Deploy a vibe coded app: where to host what the AI built
How to deploy a vibe coded app: identify what the AI built, compare built-in hosting, Vercel, PaaS and a VPS, then fix env vars, keys and URLs before launch.

Key takeaways
- Where you can host a vibe coded app depends on what the AI produced - a static build, a server app, or a front end that talks to a hosted backend such as Supabase.
- A static Vite build runs on any static host, while Next.js, TanStack Start, Express or FastAPI apps need a host that keeps a process running.
- Anything prefixed VITE_ or NEXT_PUBLIC_ is embedded in the browser bundle, so secret keys must never use those prefixes.
- A VPS with a hosting panel gives a flat monthly bill and room for databases and many sites, but you give up a global CDN and preview deployments and you run the server.
To deploy a vibe coded app, first find out what the AI actually built: a static front end (for example a Vite + React build), a full-stack server app (Next.js, Node.js, Python), or a front end that talks to a hosted backend such as Supabase. Static builds can go almost anywhere; server apps need a host that runs a process. Then pick between the tool's built-in hosting, a front-end platform such as Vercel or Netlify, a PaaS such as Railway or Render, or your own VPS, and fix environment variables, hard-coded localhost URLs and exposed keys before you launch.
This is the pillar guide of our vibe coding series. Tool-specific walkthroughs are in deploy a Lovable app to a VPS and deploy Bolt, v0 and Replit apps; the security side is covered in the vibe coding security checklist.
What kind of app did the AI build?
AI app builders all produce ordinary code, but not the same kind of code. Hosting choices follow from that, so open package.json (or requirements.txt) before anything else.
| What you see in the repository | What it is | What the host must do |
|---|---|---|
vite in dependencies, no server framework, a build script that writes dist/ |
Static single-page app (React, Vue, Svelte) | Serve files, return index.html for client-side routes |
next, @tanstack/react-start, nuxt, @remix-run/* |
Full-stack framework with server rendering | Run node permanently behind a reverse proxy |
express, fastify, hono, or fastapi, django, flask |
API or web server | Run a process, set PORT, keep it alive |
@supabase/supabase-js plus VITE_SUPABASE_URL in .env |
Front end talking to Supabase (or Lovable Cloud) | Host the front end; the database, auth and storage stay at Supabase |
Dockerfile |
Containerised app | Run a container |
Two real examples show why this matters. Lovable's own docs say apps created from May 13, 2026 use TanStack Start, which renders pages on the server, while older apps use React + Vite and render in the browser. The same product can therefore give you a static site or a server app depending on when the project was created. Replit's docs note that Static deployments are not compatible with apps created by its Agent, because the Agent builds full-stack apps that need a backend server.
Where can you host a vibe coded app?
There are four realistic options.
1. The tool's built-in hosting. The quickest path, and fine for demos:
- Lovable hosts every project at an
xxx.lovable.appaddress; custom domains are available on paid plans. - Bolt publishes to its own hosting by default, on a
.bolt.hostdomain for Free and Pro users, with custom domains for Pro users; you can switch a project to Netlify. - v0 publishes to a Vercel project, with a free
vercel.appaddress or your own domain. - Replit offers Autoscale, Static, Reserved VM and Scheduled deployments.
2. Front-end platforms (Vercel, Netlify, Cloudflare Pages). Connect GitHub, get a build on every push, a global CDN and preview URLs. Excellent for static sites and for Next.js on Vercel.
3. A PaaS (Railway, Render). Runs server apps and databases from a repository with little setup, billed by resources used.
4. Your own VPS, ideally with a panel. A fixed monthly price, room for many apps and databases, and full control. You run the server, so you also own updates, backups and monitoring.
Which option fits your app? A decision table
| Your situation | Good fit | Why |
|---|---|---|
| Prototype, sharing a link with friends | Built-in hosting | Zero setup; the tool keeps editing and hosting in one place |
| Static Vite/React build, low traffic | Cloudflare Pages, Netlify, or any VPS | Static files are cheap to serve anywhere |
| Next.js app, team wants preview URLs per pull request | Vercel | Previews and Next.js support are its core product |
| Server app plus database, no wish to touch Linux | Railway or Render | Managed processes and databases from Git |
| Several apps and sites, predictable bill, data on your own server | VPS with a hosting panel | One flat price; databases, email and SSL on the same box |
| Front end on Supabase or Lovable Cloud | Any of the above for the front end | The backend stays where it is; only the front end moves |
What does it cost? Price and control trade-offs
Prices at the time of writing (November 2026), taken from each vendor's own page:
| Option | Entry price | What to watch |
|---|---|---|
| Vercel Hobby | $0 | "For personal, non-commercial use", with usage caps you cannot buy past |
| Vercel Pro | $20 per developer seat per month | Includes $20 of usage credit and 1 TB Fast Data Transfer; beyond that from $0.15 per GB |
| Netlify | Free (300 credits), Personal $9, Pro $20 per month | Usage is measured in credits |
| Cloudflare Pages Free | $0 | 500 builds per month, 20,000 files per site, 25 MiB per file |
| Railway Hobby | $5 per month, includes $5 of usage | Memory is about $10 per GB per month and CPU about $20 per vCPU per month, billed per second |
| Render Free | $0 | Free web services spin down after 15 minutes without traffic and take about a minute to wake; free Postgres expires after 30 days |
| Hetzner CX23 VPS | €5.99 per month excl. VAT | 2 vCPU, 4 GB RAM, 40 GB NVMe, 20 TB traffic; you manage the server |
The pattern is consistent. Platforms charge little to start and more as usage, seats or always-on processes grow, and in return you get CDNs, previews and no servers to patch. A VPS is the opposite: the bill stays flat whether you run one app or fifteen, a database costs nothing extra, but nobody else is on call. If you are weighing those two sides in depth, read self-hosted Vercel alternatives and VPS vs shared hosting.
Control matters too: on your own server, user data stays on a machine you chose and every log is yours to read.
Pre-launch checklist: what breaks when AI-built code leaves the sandbox
AI tools run your app inside their own environment, where URLs, keys and ports are wired for you. These are the things that most often fail once the code runs somewhere else.
1. Environment variables
List every variable the code reads (import.meta.env., process.env., os.environ) and recreate them on the new host. In Vite, VITE_ variables are bundled into your source code at build time, so after changing one you must rebuild, not just restart.
grep -rhoE "import\.meta\.env\.[A-Z0-9_]+|process\.env\.[A-Z0-9_]+" src | sort -u
2. Hard-coded localhost URLs
Generated code often contains http://localhost:3000 or the tool's preview domain in API calls, OAuth callbacks and CORS settings.
grep -rnE "localhost|127\.0\.0\.1|\.lovable\.app|\.bolt\.host|\.repl\.co" --exclude-dir=node_modules .
Replace each hit with an environment variable or a relative URL (/api/...). If you use Supabase Auth, also change the Site URL from http://localhost:3000 to your production URL and add the new domain to Redirect URLs, as Supabase's redirect URL guide explains; otherwise email confirmations and sign-ins send people to the wrong place.
3. Exposed keys
Vite's docs are blunt: "VITE_* variables should not contain sensitive information such as API keys." The same applies to NEXT_PUBLIC_* in Next.js. Anything with those prefixes is readable by every visitor.
With Supabase, the publishable key is safe to expose because "it only reaches what Row Level Security allows", while a secret (or legacy service_role) key "bypasses every Row Level Security policy" and must never reach a browser or source control. So:
- Check that only the publishable or
anonkey appears in front-end code. - Turn on Row Level Security on every table and write policies for the
anonandauthenticatedroles. - Search the Git history, not just the current files, for keys:
git log -p | grep -E "sk-|sb_secret_|service_role". A key that was ever committed should be rotated. - Move calls to OpenAI, Anthropic, Stripe and similar APIs into a server route or an edge function.
4. CORS
If the front end and an API live on different domains, the API must allow the front end's origin. AI-generated servers often ship with cors({ origin: "*" }) or allow only localhost. Set the exact production origin, and avoid wildcards on any endpoint that uses cookies or credentials. Serving the API under the same domain (for example /api proxied to the backend) avoids CORS entirely.
5. Runtime basics
- Server apps must listen on the
PORTthe host gives them, not a fixed port. - Commit the lockfile (
package-lock.json,pnpm-lock.yaml), so the build installs the same versions you tested. - Single-page apps need the server to return
index.htmlfor routes such as/dashboard, or a reload gives a 404. - Files the app writes to disk (uploads, SQLite) disappear on many platforms at each deploy; keep them in a database, object storage or a persistent folder.
How to deploy a vibe coded app to a VPS with ZoPanel
ZoPanel is a hosting control panel for Ubuntu and Debian. Its Git deploy reads the repository, detects the framework, builds in a sandbox limited to the hosting account's CPU and memory, and switches traffic only after the new release passes a health check. Here is the whole path from an AI-built repository to a live domain.
Step 1: Get the code into Git
Sync the project from your tool to GitHub, GitLab or Gitea (Lovable, Bolt and v0 all have a GitHub option; with Cursor or Claude Code the code is already in your repository). Without Git, choose Uploaded files (File Manager) as the source and upload the project files to domains/<domain>/source with the File Manager or SFTP. If your tool gave you a ZIP export, the File Manager can extract it in that folder; then click Deploy.
Step 2: Prepare the server
Take a fresh Ubuntu or Debian VPS, install ZoPanel following the install guide, and point your domain to the server. The Free plan covers 3 hosting accounts, 10 websites and 10 databases with no time limit; see pricing.
Step 3: Create the website from Git
- Websites → New website, type Git deploy.
- Enter the Repository URL and Branch, plus the Root directory for a monorepo. For a private repository, add the deploy key shown under Deploy → Deploy key (private repositories) to the repository as a read-only key and use the
git@…URL. - Keep Free SSL (Let's Encrypt) on and click Create website.
Click Analyze repository to see the detection first. ZoPanel recognises Next.js, Nuxt, Remix, SvelteKit, Astro, Vite, NestJS, Express and other Node servers, Django, FastAPI, Flask, Laravel and more. A Vite project without a start script is served as a static site from dist; Next.js runs next start as a service; FastAPI gets uvicorn bound to 127.0.0.1:$PORT.
Step 4: Add the environment variables
Open the Deploy tab, click Paste .env, paste the production values and Save & redeploy. Variables are available both during the build and at runtime, so VITE_* and NEXT_PUBLIC_* values are embedded correctly. Do not add NODE_ENV=production yourself: ZoPanel sets it only for the running app, so devDependencies such as Vite and TypeScript still install for the build.
If the app needs a database, create PostgreSQL, MariaDB, MongoDB or Redis under Databases and paste the connection string as DATABASE_URL.
Step 5: Check routing and the health check
- For a single-page app, ZoPanel 0.4.35 and later turn on the single-page app fallback for a new website deployed from Vite, Create React App or Angular, so routes answer with status 200 on a direct visit; on an existing website, turn on Single-page app fallback on the Tools tab. Details are in static sites.
- For a server app, set Health check path to a route that answers quickly. A release must answer it with a status below 500 within 90 seconds before nginx switches to it; otherwise the previous release keeps serving.
Step 6: Deploy on every push
Turn on Deploy when main is pushed, copy the Payload URL and Secret, and add them as a webhook in GitHub (content type application/json), GitLab or Gitea. Each push now builds a new release; the last 5 are kept, and Rollback switches back without downtime. The longer version, including GitHub Actions, is in auto deploy from GitHub.
What ZoPanel does not do
Be clear about the trade-offs. There is no global CDN (put Cloudflare in front if your visitors are far away), no preview deployment per pull request, and no autoscaling: one server, with the capacity you bought. You are responsible for the server itself, so start with securing the Ubuntu VPS. In exchange, all your apps, databases, SSL and email sit on one machine at a flat price, and an optional built-in AI assistant can explain error logs using your own Anthropic API key. See the vibe coding page for the overview.
Conclusion
Deploying a vibe coded app is mostly about knowing what you have. A static build is the easiest case and runs anywhere. A server app needs a host that keeps a process alive, which narrows the choice to Vercel-style platforms, a PaaS or a VPS. A Supabase-backed front end moves without its backend. Whatever you pick, the pre-launch checklist (variables, URLs, keys, CORS, routing) is where most AI-built apps fail. If a flat bill and your own server suit you, try ZoPanel's Free plan and follow the Git deploy guide.
FAQ
Can I keep using my AI tool after moving the app to my own server?
Usually yes. Tools with two-way GitHub sync, such as Lovable, push every change to the repository, and a push webhook on your server deploys it. You keep editing in the tool and the server follows the branch.
Do I need a server, or is static hosting enough?
Check package.json. A Vite project that only builds to dist/ is static. If it lists Next.js, TanStack Start, Nuxt, Express or a Python framework and has server routes or server-side rendering, you need a host that runs a process.
Is the Supabase anon or publishable key safe in my front end?
Yes, that is what it is for, but only if Row Level Security is enabled with sensible policies, because the key "only reaches what Row Level Security allows". The secret or service_role key must never be in front-end code.
Is Vercel's free plan enough for a vibe coded app?
For a personal project, often yes. Vercel describes Hobby as "for personal, non-commercial use", so a commercial app needs Pro, at $20 per developer seat per month at the time of writing, or another host.
What is the cheapest way to host several AI-built apps?
Usually one VPS running them side by side, because the price does not grow with each app or database. The cost is your time: you maintain the server, and you do not get a CDN or previews unless you add them.
Why does my deployed app show a blank page or 404 on reload?
A blank page usually means a missing environment variable at build time or an asset path problem; read the browser console. A 404 on reload of /dashboard means the server is not returning index.html for client-side routes.
Put your servers on ZoPanel
Start free with 10 websites on a fresh Ubuntu or Debian server, or talk to our team about moving from cPanel, DirectAdmin or aaPanel and about licences for your business.
Free for 10 websites · No credit card · Installs in minutes
Keep reading

Deploy a Bolt.new, v0 or Replit app to your own server
How to deploy a Bolt.new, v0 or Replit app to your own VPS: export the code, fix what breaks outside the tool, then add a domain, SSL and auto deploy.

Deploy a Lovable app to a VPS: GitHub sync, build, domain
How to deploy a Lovable app to a VPS: sync it to GitHub, tell a Vite app from TanStack Start, keep or move the Supabase backend, then build, route and add SSL.

What is vibe coding? Tools, limits and getting to production
What is vibe coding: where the term comes from, how it works, the main vibe coding tools, their limits, and how to take a vibe-coded app to production.