v0 by Vercel

We gave v0 a single prompt: "Build a SaaS dashboard for a freelance invoice tracker, clients, invoices with line items, status workflow from draft to paid, and a revenue chart." v0 returned a working Next.js sandbox in under two minutes: sidebar nav, shadcn/ui DataTable, editable invoice detail view, Recharts revenue chart. Production-quality UI in seconds. Then we added Next-Auth. The invoice create form broke, the session token was not being passed to the API route. Three successive fixes; the third worked. Total time: 47 minutes from first prompt to a working authenticated, database-backed app. That is v0 in April 2026: fast for React-skilled developers who can read and debug the generated code; a credentialing exercise for anyone who cannot.

v0 launched in private beta in September 2023 as a "generative user interface system," attracting 100,000 waitlist signups in three weeks. Vercel had hired shadcn in July 2023 to co-build v0, and that partnership is structural: every component at ui.shadcn.com carries an "Open in v0" button, and every generation defaults to shadcn primitives. By March 2026, six million developers used the platform. The February 2026 overhaul, sandboxed runtime, Git panel, VS Code-style editor, token billing, turned it from a component generator into a full-stack agentic environment.

What v0 can actually ship in April 2026

v0 is now a browser-based, agentic full-stack environment, the component generator embedded in a system that builds, runs, and deploys complete applications without leaving the browser. The February 2026 overhaul was the largest single capability update: a sandboxed runtime that runs generated apps live in the browser (routing, layouts, interactive forms, not a static preview), a Git panel for branch creation and pull requests from the chat interface without a terminal, a VS Code-style file editor for direct code access alongside chat, and the switch from fixed credits to token-based billing.

Database integrations. Neon Postgres, Supabase, and Upstash Redis, are provisioned from the project sidebar in one click. When added, v0's AI automatically writes schema, queries, and API routes against the provisioned service. Snowflake and AWS database connectors were added in February 2026 for enterprise teams connecting existing data warehouses. Figma import (Premium and above) converts frames into shadcn/ui components, reliable for simple layouts, less so for complex auto-layout structures. One-click Vercel deployment with custom domains and environment variable management completes the workflow without leaving the browser.

Where v0 shines, and where it silently hurts you

The canonical winning workflow is boilerplate elimination for React/Next.js developers. v0 produces genuinely beautiful shadcn/ui components, correct ARIA attributes, TypeScript types, Tailwind tokens, in under 15 seconds from a prompt. The Speakeasy engineering team used this pattern for all new component work: v0 for scaffolding, Figma for design review, then integration into their existing Next.js codebase.

"v0 creates polished, responsive React components. I use it to scaffold UI and it saves me hours."

, r/nextjs community member, 2025

The failure modes are structural. The backend complexity wall: v0 generates excellent frontend code but writes raw SQL without migrations or ORM tooling, skips auth implementation details, and breaks when Marketplace database integrations are added mid-session. Adding Next-Auth after a database was connected required three iteration rounds in our test, manageable for a developer who can read the generated code, invisible to anyone who cannot. Second failure mode, the February 2026 billing shift:

"The price has been effectively multiplied by ten overnight. Last month, I managed my usage comfortably on $20. Today, I spent $20 in a single day."

. Vercel Community forum, "V0.dev Has Become Unusable and Unethical. Demanding a Refund," 2026

A second user in the same thread reported paying "$5 to fix a '{'", the Max model correcting a syntax error the standard model introduced. The third failure mode is no session memory: v0 has no memory across conversations, loses architectural context between sessions, and contradicts prior decisions when prompted in a new conversation.

Language and framework support: the reality check

v0 is React and Next.js. This is not a limitation you can work around, it is an architectural choice baked into every layer of the platform. Generated code uses React JSX, TypeScript, Tailwind CSS, and shadcn/ui primitives. The deployment target is Vercel. The database integration partners are Neon, Supabase, and Upstash, all Vercel-recommended canonical choices for Next.js applications. If your project is Vue, SvelteKit, or Astro, or if you are deploying to AWS or Railway, v0 is not your tool. You can export generated code and reconfigure deployment manually, but you are working against the product's grain.

Within the Next.js stack, v0 supports the full modern surface area: App Router, Server Components, Client Components, route handlers, server actions, and the middleware layer. The agentic mode handles multi-file architectural decisions consistently. Where framework support decays is in TypeScript strictness: generated code compiles and runs but occasionally produces imprecise or over-permissive types that need review before merging into a codebase with strict mode enabled. shadcn/ui version awareness is reliable, v0 generates against the current component API and correct import paths, but if your project is on an older shadcn version, generated components will use APIs that may not exist yet in your install.

A real workflow: using v0 on a Next.js SaaS landing page

The generate-then-integrate workflow is the correct mental model for v0. Not: "use v0 to build my entire app autonomously." Correct: "use v0 to eliminate the boilerplate for each component, then integrate into my project."

Start a new project in v0.app. Describe the component you need: "Build a client list component with a data table, name, email, total invoiced, status badge (active/inactive), and an action menu." v0 generates the following using shadcn/ui primitives:

// Generated by v0. Client data table with shadcn/ui
// Prompt: "client list table with name, email, total invoiced, status badge, action menu"

import {
  Table,
  TableBody,
  TableCell,
  TableHead,
  TableHeader,
  TableRow,
} from "@/components/ui/table"
import { Badge } from "@/components/ui/badge"
import {
  DropdownMenu,
  DropdownMenuContent,
  DropdownMenuItem,
  DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu"
import { Button } from "@/components/ui/button"
import { MoreHorizontal } from "lucide-react"

type Client = {
  id: string
  name: string
  email: string
  totalInvoiced: number
  status: "active" | "inactive"
}

export function ClientTable({ clients }: { clients: Client[] }) {
  return (
    
      
        
          Name
          Email
          Total Invoiced
          Status
          
        
      
      
        {clients.map((client) => (
          
            {client.name}
            {client.email}
            
              {new Intl.NumberFormat("en-US", {
                style: "currency",
                currency: "USD",
              }).format(client.totalInvoiced)}
            
            
              
                {client.status}
              
            
            
              
                
                  
                    
                    Open menu
                  
                
                
                  View invoices
                  Edit client
                  
                    Archive client
                  
                
              
            
          
        ))}
      
    
  )
}

This is representative v0 output: correct TypeScript types, accessible sr-only ARIA label, Intl.NumberFormat currency formatting, Lucide icon integration, and Tailwind tokens mapped to the shadcn CSS variable layer. It drops directly into any Next.js + shadcn/ui project without modification. Generation time: under 15 seconds on the Premium plan. If the component needs database connectivity, add a Neon or Supabase integration from the sidebar and v0 will generate the server-side data-fetching layer against the provisioned schema. Use the Git panel to commit the component to a feature branch and open a pull request. The deploy preview appears in the PR automatically from Vercel. This is the workflow at its best, fast, coherent, and ready to review before merging.

Where to stay careful: multi-round sessions accumulate cost. The token billing model charges on both input and output; long sessions on the Pro or Max model burn credits at rates that are not visible in advance. Treat sessions as discrete units, generate, review, commit, close, rather than leaving the same conversation open all day.

Security, licensing, and code leakage

In July 2025, Okta Threat Intelligence researchers documented v0 being weaponized for phishing. Attackers prompted v0 to generate pixel-accurate clones of Okta, Microsoft 365, and cryptocurrency wallet login pages, then hosted them on Vercel's own infrastructure to exploit its trusted domain reputation. Okta noted that v0 "allows emerging threat actors to rapidly produce high-quality, deceptive phishing pages, increasing the speed and scale of their operations." Vercel blocked the documented pages and announced third-party abuse reporting mechanisms with Okta, but the incident revealed a clear gap: login-page cloning was not detected as an abuse pattern.

In April 2026, Vercel disclosed a supply chain breach: attackers compromised Context.ai, a third-party AI tool used by a Vercel employee, gained access to their Google Workspace account, and enumerated non-sensitive environment variables from Vercel's systems. The ShinyHunters persona listed the stolen data for $2 million on BreachForums. Vercel confirmed (TechCrunch, April 20, 2026) that sensitive environment variables showed no evidence of access and shipped emergency security updates. The breach directly affects developers who store API keys and database credentials as v0 environment variables, rotating secrets after any confirmed Vercel incident is prudent.

On training data: Free opts in by default; Premium opts out by default; Business enforces opt-out. Generated code belongs to the user.

v0 vs. Lovable vs. Bolt.new

Lovable is v0's most direct full-stack competitor. Lovable generates a complete React + Supabase application from a prompt, authentication, database, and deployment included by default, and gives full GitHub code ownership with a clean exit path. v0 produces higher-quality shadcn/ui output; Lovable produces more complete backend architecture without Marketplace configuration. For a non-developer building a SaaS MVP, Lovable requires fewer manual steps to a working app. For a developer already in the Next.js ecosystem who wants to generate components against an existing stack, v0 is the stronger fit.

Bolt.new by StackBlitz competes on speed and billing transparency. Bolt runs in-browser via WebContainers and shows code as it generates, the best option for developers who want to learn while building. Bolt's token-metered pricing is more predictable for estimating session cost in advance. The key difference: Bolt requires external hosting while v0 deploys to Vercel natively. Bolt supports Vite, Astro, and SvelteKit beyond Next.js; v0 is React/Next.js only. Outside the Vercel ecosystem, Bolt wins on flexibility. Inside it, v0's native deploy and shadcn/ui quality are the edge.

A Vercel Community thread running throughout 2025 raised a third comparison: "Why should I keep paying for Vercel when I can use Cursor an unlimited number of times for $20 a month?" Cursor is a local IDE assistant, the comparison is imprecise, but the value gap is real. Cursor's $20/month provides effectively unlimited AI code assistance in your existing codebase. v0's $20 provides $20 in tokens that burn on complex sessions.

Pricing for solo devs, teams, and enterprise

v0's February 2026 billing switch to token-based pricing changed the economics sharply. Token cost scales with model tier and prompt complexity. Simple component generations cost fractions of a cent; complex multi-file agentic builds on the Pro or Max model run $1–$5 per session. The core complaint: v0 does not show a cost estimate before a generation runs.

Free: $5/month in credits, 7 messages/day, v0-1.5-md model, an evaluation tier, not a working one. Premium ($20/month): $20/month in credits, unlimited messages, v0-1.5-lg model, Figma import, API access, training opt-out by default. Multiple users burned through the $20 allocation in three days or fewer after the February 2026 switch. Team ($30/user/month): shared credit pool, $2/day bonus credits, centralized Vercel billing. Business ($100/user/month): enforces training data opt-out by default, the primary governance feature over Team. Enterprise (custom): SSO, SLAs, dedicated support, no model training on customer data.

Vercel lock-in applies across all plans. The Git-to-deploy workflow ends at the Vercel boundary. Teams on AWS, Railway, or Render can export the generated code and deploy independently, but lose the integrated loop that makes v0 fast.