Run a full-stack app for $0/month with Vercel, Neon PostgreSQL, and GitHub Actions. Real config from production.
Get new posts delivered to your inbox. No spam, unsubscribe anytime.
My blog costs me $0/month to run. It handles 30+ articles, a PostgreSQL database, server-side rendering, an RSS feed, a sitemap, and a service worker that caches everything for offline reading. Zero dollars. Not $5. Not "basically free." Actually free.
I'm not talking about a static HTML page hosted on GitHub Pages. ismatsamadov.com is a full Next.js application with an admin dashboard, authentication, full-text search, dynamic OG images, and a Neon PostgreSQL database with Drizzle ORM. It runs on Vercel's free tier. The database runs on Neon's free tier. The CI/CD runs on GitHub Actions' free tier.
I also run birjob.com, a job aggregation platform that scrapes listings from multiple sources. That one costs me about $25/month because it needs more compute and storage. But the point stands — you can ship real products for nothing, and scale to paid tiers only when you actually need to.
This article is the exact playbook. Every free tier limit, every gotcha, every config file. I'll show you what I run in production and what breaks first when you outgrow free.
Three services. All free. Here's what each one does:
| Service | Role | Free Tier |
|---|---|---|
| Vercel | Hosting, serverless functions, CDN, CI/CD | 100 GB bandwidth, 150K function calls |
| Neon | PostgreSQL database (serverless) | 100 CU-hours, 0.5 GB storage |
| GitHub Actions | CI/CD, cron jobs, automation | 2,000 min/month (private), unlimited (public) |
That's it. No Docker. No Kubernetes. No AWS bill that makes you cry at 3am. You push code to GitHub, Vercel deploys it, Neon serves the data, and GitHub Actions handles anything else you need automated.
Vercel was built by the creators of Next.js. That means zero-config deployment for Next.js apps. You connect your GitHub repo, push to main, and your site is live. No Dockerfiles. No nginx configs. No SSH.
I've been running ismatsamadov.com on Vercel's Hobby (free) tier since day one. Here's what you get:
| Resource | Hobby (Free) | Pro ($20/mo) |
|---|---|---|
| Bandwidth | 100 GB/month | 1 TB/month |
| Serverless Function Invocations | 150,000/month | 1M/month |
| Build Minutes | 6,000/month | 24,000/month |
| Projects | Unlimited | Unlimited |
| Function RAM | 2 GB | 3 GB |
| Function vCPUs | 1 | 2 |
| Function Timeout | 10 seconds | 60 seconds |
| Concurrent Builds | 1 | 3 |
| Team Members | 1 (personal) | Unlimited |
Source: Vercel Hobby Plan and Vercel Pricing.
100 GB of bandwidth handles roughly 100,000 visitors per month depending on your page weight. For a blog? That's more than enough. My blog doesn't come close.
150,000 serverless function invocations covers every API route, every server-rendered page, every search query. Again, not even close to hitting this.
The catch: Vercel Hobby is non-commercial. You can't run a business on it. If you're making money from the site, you need Pro at $20/month. My blog doesn't make money (shocking, I know), so Hobby works fine. birjob.com would technically need Pro since it's a product, but that's a conversation for another day.
There is no deployment step. You push to GitHub and Vercel handles everything.
git add .
git commit -m "Add new blog post"
git push origin main
That's it. Vercel detects the push, runs your build, deploys to their edge network, and your changes are live in about 60 seconds. Preview deployments for every pull request. Rollback with one click.
If you want more control, here's a minimal vercel.json:
{
"framework": "nextjs",
"regions": ["iad1"],
"headers": [
{
"source": "/(.*)",
"headers": [
{
"key": "X-Content-Type-Options",
"value": "nosniff"
},
{
"key": "X-Frame-Options",
"value": "DENY"
}
]
}
]
}
But honestly, you probably don't even need that. The defaults work.
If you somehow blow past the free limits:
You won't hit these on a personal project. If you do, you've got a good problem.
Neon is the database layer. It's PostgreSQL — real PostgreSQL, not some proprietary thing that speaks the PostgreSQL wire protocol. You get full SQL, extensions, triggers, the whole deal.
What makes Neon special for free-tier stacking: it scales to zero. When nobody's querying your database, you're not paying for idle compute. The connection spins up in ~150ms on the first query and goes back to sleep when you're done. For a blog that gets sporadic traffic, this is perfect.
Neon was acquired by Databricks in May 2025, and since then compute costs have dropped 15-25%. The free tier also got more generous — they doubled the compute hours from 50 to 100 CU-hours per project in October 2025.
| Resource | Free Tier | Launch ($19/mo) |
|---|---|---|
| Compute Hours | 100 CU-hours/month | 300 CU-hours/month |
| Storage | 0.5 GB per branch | 10 GB |
| Aggregate Storage | 5 GB across projects | 50 GB |
| Projects | Up to 100 | Up to 100 |
| Branches | 10 per project | 500 per project |
| Egress | 5 GB/month | 50 GB/month |
| Scale-to-Zero | Yes | Yes |
Source: Neon Pricing and Neon Plans.
0.5 GB of storage is the real constraint. For a blog, it's fine — text is small. My 30+ articles with all metadata take up maybe 2 MB. But if you're storing files, images, or large JSON blobs, you'll hit this fast.
The branching feature is genuinely cool. Neon uses copy-on-write branching, so you can spin up a complete copy of your database for testing in seconds. I've used it maybe twice, but when I did, it saved me from a bad migration.
Here's the actual connection pattern I use in ismatsamadov.com:
import { neon } from '@neondatabase/serverless'
import { drizzle } from 'drizzle-orm/neon-http'
import * as schema from './schema'
const sql = neon(process.env.DATABASE_URL!)
export const db = drizzle(sql, { schema })
That's the entire database connection file. Three lines of actual code. Drizzle with Neon's serverless driver means no connection pooling to manage, no PgBouncer to configure. Each request gets its own HTTP-based connection through Neon's proxy.
Here's what a typical query looks like:
import { db } from '@/lib/db'
import { posts } from '@/lib/db/schema'
import { eq, desc } from 'drizzle-orm'
// Get all published posts
const allPosts = await db
.select()
.from(posts)
.where(eq(posts.status, 'published'))
.orderBy(desc(posts.publishedAt))
// Get a single post by slug
const post = await db
.select()
.from(posts)
.where(eq(posts.slug, 'some-post-slug'))
.limit(1)
SQL-like syntax that compiles to actual SQL. No magic. No generated client. Just queries.
GitHub Actions is the glue. It handles everything that isn't "serve the website" or "store the data."
| Resource | Free (Public Repos) | Free (Private Repos) |
|---|---|---|
| Minutes/Month | Unlimited | 2,000 |
| Storage | 500 MB | 500 MB |
| Concurrent Jobs | 20 | 20 |
Source: GitHub Actions Billing.
For public repos, it's completely free with no minute limits. That's absurd. If your side project is open source, you get unlimited CI/CD for nothing.
For private repos, 2,000 minutes is plenty. A typical Next.js build takes 2-3 minutes. That's ~700 builds per month. You're not doing 700 deploys a month. (If you are, stop and think about what you're doing.)
There were some pricing changes in early 2026. GitHub dropped runner prices by about 40% in January 2026, which is nice. They also introduced a $0.002/minute platform charge for self-hosted runners starting March 2026 — but public repos are exempt from this. If you're on free tier with a public repo, nothing changes.
Here's a workflow pattern similar to what I use for birjob.com's scraping jobs — a cron-triggered workflow that runs a script on a schedule:
name: Scheduled Data Sync
on:
schedule:
# Run every 6 hours
- cron: '0 */6 * * *'
workflow_dispatch: # Allow manual triggers
jobs:
sync:
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: '20'
cache: 'npm'
- run: npm ci
- name: Run sync script
env:
DATABASE_URL: ${{ secrets.DATABASE_URL }}
run: npx tsx scripts/sync-data.ts
- name: Notify on failure
if: failure()
run: |
curl -X POST ${{ secrets.WEBHOOK_URL }} \
-H "Content-Type: application/json" \
-d '{"text": "Data sync failed!"}'
This runs every 6 hours, pulls the latest code, runs a TypeScript script that syncs data to Neon, and sends a webhook notification if it fails. Total cost: $0.
For a basic CI pipeline (lint, type-check, build), here's what works:
name: CI
on:
push:
branches: [main]
pull_request:
branches: [main]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: '20'
cache: 'npm'
- run: npm ci
- run: npm run lint
- run: npx tsc --noEmit
- run: npm run build
env:
DATABASE_URL: ${{ secrets.DATABASE_URL }}
Since Vercel already handles deployment on push, I mainly use GitHub Actions for things Vercel can't do: scheduled jobs, data processing, running scripts that take longer than Vercel's 10-second function timeout.
Here's every major free hosting option in 2026, side by side:
| Feature | Vercel (Hobby) | Cloudflare Pages | Netlify (Free) | Railway | Render (Free) |
|---|---|---|---|---|---|
| Bandwidth | 100 GB/mo | Unlimited | 125 GB/mo | Usage-based | 750 hours/mo |
| Serverless Functions | 150K/mo | 100K/day | 125K/mo | — | — |
| Build Minutes | 6,000/mo | 500/mo | 300/mo | — | — |
| Database | — (use Neon) | D1 (5 GB free) | — (use external) | $5 trial | — |
| Function Timeout | 10s | 30s (workers) | 10s | — | — |
| Custom Domains | Yes | Yes | Yes | Yes | Yes |
| Auto Deploy | Yes (GitHub) | Yes (GitHub) | Yes (GitHub) | Yes | Yes |
| Commercial Use | No | Yes | Yes | Yes | Yes |
| Cost | $0 | $0 | $0 | $5 credit | $0 (limited) |
Source: DigitalOcean — Vercel Alternatives.
Some quick takes:
Cloudflare Pages has the most generous free tier, period. Unlimited bandwidth is wild. If you don't need serverless functions (or can use Cloudflare Workers), this is arguably better than Vercel for static and JAMstack sites. The 500 build minutes per month is tight though.
Netlify is solid. 125 GB bandwidth and 125K function invocations. Similar to Vercel but allows commercial use on the free tier. If the non-commercial restriction on Vercel Hobby bothers you, Netlify is the move.
Railway killed their always-free tier. You get a $5 trial credit and that's it. Not really "free" anymore.
Render is free for static sites but their free web service tier has limited hours and spins down after inactivity. Fine for demos, not great for production.
I stick with Vercel because ismatsamadov.com is a Next.js app and Vercel's Next.js integration is unmatched. Vercel built Next.js. The deployment is zero-config. ISR, RSC, middleware, image optimization — it all just works without any configuration. That matters more to me than unlimited bandwidth.
Let's be honest about the limits. Free tier will break eventually if your project grows. Here's where it breaks first:
This is the sharpest edge. Any serverless function that takes more than 10 seconds will be killed. For a blog serving cached pages, this is never an issue. For an API that does heavy computation, database joins across large tables, or calls external APIs that are slow — you'll hit this fast.
birjob.com's scraping jobs take minutes to run. They can't be serverless functions on Vercel Hobby. That's why they run as GitHub Actions cron jobs instead.
Upgrade path: Vercel Pro ($20/month) gives you 60-second timeouts.
Half a gigabyte sounds small, and it is. For text data — blog posts, user records, configuration — it's more than enough. My entire blog database is a few megabytes.
But if you're building something with user-uploaded content, activity logs, or large JSON documents, you'll hit 0.5 GB fast.
Upgrade path: Neon Launch ($19/month) gives you 10 GB. That's 20x the storage for $19.
The Hobby plan is explicitly for non-commercial use. If your project makes money — ads, subscriptions, selling a product — you technically need to upgrade. Vercel hasn't been aggressive about enforcing this, but it's in the terms.
Upgrade path: Vercel Pro at $20/month removes this restriction.
2,000 minutes per month for private repos. If you're running lots of CI/CD jobs with long build times, this can get tight. A 3-minute build triggered 30 times a day eats 2,700 minutes in a month. You'd need to optimize your builds or go less frequently.
Upgrade path: Make your repo public (unlimited minutes) or pay for more minutes.
If you outgrow free tier, here's what "paid" looks like:
| Service | Plan | Cost |
|---|---|---|
| Vercel Pro | 1 TB bandwidth, 60s timeout | $20/month |
| Neon Launch | 10 GB storage, 300 CU-hours | $19/month |
| GitHub Actions | Public repo | $0 |
| Total | $39/month |
$39/month for a production-grade stack with a PostgreSQL database, edge CDN, serverless functions, and CI/CD. That's less than most people spend on coffee in a week.
The free tier in 2026 is absurdly generous. I'm running a full-stack application with server-side rendering, a PostgreSQL database, authentication, full-text search, and automated deployments for zero dollars a month. Ten years ago, this would have required a VPS, a managed database, a CI server, and a CDN. That's $50-100/month minimum.
Now it's free.
There is no excuse for not shipping. None. "I can't afford hosting" stopped being a valid excuse around 2020 and it's downright laughable in 2026.
If your side project needs more than 100 GB of bandwidth and 0.5 GB of database storage, congratulations — you have a real business. And $20-40/month won't kill you. The $20/month Vercel Pro plan handles more traffic than 99% of side projects will ever see. The $19/month Neon Launch plan gives you more database than most apps need.
The bottleneck was never infrastructure. It was never the cost of hosting. It was never "which framework should I use" or "should I go with Neon or Supabase." The bottleneck was always you not shipping.
I know because I've been there. I spent more time researching hosting options for birjob.com than building the first version of it. The irony of writing a 3,000+ word article about free hosting when I could be writing actual features is not lost on me.
But here it is anyway. The stack works. I run it in production. ismatsamadov.com is proof. Go build something.