How to Deploy a v0 App: Four Hosting Options

v0 is Vercel's AI UI generator. By default, one click publishes your app to Vercel's servers. But you don't have to stay there. You can export your v0 app and deploy it to Northflank, self-hosted Coolify, your own VPS, or a flat-rate platform like Ship. Each path trades setup time against cost predictability and platform lock-in.

What is v0? Why Export It?

v0 is Vercel's tool for building full-stack web apps with AI. It generates Next.js code. The default deployment sends your app to Vercel's infrastructure. Exporting means taking that code and running it on your own platform instead.

v0 launched in 2023 and fills a real gap: non-developers can describe a web app in plain language and get working Next.js code back. That's powerful. The catch: by default, your app lives on Vercel servers at Vercel's pricing. If your app grows, Vercel's costs scale with traffic. A heavy day can hurt.

But here's the honest part: Vercel is fast. Their edge network is genuinely good. If you don't mind their pricing model and you trust their platform, there's no reason to leave. This guide is for the other case: you want to keep the app, not the platform contract.

Exporting v0 means:

1. Generating the full source code from v0
2. Running it locally to test
3. Pushing to GitHub (or your own Git repo)
4. Deploying to a platform of your choice

The code is always just Next.js. Any host that runs Node.js can run it.

Why Move Off Vercel? The Three Reasons

1. Cost predictability -- Vercel bills on traffic (invocations, execution time, bandwidth). A traffic spike can spike your bill. Some businesses prefer flat-rate or per-compute pricing.

2. Data residency -- You may need your app to run in the EU for GDPR compliance. Vercel's free tier runs globally; you must pay extra for EU-only servers.

3. Lock-in avoidance -- Vercel's serverless functions and edge deployment are great, but they're Vercel-specific. If you move, rewriting is painful. Generic hosting (Docker, Node.js, Next.js) is portable.

None of this means Vercel is bad. It's a tradeoff. You're choosing control and predictability over one-click simplicity and global edge caching.

Your Four Deployment Paths at a Glance

Path	Platform	Cost	Setup Time	Best For
1	Vercel	Variable ($0-hundreds)	30-60 sec	Fastest path, high traffic, global edge
2	Northflank	~$24/mo (starter)	15 min	Balanced: managed scaling, cost control
3	Ship	EUR 10-20/mo	15 min	Flat-rate, GDPR, zero DevOps
4	Coolify	$0 (platform) + $2.99-10/mo (VPS)	30-45 min	Cheapest, you manage updates
5	DIY VPS	$4-20/mo	45-90 min	Ultimate control, steepest learning curve

We'll walk through each.

Path 1: Deploy to Vercel (The Default, 30-60 Seconds)

If you haven't already, this is the fastest path. Inside v0, click Publish. Choose "Publish to Production." Vercel handles the rest: code is pushed to Vercel's Git, your app builds, and it's live at a free yourapp.vercel.app subdomain within seconds.

No setup. No terminals. No Git knowledge required. This is why v0 users often don't realize they have alternatives.

The cost: free for static sites and light apps. For heavier traffic, you pay for compute, database connections, and bandwidth. Vercel's pricing page doesn't show a simple calculator; you're charged on consumption.

When to use Vercel: You're building a prototype, personal project, or you expect high traffic and can afford variable costs.

When to skip it: You want predictable monthly bills or you need EU-only data residency.

Path 2: Managed Hosting -- Northflank or Ship (15 Minutes)

This is the middle ground: more setup than Vercel, less ops burden than self-hosting.

Northflank

Northflank is built on managed Kubernetes. Start at $24/month for a basic plan (nf-compute-100-2). You get a built-in database, built-in Redis, and automatic scaling. No surprise bills from traffic spikes; your plan caps your compute.

To deploy to Northflank:

1. Export your v0 app (v0 menu Export Code)
2. Create a GitHub repo and push the exported code
3. Create a Northflank account
4. Connect your GitHub repo (one click)
5. Configure environment variables (database URL, API keys)
6. Deploy

Northflank builds your image and runs it. You can scale replicas if needed, but you control the cost tier. Enterprise plans start at $480/mo, but most small apps run on the $24 tier.

Ship

Ship is Opsily's offering: flat-rate managed hosting. EUR 10-20/month, no surprises. GDPR-compliant (data stays in the EU by default). Zero DevOps: you push code, Ship handles the rest.

To deploy v0 to Ship:

1. Export your v0 app
2. Push to Git
3. Connect Ship to your repo
4. Ship auto-detects Next.js and builds it
5. Custom domain, SSL, built-in--done

Ship is honest about its limits: it's good for apps under 10K monthly active users and < 2GB data. For larger apps, you graduate to Northflank or your own infrastructure. That's the tradeoff: simplicity at the cost of a ceiling.

The advantage: you know your monthly bill. No math required.

When to use: You want flat-rate pricing and GDPR compliance.

For more detail on export workflows and comparing these options, see our guide on exporting v0 to self-hosted options.

Path 3: Self-Hosted on Coolify (30-45 Minutes, Cheapest)

Coolify is open-source (7,200+ GitHub stars). It's a one-click deployment tool for your own VPS. Install Coolify on a $4-10/month VPS (e.g., DigitalOcean), and you can deploy unlimited apps for the cost of the server.

Total cost: $2.99-10/mo (VPS) + $0 (Coolify is free).

To deploy v0 on Coolify:

1. Export your v0 app
2. Build locally (npm run build) to test
3. Push to GitHub
4. Rent a VPS (DigitalOcean, Linode, Hetzner)
5. Install Coolify on the VPS (one script)
6. In Coolify UI, connect your GitHub repo
7. Configure environment variables
8. Coolify builds, deploys, and manages SSL

Coolify handles Docker builds and restarts. You don't write Docker files (Coolify auto-detects Next.js). It's the bridge between "I want to self-host" and "I want to avoid DevOps."

The catch: if the VPS goes down, you fix it (or learn to). Coolify updates need attention. Database backups are your job. These are small, but they're real.

When to use: You're technically comfortable with Linux basics and want the cheapest option.

For cost-benefit analysis and infrastructure choices, check our post on the cheapest way to host a full-stack app.

Path 4: DIY on a Bare VPS (Advanced, 45-90 Minutes)

This is for people who want ultimate control. You buy a VPS, install Node.js, install PostgreSQL, configure Nginx, set up SSL, handle backups, and manage updates yourself.

Cost: $4-20/mo for the VPS. Time: 45-90 minutes to set up (first time), plus ongoing maintenance.

I'm not walking through this step-by-step here; it deserves its own guide. But the path is: rent a VPS, git clone your app, npm install && npm run build, run it with PM2 or systemd, point a domain, configure Nginx, set up Let's Encrypt SSL.

It's the cheapest and most flexible. It's also the most work.

When to use: You already run your own infrastructure and want to keep this app in the same ecosystem.

When to skip it: You're a founder with a business to run. Your time is worth more than the $15/mo you'd save over Northflank.

Common Gotchas and How to Fix Them

1. npm run build fails locally -- Check your Node version matches v0's requirement (usually 18+). Run node --version. If wrong, use nvm to install the right one. Also check for missing environment variables--v0 apps often need API keys at build time.

2. Database won't connect after deploy -- This is the number one gotcha. Your local .env file is not copied to your host. You must set environment variables on the platform (Northflank dashboard, Ship settings, Coolify config). Don't check .env into Git. Use .env.example and document what secrets are needed.

3. v0 exported multiple component files -- v0 sometimes generates a main component plus helper components spread across files. Some platforms struggle with this (especially if you upload a ZIP instead of pushing Git). Ask v0 to "combine this into one self-contained component" before exporting.

4. Forgot to export environment variables -- Your app works locally but fails in production with "API key is undefined." The platform doesn't auto-read your local .env. You must explicitly set each var in the platform's dashboard (or via CLI).

5. Custom domain DNS times out -- You pointed your domain's DNS to your new host, but it's not resolving. DNS propagation takes 5-30 minutes globally. Wait. Don't panic and revert. Check with dig yourdomain.com to see if your host's nameserver is showing up yet.

6. App runs locally but crashes on deploy -- Common causes: Node version mismatch, missing package.json dependencies (you didn't push node_modules, but you also didn't commit package-lock.json), or your app reads files from the filesystem that don't exist on the host. Check the host's logs (every platform has a log viewer).

Frequently Asked Questions

Is v0 owned by Vercel?

Yes. v0 is Vercel's product. Vercel built it, maintains it, and controls its roadmap.

What's the difference between v0 and Vercel?

v0 builds UI code. Vercel hosts it (and much more). You can use v0 to generate code and deploy it anywhere (not just Vercel).

Can I use v0 for free?

Yes. v0.dev is free. You get unlimited AI generations. Hosting costs depend on your platform. Vercel's free tier is free; Northflank's starter is $24/mo; Coolify is free (VPS costs money).

Is Vercel really expensive?

Not for small projects. For production traffic (10K+ requests/day), costs add up. Enterprise plans run hundreds per month. It's usage-based, so bills are hard to predict.

What can I use instead of Vercel?

Northflank (managed Kubernetes), Ship (managed flat-rate), Coolify (self-hosted), Railway, Render, DigitalOcean App Platform, or a bare VPS.

How much does a v0 app cost to host?

Depends on your path. Vercel: free-hundreds. Northflank: $24/mo starter. Ship: EUR 10-20/mo. Coolify: $2.99/mo (VPS only). DIY VPS: $4-20/mo.

Can I deploy my app for free?

If the app is static (no backend), yes: Vercel, Netlify, GitHub Pages. If it has a backend, you're either paying (managed hosting) or doing ops work yourself (free platform, paid VPS).

The Bottom Line

You have control. v0's default is Vercel, but that's not your only option. Pick the path that fits your priorities.

Vercel if you want speed and global scale and don't mind variable costs. Northflank or Ship if you want managed infrastructure and cost predictability. Coolify if you're comfortable with Linux basics and want the cheapest hosting. A bare VPS if you're building your entire ops stack yourself.

The code is always just Next.js. No matter which platform you choose, your v0 app will run. The difference is how much you pay, how much you maintain, and how locked in you are.

Ship hosting is the middle path we built: flat-rate (EUR 10-20/mo), GDPR by default, zero DevOps required. Ship managed hosting removes the guesswork.