TL;DR: You built an app with Cursor, Lovable, Replit, or Bolt. It runs on localhost. Now you need it on the internet. The default advice is Vercel + Supabase, but that path gets expensive fast ($50-100/mo at production scale). A $6-12/mo VPS with a native database, a free domain SSL via Caddy or Certbot, and a simple GitHub Actions deploy pipeline gives you more control, fixed pricing, and no surprise overages. This guide covers every option with real monthly costs so you can pick the right path for your project.

Table of Contents

• The Last Mile Problem
• Where Your App Lives: Hosting Options Compared
• Where Your Data Lives: The Database Problem
• The Setup I Recommend for Most Projects
• The Vercel + Supabase Path (And What It Actually Costs)
• Domain, SSL, and DNS
• What About CI/CD?
• FAQ
• Conclusion

The Last Mile Problem

You spent a weekend vibe coding with Cursor, Lovable, or Replit Agent. The app works. The UI looks great. You can click through it on localhost and everything behaves exactly the way you described it in your prompt. You are riding the high of shipping something real without writing much code yourself.

Then you try to put it on the internet, and everything stalls.

This is the last mile problem of vibe coding, and it is where most AI-built projects die. Not because the code is bad, but because deployment is a different skill than building. Your AI coding assistant generated a working Next.js app or a Flask project or a Rails app. It did not generate a server, a database host, a domain configuration, SSL certificates, or a deployment pipeline.

The vibe coding tutorials and YouTube videos almost always stop at "and here it is running locally." The comments are full of people asking "how do I actually put this online?" and getting vague answers about Vercel or Railway.

This guide is the answer to that question. We are going to cover every option for hosting your app, hosting your database, setting up a domain, and automating deploys. Every option includes real monthly costs. No referral links, no affiliate bias -- just the numbers.

If you are still deciding on your tech stack for vibe coding, start there first. This article assumes you have a working app and need to get it live.

Where Your App Lives: Hosting Options Compared

The first decision is where your application code runs. Here are the realistic options in 2026, with actual pricing:

What these tiers actually mean

Vercel and Netlify are optimized for frontend frameworks. If your vibe-coded app is a Next.js project with API routes, Vercel is a natural fit. But you are locked into serverless functions for your backend logic, which means no long-running processes, no WebSockets (without workarounds), and no persistent filesystem. If your AI assistant generated a traditional server app (Express, Flask, Django, Rails), Vercel is not the right choice.

Railway and Render are closer to traditional hosting. You push your code, they build and run it. Railway uses usage-based pricing, which means your bill fluctuates with traffic. Render offers a flat $7/mo web service tier that is more predictable.

A DigitalOcean VPS (or equivalent from Hetzner, Linode, or Vultr) gives you a full Linux server for $6/mo. You can run anything on it: any language, any framework, any database. The tradeoff is that you set it up yourself. But in 2026, "set it up yourself" means running 5-10 commands, not managing a rack in a data center.

The bottom line: If your app is a Next.js frontend with a few API routes, Vercel or Netlify work. For everything else -- Python apps, Ruby apps, apps that need a real database running alongside them, apps that need background workers -- a VPS or Railway/Render is the move.

Where Your Data Lives: The Database Problem

This is where most vibe-coded deployments go wrong.

Your app works on localhost because it connects to a local database -- SQLite, MySQL, or Postgres running on your machine. When you deploy to Vercel or Netlify, that database does not come with you. Worse, if your app uses SQLite (which many AI-generated apps default to), it will appear to work on these platforms and then silently lose data. Vercel and Netlify use ephemeral filesystems. Your SQLite file gets wiped on every deploy or container restart.

This is not a theoretical problem. It is the single most common failure mode for first-time deployments of vibe-coded apps.

Your database needs a real, persistent home. Here are the options:

Fixed-price managed providers (your bill is the same every month):

Usage-based platforms (your bill grows with traffic):

The free tier trap

Free database tiers are designed for demos, not production. Supabase pauses your database after 7 days of inactivity on the free plan. Neon's free tier has compute hour limits that will throttle your app during traffic spikes. PlanetScale removed their free tier entirely.

If you are building something that needs to stay online -- even a side project with a handful of users -- you are paying for your database. The question is how much and how predictably. For a deeper look at this pattern, see our breakdown of free tier traps in vibe coding.

Fixed vs. usage-based pricing

This matters more than most people realize when they deploy their first app. Usage-based pricing (Supabase, Neon, PlanetScale, Railway) means your bill goes up when your app gets traffic. That sounds fair in theory. In practice, it means you cannot predict your monthly costs, and a single viral moment or a bot crawling your API can spike your bill.

Fixed pricing (DigitalOcean Managed DB at $15/mo, or self-managed on a VPS) means you pay the same amount every month regardless of traffic. You are capped by your server's resources, not by a billing meter. For a detailed comparison of Supabase costs vs. self-managed MySQL, we published a full breakdown with real numbers.

The Setup I Recommend for Most Projects

For the majority of vibe-coded apps -- side projects, MVPs, small SaaS products, portfolio projects that need to stay online -- here is the setup that gives you the best balance of cost, simplicity, and control.

Total monthly cost: $6-20/mo, all fixed pricing, no surprises.

Step 1: Get a VPS ($6-12/mo)

Create a DigitalOcean droplet (or Hetzner, Linode, Vultr -- they all work). A $6/mo instance with 1 GB RAM is enough for most apps. If you are running a database on the same server, go with 2 GB RAM at $12/mo.

# After creating your droplet and SSHing in:
sudo apt update && sudo apt upgrade -y

Step 2: Install your database

If your app uses MySQL:

sudo apt install mysql-server -y
sudo mysql_secure_installation

If your app uses Postgres:

sudo apt install postgresql postgresql-contrib -y
sudo -u postgres createuser --interactive
sudo -u postgres createdb your_app_db

If you prefer not to manage the database yourself, use DigitalOcean's Managed Database at $15/mo instead. It handles backups, updates, and failover for you. Your total cost becomes $6 (VPS) + $15 (managed DB) = $21/mo.

Step 3: Deploy your app

There are two clean approaches.

Option A: Direct deploy. Clone your repo, install dependencies, run your app behind a process manager:

# Example for a Node.js app
git clone https://github.com/you/your-app.git
cd your-app
npm install
npm run build

# Use PM2 to keep it running
npm install -g pm2
pm2 start npm --name "your-app" -- start
pm2 save
pm2 startup

Option B: Docker. If your AI assistant generated a Dockerfile (many do), use it:

sudo apt install docker.io docker-compose -y
git clone https://github.com/you/your-app.git
cd your-app
docker compose up -d

Both work. Docker adds a layer of abstraction but makes your deploy environment reproducible. Direct deploy is simpler if your app is straightforward.

Step 4: Point your domain and set up SSL

Buy a domain from Namecheap or Cloudflare Registrar (typically $10-12/year for a .com). Point an A record to your VPS IP address.

For SSL, use Caddy as your reverse proxy. It handles HTTPS certificates automatically with zero configuration:

# Install Caddy
sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudflare.com/caddy/stable/deb.asc' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudflare.com/caddy/stable/deb.list' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update && sudo apt install caddy

Your Caddyfile is two lines:

yourdomain.com {
    reverse_proxy localhost:3000
}

Caddy automatically provisions and renews Let's Encrypt SSL certificates. No certbot cron jobs, no manual renewal. You get HTTPS on your domain within seconds.

Step 5: Set up database management

You need a way to inspect and manage your production database. Options:

• CLI tools (mysql client, psql) -- free, already on your server, but not visual
• Desktop apps (DBeaver, TablePlus) -- work well, require SSH tunnel setup
• Browser-based tools (phpMyAdmin, Adminer, DBEverywhere) -- accessible from any device, no local install

Pick whatever fits your workflow. The important thing is having some way to look at your production data when you need to debug an issue at 11pm from your phone.

The Vercel + Supabase Path (And What It Actually Costs)

To be fair, the Vercel + Supabase stack is popular for a reason. The developer experience is genuinely good. If your vibe-coded app is a Next.js project, deploying to Vercel takes about 30 seconds. Connecting to Supabase takes another few minutes. For a demo or a hackathon project, this is hard to beat.

But let us look at what it costs when you move past the demo stage.

Free tier (the demo stage)

This works for a portfolio project that nobody uses. The moment you have real users, Supabase will pause your database during slow weeks, and Vercel's hobby plan prohibits commercial use.

Production tier (real users)

And that is before you hit the Supabase Pro-to-Team cliff. If you need more than 8 GB of database storage, or you need point-in-time recovery, or you need SOC 2 compliance, the next tier is $599/mo. There is no $50 or $100 tier in between. For the full breakdown of how those numbers play out, see our Supabase pricing analysis.

The math

A VPS setup ($6 for hosting + $0 for self-managed DB, or $21 with managed DB) gives you the same capability for 60-90% less. You give up the one-click deploy experience, but you gain predictable costs, full control over your stack, and no vendor lock-in.

For a Next.js app specifically, you can still deploy to a VPS. Run next build && next start behind Caddy or Nginx. It works exactly the same way. You lose Vercel's edge network and analytics dashboard, but for most vibe-coded projects, those are not make-or-break features.

Domain, SSL, and DNS

This section is quick because it should be quick.

Domain registrar: Use Cloudflare Registrar (at-cost pricing, usually $9-10/year for a .com) or Namecheap. Avoid GoDaddy -- their renewal prices are significantly higher than their promotional prices.

DNS: If you bought your domain through Cloudflare, DNS is already set up. Otherwise, point your domain's nameservers to Cloudflare (free plan) for fast DNS and DDoS protection. Create an A record pointing to your server's IP address.

SSL: If you are using Caddy (recommended), SSL is automatic. If you are using Nginx or Apache, use Certbot:

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d yourdomain.com

Certbot sets up auto-renewal via a systemd timer. Your certificates will renew automatically every 60-90 days.

Total cost for domain + SSL: ~$10/year for the domain. SSL is free.

What About CI/CD?

You want pushing to GitHub to automatically deploy your app. This is easier than it sounds.

Option A: Platform auto-deploy

If you are on Vercel, Netlify, Railway, or Render, this is built in. Connect your GitHub repo, and every push to main triggers a deploy. There is nothing to configure.

Option B: GitHub Actions (for VPS deploys)

If you are on a VPS, a simple GitHub Actions workflow handles it:

name: Deploy
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Deploy to server
        uses: appleboy/ssh-action@v1
        with:
          host: ${{ secrets.SERVER_IP }}
          username: deploy
          key: ${{ secrets.SSH_KEY }}
          script: |
            cd /opt/your-app
            git pull origin main
            npm install
            npm run build
            pm2 restart your-app

Store your server IP and SSH key as GitHub repository secrets. Every push to main pulls the latest code, rebuilds, and restarts your app. The whole workflow takes under a minute for most projects.

For Docker-based deploys, replace the script section with:

cd /opt/your-app
git pull origin main
docker compose build
docker compose up -d

That is the entire CI/CD pipeline. No Jenkins. No CircleCI. No complex YAML. Push to GitHub, app deploys.

FAQ

Can I deploy a vibe-coded app for free?

Yes, but with significant limitations. Vercel's hobby tier and Cloudflare Pages are genuinely free for static sites and simple Next.js apps. But free database tiers are unreliable for production (Supabase pauses after inactivity, Neon throttles compute). If your app needs a database and real uptime, budget at least $6/mo for a VPS.

My AI assistant generated a SQLite database. Will that work in production?

It depends on your hosting. On a VPS, SQLite works fine for low-traffic apps -- the file lives on a real filesystem. On Vercel, Netlify, or any serverless platform, SQLite will not work because the filesystem is ephemeral. Your data will disappear on every deploy. If you are deploying to a serverless platform, you need to migrate to Postgres or MySQL. For a deeper look at choosing the right database for vibe-coded projects, we cover every engine and hosting combination.

Do I need Docker?

No. Docker is useful if your app has complex dependencies or if you want a reproducible build environment. But for a straightforward Node.js, Python, or Ruby app, running it directly on the server with a process manager (PM2, systemd, gunicorn) is simpler and uses less memory. Use Docker if your AI assistant already generated a Dockerfile. Skip it if it did not.

What is the cheapest possible production setup?

A $6/mo DigitalOcean droplet running your app and a self-managed database, with Caddy for SSL and a $10/year domain. Total: roughly $7/mo. This handles a surprising amount of traffic -- a 1 GB droplet can serve thousands of requests per second for a typical web app.

How do I handle environment variables and secrets?

Never commit secrets (database passwords, API keys, Stripe keys) to your repository. On a VPS, store them in a .env file on the server that is not in your Git repo. On Vercel/Netlify/Railway, use their built-in environment variable settings. Your AI assistant probably generated code that reads from process.env or os.environ -- those will pick up environment variables regardless of how you set them.

Conclusion

Deploying a vibe-coded app is not as hard as the gap between "it works on my machine" and "it is live on the internet" makes it feel. The core steps are the same regardless of what AI tool you used to build it:

1. Pick a host for your code (VPS for control and fixed pricing, or a platform like Vercel/Railway for convenience)
2. Pick a home for your database (self-managed for cost, managed service for convenience)
3. Point your domain and get SSL (Caddy makes this automatic)
4. Set up auto-deploy from GitHub (5-minute setup)

For most projects, a VPS at $6-12/mo with a self-managed database and Caddy for SSL gives you the best ratio of cost to capability. You get full control, fixed pricing, and a setup that scales further than you think before you need to upgrade.

The Vercel + Supabase path is fine for demos and hackathons. But when your vibe-coded project turns into something real -- when you have users and you need it to stay online -- fixed-cost infrastructure pays for itself in predictability alone.

The hardest part of vibe coding is not building the app. It is getting it live and keeping it live. Now you know how.

For a broader look at choosing the right tools before you start building, check out our guide to the best tech stacks for vibe coding in 2026.