The Cheapest Way to Deploy a Full-Stack App in 2026 (Real Numbers, No BS)

I have a problem. I build too many side projects.

At last count, I'm running 23 apps in various states of "production." Some get decent traffic, some are internal tools, and a few are just experiments I forgot to shut down. Every month, I open my email to a parade of invoices from hosting platforms, and every few months I do an audit to figure out if I'm overpaying.

After years of this cycle, I've landed on a stack that keeps my total hosting bill under $15/month for most projects — and some of them cost literally nothing. Here's exactly how.

The Problem With "Free Tier" Advice

Most "host your app for free" articles are written by people who haven't actually run anything in production. They'll tell you to slap everything on Vercel's free plan and call it a day. That works until you need a cron job, a background worker, a database that doesn't sleep after 5 minutes of inactivity, or an API that handles more than 10 requests per second.

Free tiers are real, but they come with constraints that matter. Let me break down what actually works versus what will bite you at 2 AM when your app goes down.

My Go-To Stack (And What It Costs)

Here's the combination I reach for most often:

Frontend: Vercel — Free (Hobby plan) Backend API: Railway — $5-8/month Database: Supabase — Free (for side projects) or $25/month (Pro) File Storage: Supabase Storage or Cloudflare R2 — Free (under limits) DNS + CDN: Cloudflare — Free

Total for a typical side project: $5-8/month Total if you need a beefier database: $30-33/month

Let me explain each choice.

Frontend: Vercel Is Still King for Free Hosting

I know, everyone says this. But it's true for a reason. Vercel's Hobby plan gives you:

• Unlimited static sites and serverless functions
• 100GB bandwidth/month
• Automatic SSL and preview deployments
• Edge functions at no extra cost

For any Next.js, Astro, or static site, there's no reason to pay for frontend hosting unless you're hitting serious traffic numbers. I've had apps serve 50k+ page views per month on the free plan without issues.

The catch: Vercel's serverless functions have a 10-second timeout on the free plan (60s on Pro). If your API routes do heavy processing, you'll hit this fast. That's why I split my backend out.

# Deploy to Vercel in one command
npx vercel --prod

Backend: Railway Changed the Game

This is where my opinion gets spicy. I used to run backends on Render, Fly.io, and even a $5 DigitalOcean droplet. I've settled on Railway for almost everything now.

Why? Three reasons:

1. Usage-based pricing that actually makes sense

Railway charges per-second for compute. A Node.js API that handles moderate traffic (a few thousand requests per day) typically costs me $3-5/month. You get $5 of free usage when you verify your account, which is enough to run a small app for a month.

2. One-click Postgres/Redis/MySQL

Need a database? Click a button. Railway spins up a Postgres instance right next to your app with zero config. The connection string is injected as an environment variable automatically.

# railway.toml - that's literally all the config you need
[build]
builder = "nixpacks"

[deploy]
startCommand = "node dist/server.js"
healthcheckPath = "/health"
restartPolicyType = "on_failure"

3. No cold starts

Unlike serverless platforms, Railway keeps your container running. Your API responds in milliseconds, not seconds. For any app where response time matters (real-time features, webhooks, API integrations), this is a big deal.

The only downside: Railway isn't truly free anymore. The $5 trial credit runs out, and then you're paying. But for $5-8/month, you get a real server with predictable performance. That's worth it.

Database: The Supabase Free Tier Is Generous (With Caveats)

Supabase gives you a Postgres database with:

• 500MB storage
• 2GB bandwidth
• 50,000 monthly active users for auth
• Realtime subscriptions
• Edge functions
• 1GB file storage

For side projects, this is more than enough. I've run apps with a few hundred daily active users on the free tier without any problems.

Here's a real schema I use for a basic SaaS starter:

-- Users are handled by Supabase Auth, but I add a profiles table
create table profiles (
  id uuid references auth.users on delete cascade primary key,
  email text not null,
  full_name text,
  plan text default 'free' check (plan in ('free', 'pro', 'team')),
  created_at timestamptz default now()
);

-- Row-level security so users can only read their own data
alter table profiles enable row level security;

create policy "Users can read own profile"
  on profiles for select
  using (auth.uid() = id);

create policy "Users can update own profile"
  on profiles for update
  using (auth.uid() = id);

The caveat: Supabase pauses inactive free-tier projects after 7 days of no activity. If your app gets zero requests for a week, the database goes to sleep. Waking it up takes 30-60 seconds. For a demo or portfolio project, this is fine. For anything with real users, you either need to set up a keep-alive ping or upgrade to Pro ($25/month).

Here's a simple keep-alive I run as a cron job:

// keep-alive.ts — runs every 6 days via Railway cron
import { createClient } from "@supabase/supabase-js";

const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_ANON_KEY!
);

async function keepAlive() {
  const { error } = await supabase.from("profiles").select("id").limit(1);
  if (error) console.error("Keep-alive failed:", error.message);
  else console.log("Database pinged successfully");
}

keepAlive();

The "I Don't Want to Pay Anything" Stack

If you're truly bootstrapping and can live with some limitations:

Frontend: Vercel Hobby or Cloudflare Pages — Free Backend: Vercel API routes or Cloudflare Workers — Free Database: Supabase Free or Turso Free (8GB, embedded SQLite) — Free Auth: Supabase Auth or Clerk Free (10k MAU) — Free

Total: $0/month

This works surprisingly well for:

• Portfolio sites with a contact form
• Small SaaS apps in early validation
• Internal tools with < 10 users
• Weekend projects and experiments

It falls apart when you need background jobs, websockets, or consistent uptime. But for shipping an MVP to see if anyone cares? Zero dollars is hard to beat.

What About DigitalOcean / AWS / Fly.io?

I still use DigitalOcean for specific cases:

• Long-running processes (video encoding, ML inference): A $6/month droplet with 1GB RAM handles this better than any serverless platform
• Self-hosting tools (n8n, Plausible Analytics, Umami): Docker Compose on a droplet is still the simplest self-hosting setup
• When I need full control: SSH access, custom nginx configs, cron jobs that need to run for minutes

# docker-compose.yml for self-hosted analytics
version: "3"
services:
  umami:
    image: ghcr.io/umami-software/umami:postgresql-latest
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://umami:password@db:5432/umami
    depends_on:
      db:
        condition: service_healthy
    restart: always

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: umami
      POSTGRES_USER: umami
      POSTGRES_PASSWORD: password
    volumes:
      - umami-db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U umami"]
      interval: 5s
      timeout: 5s
      retries: 5
    restart: always

volumes:
  umami-db:

Fly.io has gotten more expensive and less predictable with their pricing changes. I moved most of my Fly apps to Railway last year and haven't looked back.

AWS is overkill for side projects. If you're paying for ECS, RDS, and CloudFront to serve a todo app with 12 users, you're doing it wrong.

My Decision Framework

When I start a new project, I ask three questions:

1. Does it need a persistent backend process? No → Vercel API routes + Supabase. Total: $0. Yes → Railway + Supabase. Total: $5-8/month.

2. Does it need to handle > 100 concurrent users? No → Free tiers everywhere. Go wild. Yes → Budget $25-40/month. Supabase Pro + Railway with more compute.

3. Am I self-hosting an existing tool? Yes → DigitalOcean $6 droplet + Docker Compose. Simple and reliable.

That's it. No Kubernetes. No multi-region. No infrastructure-as-code for a side project with 50 users. Keep it simple until the problem demands complexity.

The Actual Monthly Bill

Here's what I pay right now across all my active projects (February 2026):

| Service | Monthly Cost | What It Runs | |---------|-------------|--------------| | Vercel (Hobby) | $0 | 8 frontend apps | | Railway | $22 | 4 backend APIs + 2 cron workers | | Supabase (1 Free + 1 Pro) | $25 | Databases for 6 apps | | DigitalOcean | $12 | 2 droplets (self-hosted tools) | | Cloudflare | $0 | DNS + CDN for everything | | Total | $59 | 23 apps |

That's about $2.56 per app per month. Some of these apps make money, most don't. But the point is that running 23 projects doesn't require 23× the cost. Smart infrastructure sharing and free tiers do most of the heavy lifting.

One Last Tip: Don't Optimize Too Early

The biggest waste of time I see from other developers is spending hours comparing hosting providers for an app that has zero users. Ship on whatever's fastest to deploy. You can always migrate later.

Vercel takes 30 seconds to deploy. Railway takes 2 minutes. Start there. If your app takes off and you need to optimize costs, that's a good problem to have.

Build first. Optimize later. Your hosting bill only matters if people actually use what you're building.

---

Some links in this article are affiliate links. If you sign up through them, I may earn a small commission at no extra cost to you. I only recommend tools I actually use and pay for myself.