# 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.

Source: https://zopanel.net/blog/deploy-vibe-coded-app  
Updated: 2026-11-09

## 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](/blog/deploy-lovable-app-vps) and [deploy Bolt, v0 and Replit apps](/blog/deploy-bolt-v0-replit-app); the security side is covered in the [vibe coding security checklist](/blog/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](https://docs.lovable.dev/introduction/faq). 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](https://docs.replit.com/features/publishing/deployment-types), 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.app` address; [custom domains are available on paid plans](https://docs.lovable.dev/features/custom-domain).
- Bolt publishes to its own hosting by default, on a `.bolt.host` domain for Free and Pro users, with [custom domains for Pro users](https://support.bolt.new/bolt-cloud/hosting); you can switch a project to Netlify.
- v0 publishes to a [Vercel project](https://v0.app/docs/deployments), with a free `vercel.app` address or your own domain.
- Replit offers [Autoscale, Static, Reserved VM and Scheduled deployments](https://docs.replit.com/features/publishing/deployment-types).

**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](https://vercel.com/pricing) 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](https://www.netlify.com/pricing/) | Free (300 credits), Personal $9, Pro $20 per month | Usage is measured in credits |
| [Cloudflare Pages](https://developers.cloudflare.com/pages/platform/limits/) Free | $0 | 500 builds per month, 20,000 files per site, 25 MiB per file |
| [Railway](https://railway.com/pricing) 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](https://render.com/docs/free) 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](https://www.hetzner.com/cloud/cost-optimized/) 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](/blog/self-hosted-vercel-alternative) and [VPS vs shared hosting](/blog/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](https://vite.dev/guide/env-and-mode), so after changing one you must rebuild, not just restart.

```bash
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.

```bash
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](https://supabase.com/docs/guides/auth/redirect-urls) 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](https://supabase.com/docs/guides/api/api-keys) 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 `anon` key appears in front-end code.
- Turn on Row Level Security on every table and write policies for the `anon` and `authenticated` roles.
- 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 `PORT` the 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.html` for 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](/docs/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](/docs/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](/docs/install), and [point your domain to the server](/blog/point-domain-to-vps). The Free plan covers 3 hosting accounts, 10 websites and 10 databases with no time limit; see [pricing](/pricing).

### Step 3: Create the website from Git

1. **Websites → New website**, type **Git deploy**.
2. 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.
3. 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](/docs/static-sites#single-page-apps-client-side-routing).
- 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](/blog/git-auto-deploy).

### What ZoPanel does not do

Be clear about the trade-offs. There is no global CDN (put [Cloudflare in front](/blog/cloudflare-with-vps) 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](/blog/secure-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](/vibe-coding) 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](/pricing) and follow the [Git deploy guide](/docs/git-deploy).

## 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.
