Most “$0 stack” posts sell you the free tier and hide the cliff. This one inverts that: the limits are the content. You’ll get a genuinely free full-stack — Next.js on Vercel, Supabase for Postgres and file storage, Clerk for auth — plus an honest map of exactly where each free tier ends, which limit breaks first, and what the upgrade costs when it does. The goal: you finish this post able to predict your own outage.
One alternative database sits in the mix: Neon. It’s framed here as the escape hatch for Supabase’s most dangerous free-tier behavior, not as a superior default.
How This Guide Was Built
This guide is based on official pricing pages and documentation; we did not deploy the stack hands-on. Every figure was read from server-sent pricing/docs text on 2026-10-10 — no account was created, no project deployed, no request measured. All limits are as published on that date and subject to change by each vendor. Re-verify against the linked primary sources before relying on any number here.
The architecture in one diagram
The stack is four pieces, each free:
[User]
│
▼
Next.js (App Router) ── deployed on Vercel Hobby
│ (Fluid compute, global CDN, CI/CD on push)
├── auth: Clerk Hobby ── user records live in Clerk
│ (middleware-gated routes; YOU sync user IDs into your DB)
│
└── data: Supabase Free ── Postgres + 1 GB file storage
(anon key + service-role key, RLS or server-side scoping)
optional: Neon Free ── pause-proof fallback / primary Postgres
(pooled connection string)The key architectural point beginners miss: auth lives in Clerk, data lives in Postgres, and you are responsible for the join. Clerk doesn’t automatically create rows in your Supabase tables. Plan a sync step — a webhook, a server action, or an explicit “create profile on first sign-in” flow — that writes Clerk’s user ID into your database.
A note on the framework layer: the latest version shown on the Next.js Docs as of writing is 16.4.0, and the App Router is the recommended router (the Pages Router remains supported). Next.js itself has no metered limits — all metering on this stack comes from Vercel. The official Next.js Getting Started guide is the right place to scaffold.
Setup, in the right order
Order matters here because later steps depend on earlier ones (Vercel needs a GitHub repo; your environment variables need keys from Supabase and Clerk).
Step 1: GitHub
Create a GitHub account. It’s required for Vercel’s automatic CI/CD — every push to main becomes a deployment.
Step 2: Scaffold Next.js and push
Scaffold a Next.js app locally with the App Router (the recommended router per Next.js Docs), then push it to a fresh repo. Don’t add auth or database code yet — get a blank deploy green first.
Step 3: Vercel Hobby
Import the repo into a Vercel Hobby account. Set the framework preset to Next.js, deploy, and confirm the project is on Hobby. Never link a card — the point of this stack is that you can’t be surprised by a bill.
Step 4: Supabase Free project
Create a Supabase free project. Pick a region close to your Vercel region — cross-continent database↔app traffic burns your 5 GB egress faster. Record the project URL, the anon key, and the service-role key (server-only).
Step 5: Clerk Hobby application
Create one application on Clerk’s Hobby plan (no credit card required). Use one app for this stack: Clerk lists unlimited applications, but the 50,000 MRU limit applies per app, so one app keeps your whole user base under a single meter you can watch. Record the publishable and secret keys.
Step 6: Neon Free (optional)
Only needed if you use Neon as your primary DB or as the fallback for Supabase’s pause behavior (explained below). Copy the pooled connection string — one connection per serverless function invocation exhausts Postgres connections fast if you use the unpooled string.
Step 7: Environment variables in Vercel
In your Vercel project settings, add:
NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY,CLERK_SECRET_KEYNEXT_PUBLIC_SUPABASE_URL,NEXT_PUBLIC_SUPABASE_ANON_KEY,SUPABASE_SERVICE_ROLE_KEYDATABASE_URL/POSTGRES_URL(Neon pooled string) — only if you use Neon
⚠️ Never prefix server secrets with NEXT_PUBLIC_ — Next.js inlines those variables into the browser bundle, where anyone can read them.
Step 8: Security hygiene
Two configs beginners skip:
- Database authorization. With Clerk as your auth provider, Clerk user IDs don’t reach Supabase automatically, so the usual Supabase-Auth advice (“scope RLS policies to
auth.uid()”) doesn’t directly apply. You have two honest options: use the Clerk↔Supabase JWT/claims integration so Clerk identities flow into Supabase Auth, or do authorization server-side with the service-role key, checking the Clerk session before every query. Pick one — don’t rely on client-side anon-key access without a policy in place. - Firewall rules. Vercel Hobby includes 3 custom firewall rules and 3 IP blocks (Vercel Pricing). Spend them on rate-limiting your auth and write endpoints.
Step 9: Keep-alive ping for Supabase
The 1-week pause is real (next section). Configure a free cron/uptime service to hit an endpoint every few days, and make it a documented part of your deploy checklist.
Step 10: Pre-launch self-check
- Which egress pool am I most likely to hit first? (Supabase’s 5 GB is usually it.)
- Is my Supabase pause-ping running?
- Is my Clerk user ID synced into my database tables?
- Are all secrets server-side only (no
NEXT_PUBLIC_on secrets)? - Did I write copy that accounts for the 7-day forced logout?
- Am I on one Clerk app, so MRU counting is coherent?
Every free limit, and which one breaks first
The centerpiece table. All figures from the four pricing pages, read 2026-10-10.
| Service | Free price | Headline user/storage limit | Egress | Breaks first | Pause/expiry trap | Upgrade price |
|---|---|---|---|---|---|---|
| Vercel Hobby | $0/mo | 1M CDN requests/mo; 100 GB Fast Data Transfer; 5K image optimizations/mo; 1 GB Blob storage (10K simple / 2K advanced ops); 3 firewall rules | 100 GB/mo | Image optimizations (5K/mo) or Blob 1 GB for file-heavy apps; 1M requests and 100 GB rarely break first | Logs/monitoring retention limited; no cold-start prevention (Pro-only) | Pro $20/mo |
| Supabase Free | $0/mo | 50,000 MAU; 500 MB database; 1 GB file storage; 2 active projects; unlimited API requests | 5 GB + 5 GB cached | 1-week inactivity pause — kills weekend projects | Projects pause after 1 week idle; community-only support | Pro from $25/mo |
| Clerk Hobby | $0/mo | 50,000 MRU per app; unlimited apps; 3 dashboard seats; custom domain included | n/a | Fixed 7-day session lifetime — every user logs out weekly | App logs retained 1 day only | Pro $20/mo annual ($25 monthly) |
| Neon Free | $0/mo | 100 projects; 1 GB storage/project (20 GB account total); 100 CU-hours/project; autoscaling to 2 CU | 5 GB public transfer/project | 5-minute scale-to-zero cold starts | 6-hour history window (no real backups); 1-day monitoring | Launch: usage-based ($0.106/CU-hour, $0.35/GB-month) |
The traps that bite while you sleep
Supabase’s 1-week pause — the #1 killer
Free Supabase projects pause after 1 week of inactivity (Supabase Pricing). A side project you touch on weekends will pause mid-week; the first visitor after a lull gets errors, not your app. Spinning up extra projects does not get around it: the free plan caps you at 2 active projects. This is the single strongest argument for Neon as a primary or fallback database. Mitigation: the keep-alive ping from Step 9, or Neon.
Neon’s 5-minute cold start — and the double-cold page load
Neon scales to zero after 5 minutes of inactivity (Neon Plans). Your DB connection drops; the next query pays a cold-start penalty. Pair that with Vercel Hobby — which doesn’t include cold-start prevention (that’s a Pro perk) — and both the app and the database can be cold on the same request. On a low-traffic hobby project, users feel this as a slow first page load. Wrap DB access in retry/error handling so a cold start doesn’t surface as a 500.
Clerk’s forced 7-day logout
Clerk Hobby has a fixed 7-day session lifetime — not configurable (Clerk Pricing). Every authenticated user re-authenticates weekly; custom session lifetime is a Pro feature. Product implication: don’t promise “stay logged in forever” in your onboarding copy, and expect a small weekly wave of re-logins.
Expiry traps: logs, history, monitoring
- Clerk app logs: 1-day retention. Fraud or support investigations must happen same-day.
- Neon history window: 6 hours, up to 1 GB-month. This is near-zero recovery — Neon Free is not a backup plan. Export your data manually.
- Neon monitoring: 1 day. You cannot debug last week’s incident.
Upgrade triggers and what they cost
When the free tier ends, here’s the exact price of continuing (Vercel Pricing, Supabase Pricing, Clerk Pricing, Neon Plans):
- Supabase Pro — from $25/mo. Triggers: the pause pain, >500 MB database, >5 GB egress, wanting daily backups (7-day retention), or >2 projects. Includes 100,000 MAU then $0.00325/MAU, 250 GB egress, 100 GB file storage, and a $10/mo compute credit covering one Micro instance.
- Clerk Pro — $20/mo billed annually ($25 monthly). Triggers: >50,000 MRU (then $0.02/MRU/mo), wanting custom session lifetime, MFA, removing Clerk branding, SMS auth, or 7-day log retention.
- Vercel Pro — $20/mo. Triggers: >1M CDN requests, >5K image optimizations, cold-start prevention, 40 firewall rules, a free custom domain, or any commercial use (Hobby is non-commercial, see the Vercel Hobby plan docs). Pro also adds Flat Rate CDN for predictable bills, and spend management to cap surprises.
- Neon Launch — pay for what you use. $0.106/CU-hour, $0.35/GB-month storage, 500 GB transfer per project then $0.10/GB, autoscaling to 16 CU.
One honesty note: the pricing pages don’t document what happens at a free-tier cap (hard stop vs. throttle vs. prompted billing). Check each vendor’s current terms before launch — don’t assume.
Cost math at 1,000 and 10,000 MAU
Every assumption below is an unmeasured estimate — we deployed nothing and measured no traffic. Treat the egress per-user numbers as illustrative arithmetic, not benchmarks.
| Scenario | Clerk | Supabase | Vercel | Neon | Total/mo |
|---|---|---|---|---|---|
| 1,000 MAU | $0 | $0 | $0 | $0 | $0 |
| 10,000 MAU, lean (~0.1 MB DB egress/MAU ≈ 1 GB — estimate) | $0 | $0 | $0 | $0 | $0 |
| 10,000 MAU, data-heavy (~0.6 MB/MAU ≈ 6 GB — estimate, exceeds the 5 GB egress cap) | $0 | $25 (Pro) | $0 | — | $25 |
| 60,000 users (past caps) | $20 Pro + $0.02 × 10,000 MRU over 50k = $220 | $25 (Pro; auth via Clerk, so Supabase MAU moot) | $0 | — | ~$245 |
Line by line on the last row: Clerk Pro is $20/mo annual; 60,000 MRU − 50,000 included = 10,000 × $0.02 = $200; total Clerk $220. Supabase Pro from $25/mo. Vercel Hobby still $0 at these request levels.
Teaching point: the cliff isn’t at 10k MAU — it’s your egress and storage habits at 10k, and the 50k user wall beyond.
FAQ
Is this really $0 at 10,000 users? Yes, plausibly — if your users are lean. At ~0.1 MB of database egress per MAU (an estimate, not a measurement), 10,000 MAU ≈ 1 GB, well under Supabase’s 5 GB. Clerk’s 50,000 MRU and Vercel’s 1M requests are both comfortably clear. The first real cost is data-heavy usage, not user count.
What happens when Supabase pauses? The project goes inactive after 1 week without activity, and your app’s database calls fail until you restore it from the dashboard. The pricing page doesn’t specify restore timing or behavior details — verify current behavior before relying on it. The keep-alive ping exists precisely so you never find out.
Clerk MRU vs Supabase MAU — which 50k matters? They’re different units and will not line up. Clerk bills on Monthly Retained Users — not raw signups and not MAU (see Clerk Pricing for the exact definition). Supabase’s 50,000 MAU meter only applies if Supabase Auth is enabled — with Clerk as your auth provider, that cap generally doesn’t apply to your users, so don’t double-count against both 50k numbers.
Why did all my users get logged out? Clerk Hobby’s fixed 7-day session lifetime. Every user re-authenticates weekly, and you can’t change it without Pro ($20/mo annual). Write your onboarding copy accordingly.
Do I need Neon if I have Supabase? No — unless the 1-week pause risk is unacceptable for your project. Neon’s free plan gives 100 projects, 1 GB storage per project, and no inactivity pause (it scales to zero after 5 minutes instead, which is a performance cost rather than an availability failure). Its trade-off: a 6-hour history window, so it’s not a backup solution either.
What’s the first limit I’ll actually hit? For most side projects: either Supabase’s 1-week pause (if you skip the ping) or its 5 GB egress on data-heavy apps. Vercel’s 1M CDN requests and 100 GB transfer are rarely the first thing to break; Clerk’s 50k MRU wall is far away for a new product.
What happens at a cap — do I get billed? The pricing pages don’t document cap behavior (hard stop vs. throttle vs. auto-billing). Since you never linked a card on any of these free plans, surprise billing is unlikely — but verify each vendor’s current terms rather than assuming.
The Bottom Line
Verdict: viable. A lean, non-commercial product can run free to roughly 10,000 MAU, and up to Clerk’s 50,000 MRU wall on the auth side. Vercel’s Hobby plan is for personal, non-commercial use, so a paid or business product should move to Pro. The real price isn’t monetary — it’s operational: a keep-alive ping to dodge Supabase’s pause, copy that respects the forced weekly logout, same-day-only log debugging, and no real backups on Neon Free (export manually).
One-line recommendation: Supabase as primary plus a keep-alive ping; Neon if pause-risk is unacceptable; Clerk until you need custom session lengths.
Every number above is as published on 2026-10-10 and subject to change — re-verify against the linked pricing pages before you launch.