Bolt.new Fastest idea-to-app

What Bolt.new actually is

Bolt.new is StackBlitz's prompt-to-full-stack-app builder. You describe an application in plain English — "a task manager with a Kanban board and user auth" — and Bolt generates the code, installs the dependencies, starts the dev server, and shows you a live preview, all without you touching a terminal or a config file. The entire development environment runs inside your browser tab.

StackBlitz built a technology called WebContainers — a full Node.js runtime that executes natively in the browser using WebAssembly. Bolt is the product that puts WebContainers in front of a language model. When you prompt Bolt, the AI doesn't just generate code and hand it back to you. It runs the code. It installs npm packages. It starts a Node server. It reads the error output from the terminal and fixes itself. The loop from prompt to running app is measured in seconds, not minutes.

Bolt launched publicly in late 2023 and grew rapidly through 2024 and 2025, becoming one of the most-used tools in the "vibe coding" wave — the broader trend of non-technical founders building working software through conversation with an AI. By 2026 it has added native mobile support via Expo, one-click deployment to Netlify, Vercel, and Cloudflare, direct Supabase and Stripe integrations, and a model lineup anchored by Claude with adjustable reasoning depth.

The key thing Bolt is not: it is not a coding assistant for existing codebases. It does not index your repo. It does not suggest the next edit in your IDE. Bolt is a greenfield builder. You start from a prompt, not from a codebase. If you already have production code and you need AI help editing it, look at Cursor or Claude Code. If you need a working prototype by tomorrow morning, Bolt is the right tool for the job.

The WebContainers edge — why in-browser matters

Most AI app builders work through server-side sandboxes. You submit a prompt, a container spins up somewhere in the cloud, code runs there, and the result comes back to you. That model has latency, has cold-start delays, and means you're dependent on the provider's infrastructure availability.

WebContainers changes the architecture entirely. The Node.js runtime runs in your browser tab using WebAssembly. There is no round-trip to a container. Code execution happens on your machine — with your CPU, your memory, your connection to the internet. The practical effects:

• Iteration speed is fast even on slow connections — the execution environment is local, so after the initial load, recompile loops are near-instant.
• No cold starts — the environment is always "warm" as long as your tab is open.
• Full npm ecosystem — Bolt can install any package from the npm registry. Not a curated subset, not a whitelist. Any package that runs in Node runs in Bolt.
• Real terminal output — when something fails, you see the actual stack trace. Bolt reads that output and fixes itself in the next edit. The debugging loop is tight.
• No local setup — zero. You open bolt.new in a browser. That's the entire onboarding. Someone with no developer tooling on their machine can be looking at a running React app in three minutes.

This architecture is genuinely different from what Replit does (which runs in cloud VMs), what Lovable does (server-side generation), and what v0 does (component generation without a runtime). The in-browser runtime is Bolt's structural moat. It's the reason the first-time experience feels like magic and the reason competitors haven't simply copied it — WebContainers is a multi-year engineering project, not an integration layer.

First five minutes

Open bolt.new. No signup required to start — you get a prompt field. Type anything. The canonical "show me what you can do" prompt is a simple one: "Build a SaaS landing page with a pricing table, waitlist form, and dark mode toggle."

What happens next is the moment that converts skeptics. Bolt generates the component tree, writes the Tailwind classes, starts a Vite dev server, and renders the result in a preview panel — all within about 20 seconds. The output isn't a mockup. It's running code. You can open the preview in a full browser tab. You can inspect the DOM. You can edit the generated files directly in the in-browser editor if you know what you're doing.

Then you iterate. "Make the pricing table three-column. Add an annual/monthly toggle. Make the CTA button green." Each follow-up prompt re-runs in seconds. Bolt doesn't regenerate the entire app — it diffs the existing files and applies targeted edits. This is critical. Late-stage prompt sessions don't wipe your work; they refine it.

The free tier — 1 million tokens per month with a 300K daily limit — is enough to build one substantial app, but you'll feel the walls. If you hit the daily cap mid-session, you stop. The 300K daily limit is the sharpest edge of the free plan. One complex app can consume that in a single afternoon of active prompting. The free tier is honest for evaluation; it's not built for production prototyping speed.

bolt-new · bolt-builder.png

Framework and stack support

Bolt is not opinionated about your stack. The framework list covers everything widely used in 2026:

• Frontend: React, Next.js, Vue, Svelte, Astro, Remix, Solid, Angular
• Backend: Express, Fastify, Hono, tRPC (via Next.js or standalone)
• Styling: Tailwind CSS, CSS Modules, styled-components, vanilla CSS
• Databases: Supabase (first-class integration with auth, real-time, and storage), Firebase, PlanetScale, and direct Postgres via connection string
• Auth: Supabase Auth, Clerk, NextAuth — all generation-ready
• Payments: Stripe — Bolt can scaffold checkout sessions, webhooks, and subscription logic
• Mobile: Expo (React Native) — beta but functional, covered below

The best-supported stack in practice is React + Tailwind + Supabase. The Supabase integration is tight: Bolt scaffolds the schema, generates the client calls, and wires up auth flows as a unit. If you're building a standard SaaS-shaped product — user accounts, data stored per user, some kind of dashboard — this combination produces clean, working code faster than any other tool in the space.

Next.js App Router support is solid for standard patterns. Server components, route handlers, and metadata — Bolt handles these correctly. Where it gets shaky: complex layout compositions, advanced RSC data-fetching patterns, and any time you push into nuanced Next.js edge cases. For most apps, it won't matter. For a sophisticated production Next.js app, you'll find yourself correcting Bolt's assumptions.

Three real workflows, end-to-end

Real prompt, real output

We gave Bolt this prompt on a fresh session:

Bolt returned this file tree and had it running in the preview pane in 18 seconds:

The custom hook pattern was the right call — separating the persistence logic cleanly. The component split was sensible. The summary card calculated monthly totals correctly without prompting. This is the quality level you get on clean, well-scoped prompts: professional-shaped code that a developer would recognize as reasonable structure, not just a working mess.

bolt-new · bolt-app.png

Mobile and Expo — the newest frontier

In early 2025, Bolt announced a partnership with the Expo team and launched native mobile app support. As of 2026 the integration is in active development, but it's functional: you can prompt Bolt for a React Native app, and it scaffolds an Expo project that runs on a real device via the Expo Go app.

The pitch from StackBlitz: "Build iPhone apps from Windows." That's not marketing hyperbole — WebContainers running React Native via Expo actually delivers this. The traditional barrier to mobile development (Xcode required for iOS development, macOS required for Xcode) is sidestepped. You write prompts in a browser on any OS and scan the QR code with your phone.

The reality in 2026 is more nuanced. Expo integration covers the common patterns well: navigation (Expo Router), basic UI components, camera and notifications via Expo SDK. Where it gets rough is anything platform-specific or where React Native performance characteristics matter — lists with thousands of rows, custom animations, native modules. For those cases you'll need to export the project and work locally. But for prototyping an idea or building a simple utility app, the Expo path inside Bolt is genuinely viable.

The App Store and Google Play deployment path via Expo Application Services (EAS) is in active beta. Early users report it works, but needs manual review before anything you'd ship commercially. Treat it as "this will get you to TestFlight" rather than "this will get you to the App Store without touching anything."

Token burn reality

This is the section most reviewers gloss over. Token economics in Bolt are the biggest friction point for regular use, and you need to understand them before committing to a plan.

Bolt's pricing is denominated in tokens. Tokens are consumed by every prompt you send, scaled primarily by the size of your project's current codebase. The AI needs to read your entire project context to make changes — the larger the project, the more tokens that read costs, before the edit itself is even computed. This has a compounding effect: as your app grows through iterations, each subsequent prompt gets more expensive to run, even if you're asking something simple.

What this means in practice:

• A fresh, small project: a complex prompt might cost 15,000-30,000 tokens.
• A mature project with 40+ files: the same prompt might cost 80,000-150,000 tokens — entirely because of project context size.
• The free tier's 300K daily limit can evaporate in two to four prompts on a large project.
• The Pro plan's 10M monthly tokens sounds generous, but a power user building multiple projects can consume that in two active weeks.

The additional token reload pricing: if you're on an annual Pro subscription, you can buy 10M additional tokens for $20. At that math, 100M tokens over a month of heavy use would cost $200 in reloads on top of the base plan. That's the ceiling case — most users won't hit it — but it's the number to know if you're an agency planning to use Bolt for multiple client projects simultaneously.

Pricing, in real terms

Bolt uses a three-tier public pricing structure verified as of June 2026:

Free — $0/month

1 million tokens per month. Hard 300K daily limit. Bolt branding on deployed sites, no custom domain, 10MB file upload cap. Enough to evaluate seriously and build one small app. Not enough for a project with momentum. The branding restriction alone is a reason to upgrade before sharing anything with customers or investors.

Pro — $25/month

10 million tokens per month, no daily limit. Custom domain support, Bolt branding removed, 100MB file upload cap, SEO features, AI image editing, choice of database provider, private site sharing. Unused tokens roll over for one additional month. This is the plan that makes sense for individual founders and developers. The absence of a daily cap is the critical difference — you can sprint on a project when inspiration hits without worrying about hitting a wall at 4pm.

Teams — $30/member/month

Everything in Pro, plus centralized billing, team-level access management, organization-level project sharing, private NPM registries, and per-package design system knowledge. For a two-person founding team who wants to work on Bolt projects collaboratively, this starts at $60/month — a reasonable overhead if you're in active build mode.

Enterprise — custom

SSO, audit logs, compliance tooling, dedicated support, flexible billing. Contact sales.

Annual billing saves 10% on all paid plans. If you're past the evaluation phase and building regularly, the annual discount is worth taking.

The honest value comparison: Bolt Pro at $25/month is cheaper than Lovable's equivalent tier ($20/month for Lovable Starter, but with tighter token caps), roughly comparable to v0's paid tier, and significantly cheaper than Replit's Core plan ($25/month). The token economy is less predictable than a flat seat price, but for a solo builder doing one or two active projects at a time, $25/month is reasonable for what you get.

Bolt vs v0 by Vercel

bolt-new · bolt-prompt.png

Bolt vs Lovable

Bolt vs Replit

Where Bolt gets it wrong

Design ceiling

Bolt's default output is functional but visually generic. When you ask for a dashboard, you get a dashboard-shaped app with Tailwind defaults — correct structure, predictable spacing, competent layout. What you don't get is the visual personality that makes a product feel opinionated. If your first user is an investor, Lovable's output will impress faster. If your first user is a paying customer who cares whether it works, Bolt's output is fine.

Context drift on long sessions

After 20+ prompts on a single project, Bolt's understanding of your app starts to drift. It will occasionally reintroduce a UI pattern you explicitly removed three prompts ago, or apply a style to a component that already has conflicting styles. The fix is periodic cleanup prompts ("audit the styling across all components and make it consistent") but it's friction that accumulates on long projects. This is not unique to Bolt — it's an inherent challenge of stateful prompt sessions — but it's worth knowing before you start your fifteenth iteration on a complex project.

Token unpredictability

Already covered in the token burn section, but worth naming as a failure mode: the lack of pre-prompt cost estimation is a genuine UX problem. You cannot plan a prototyping session with confidence. A power user who knows the system learns to start fresh projects rather than extending large ones, but a new user will get a shock when their afternoon's work burns through a week's token budget.

Production readiness gap

Bolt-generated code works but is rarely production-ready out of the box. Security considerations are often shallow: RLS policies may be incomplete, rate limiting isn't added unless you ask, and environment variable handling varies. A 2025 Veracode study found 45% of AI-generated code samples had basic security issues. Bolt isn't worse than the industry average here, but it's not better either. Anything you're putting real users on needs a security pass by a developer, not just a Bolt session.

Large codebase degradation

Bolt is a sketchbook, not a production IDE. As codebases grow past a certain size — roughly 50-70 files with complex interdependencies — Bolt's suggestions become less reliable, the token cost per prompt climbs sharply, and the time from prompt to preview increases. The right workflow is to use Bolt for the first 70% of a project's life, export to GitHub when it's getting complex, and move to a real development environment for the hardening phase.

bolt-new · bolt-pricing.png

Who Bolt is for — and who should skip it

Build in Bolt if you are

• A non-technical founder who needs an MVP to validate an idea before hiring a developer
• A technical founder who wants to prototype fast without setting up infrastructure
• A developer building a hackathon project under time pressure
• A freelancer who needs a quick client demo and can hand off the exported code
• A mobile app builder who needs to sketch an idea without owning a Mac
• Anyone who needs to go from zero to deployed in the same afternoon

Skip Bolt if you are

• Building a system that will handle sensitive user data and needs serious security review
• Working on an existing codebase that already has hundreds of files and conventions
• A team of more than three developers who need code review and branching workflows
• Someone whose users will judge the product immediately on visual polish and brand feel
• Building a backend-heavy app where the logic lives in APIs, not UI

FAQ

The verdict

Alternatives worth considering