Why Side Projects Die Quietly
Most side projects don’t die because the idea was bad. They die because something in the stack stopped working on a weeknight and nobody noticed until a user emailed. Free tiers are the usual culprit. They look generous on the pricing page and stingy in the fine print, and the limits that matter often show up only after you’ve built on top of them.
The good news is that the traps are predictable. Once you know the mechanisms, you can design around them before launch instead of firefighting after. This guide walks through the ones I’d check first, using each provider’s own documentation wherever it exists.
The Four Ways Free Tiers Kill Projects
Almost every free-tier failure fits one of four patterns:
- Auto-pause and spin-down. The service sleeps after inactivity. Supabase free projects auto-pause after 7 days of inactivity, and Neon compute auto-suspends after 5 min idle.
- Session and policy walls. The vendor fixes a behavior on the free plan that you need to customize. Clerk is the clearest example.
- Provider exits. The free tier disappears altogether. Heroku, PlanetScale, and Railway each fall into this category in different ways.
- Quota ceilings. Hard caps on bandwidth, invocations, writes, or build minutes that quietly stop features until the next cycle.
Each category needs a different defense. Auto-pause needs a keep-alive. Quota ceilings need monitoring. Provider exits need a migration path you’ve thought through before you need it.
The Auto-Pause Trap: Supabase and Neon
Supabase is the one that bites most often. Projects on the free plan pause after 7 days of inactivity, and restoring is a manual step in the dashboard. Your data is retained, but your app stays down until someone clicks restore. If that someone is you, asleep, while a user is trying to log in, the outage lasts as long as you remain unaware of it.
Neon has the same root cause with a gentler symptom. Compute auto-suspends after 5 min idle, so the first query after a quiet period pays a cold-start penalty while compute wakes.
The practical takeaway: treat any auto-pausing database as a service with a heartbeat requirement, and write that heartbeat into your launch checklist.
The 7-Day Session Wall: Clerk’s Hobby Tier
Auth is where a free tier can break your product’s core promise. On Clerk’s Hobby plan, session lifetime is fixed at 7 days. You can’t customize it on the free plan, because custom session duration is a Pro feature at $25/mo.
That sounds minor until you think about what it does to users. Everyone gets logged out on the same schedule, active or not. The community reaction was loud. A Hacker News thread and a Reddit PSA in r/nextjs centered on the same complaint: free-tier apps force every user through re-login, and the escape hatch is an upgrade.
Is it a dealbreaker? Not always. For a prototype or internal tool, a weekly re-login is tolerable. For a consumer app where people expect to stay signed in, it’s a retention problem that shows up in your analytics before you understand why. Decide before you build: treat the $25/mo Pro plan as an upgrade trigger, or design your UI to handle re-auth gracefully from the start.
Providers That Pulled the Rug: Heroku, PlanetScale, Railway, Render
Some free tiers don’t pause. They disappear. Heroku’s free dynos, Postgres, and Redis ended Nov 28, 2022, and many indie projects learned about it from an email rather than a plan. The lesson isn’t that Heroku is uniquely untrustworthy. Any free tier can be withdrawn, so your migration path should exist before you need it.
PlanetScale’s Hobby plan was sunset in 2024. Same lesson, different vendor.
Railway is the one people misread. Its offer is a $5 one-time trial credit, not a free tier, and services stop when the credit runs out. If you launched assuming ongoing free hosting, your app goes down with it.
Render sits in the middle. Free services spin down after 15 min idle, which means a cold start on the first request after a quiet stretch. Third-party reporting from 2026 also describes a 30-day expiry on free Postgres and roughly 5 GB/mo of bandwidth. Those figures come from that reporting, not from Render’s official policy, so check the current docs before you architect around them.
The Quota Ceilings: Vercel, MongoDB Atlas, Cloudflare, GitHub Actions, Fly.io
Quota ceilings are the sneakiest, because they don’t look like outages until they are.
Vercel’s Hobby limits cover 100 GB of Fast Data Transfer, 1M function invocations, and 4 CPU-hours of active function CPU. When you hit them, features pause until the next usage cycle. That protects your wallet, but a traffic spike can take features offline. The same plan is restricted to non-commercial use, so a side project that starts earning has a licensing problem as well as a quota problem.
MongoDB Atlas M0 gives you 512 MB of storage and 100 connections, and it has no backups on the free tier. People discover that last point too late.
Cloudflare Workers’ free plan allows 100k req/day, and its KV storage allows 1,000 writes/day. Writes are the hidden quota: a counter, a session update, or a cache write on every request can exhaust that limit long before your read volume matters.
GitHub Actions includes 2,000 Linux minutes/mo on the free plan. The more dangerous detail is that scheduled workflows auto-disable after 60 days of repo inactivity. That’s the keep-alive cron many developers set up to protect their app, and it switches itself off precisely when the project goes quiet.
Fly.io belongs in this bucket too. Its free allowance has narrowed over time, and stopped apps can still accrue storage charges, so read the current pricing page before assuming anything on it is free.
Free-Tier Kill Mechanisms at a Glance
| Provider | Free Tier Status | The Hidden Limit | What It Feels Like | Survival Move |
|---|---|---|---|---|
| Supabase | Free, with auto-pause | Pauses after 7 days of inactivity | App is down until someone clicks restore | Scheduled heartbeat plus a weekly dump |
| Clerk (Hobby) | Free | Session lifetime fixed at 7 days | Every user gets logged out on a schedule | Design for re-auth, or treat $25/mo Pro as the upgrade trigger |
| Render | Free, with spin-down | Spins down after 15 min idle | First request after a quiet stretch is slow | Keep-alive ping; verify Postgres expiry in current docs |
| Vercel (Hobby) | Free, non-commercial | 100 GB transfer, 1M invocations, 4 CPU-hours | Features pause until the next cycle | Monitor usage; move static assets off the origin |
| Neon | Free, with auto-suspend | Compute suspends after 5 min idle | First query after a quiet period lags | Keep-alive ping; tolerate cold starts |
| MongoDB Atlas (M0) | Free | 512 MB storage, 100 connections, no backups | Nothing to restore from if data is lost | Scheduled mongodump to object storage |
| GitHub Actions | Free | 2,000 Linux minutes/mo; 60-day auto-disable | Your keep-alive cron stops itself | Don’t use it for keep-alive; use Workers Cron |
| Cloudflare Workers | Free | 100k req/day; 1,000 KV writes/day | Writes run out before reads do | Batch KV writes; track write count |
The Survival Playbook
Every pattern below uses free or do-it-yourself tooling.
Keep-Alive via Cloudflare Workers Cron, Not GitHub Actions
Use a Cloudflare Workers Cron Trigger to send a small scheduled request to your app and its database-backed endpoints. That covers the auto-pause and spin-down cases above. Don’t use GitHub Actions for this. Scheduled workflows auto-disable after 60 days of repo inactivity, so the keep-alive stops exactly when the project goes quiet. Keep the ping infrequent and lightweight, since every request counts against the 100k req/day limit.
Weekly pg_dump and mongodump to Object Storage
Backups are the step most people skip. Atlas M0 has no backups on the free tier, so a scheduled mongodump to object storage is mandatory. Do the same with pg_dump for Postgres-backed services like Supabase and Neon. Weekly is the minimum I’d accept. Restore from a dump at least once, because a backup you’ve never restored is only a hope.
Static Assets to R2 or a CDN
Every image, bundle, and download served from your origin counts against the transfer quota. Vercel’s Hobby plan caps Fast Data Transfer at 100 GB. Move large static files to Cloudflare R2 or a CDN and keep the origin for dynamic requests. It’s the simplest way to keep a traffic spike from pausing features.
Per-Provider Upgrade Triggers
Decide the trigger before you need it. Write one line per provider with the metric, the threshold, and the action. For example: move auth to a paid plan when session walls start hurting retention (Clerk Pro at $25/mo); plan your exit from Vercel Hobby before you earn revenue, given its non-commercial restriction; act when Workers KV writes approach 1,000 writes/day. Set thresholds against your own traffic, not vendor defaults.
Migration Escape Hatches
Choose wire-compatible databases and keep your infrastructure as code. If your database speaks the Postgres or MongoDB wire protocol, moving between hosted providers is mostly a connection-string change plus a dump restore. If your deploy is defined in config files rather than dashboard clicks, moving hosts is a weekend, not a rewrite. Heroku’s 2022 free-tier shutdown and PlanetScale’s 2024 Hobby sunset are the reasons this matters.
FAQ
Why does my Supabase project keep pausing?
Free projects auto-pause after 7 days of inactivity. You restore them manually from the dashboard, and your data is retained. The fix is a scheduled heartbeat from a Workers Cron Trigger, plus a weekly dump in case something else goes wrong.
Is Clerk’s free tier usable for a real app?
It depends on what “real” means. On Hobby, session lifetime is fixed at 7 days, so every user re-logs in weekly. For internal tools and prototypes that’s fine. For consumer apps, plan the re-login experience or treat $25/mo Pro as your trigger.
What happens when I hit Vercel’s Hobby limits?
Features pause until the next usage cycle. The plan’s limits are 100 GB of Fast Data Transfer, 1M function invocations, and 4 CPU-hours of active function CPU. Check your usage against those numbers, and move static assets off the origin before traffic grows.
Does MongoDB Atlas free tier have backups?
No. Atlas M0 has no backups on the free tier, and it caps you at 512 MB of storage and 100 connections. Run a scheduled mongodump to object storage, and test your restores.
What’s the best way to keep a free service awake?
Use a Cloudflare Workers Cron Trigger to send a small, infrequent request. Don’t rely on GitHub Actions, because scheduled workflows auto-disable after 60 days of repo inactivity. Periodic pings also address idle timers such as Render’s 15 min spin-down and Neon’s 5 min auto-suspend.
Are free tiers ever safe for production?
Sometimes, with eyes open. A free tier is reasonable when you’ve mapped its failure mode, keep backups outside the provider, and have written down an upgrade trigger and a migration path. It isn’t reasonable when it holds your only copy of data or your only login system, because the provider can withdraw it at any time. Heroku’s free tier ended Nov 28, 2022, which is the reminder to plan for exit.
How This Guide Was Built
This is desk research. I didn’t sign up for these services or run any of them. Every limit, price, and date comes from the provider documentation and pricing pages linked above, plus the community discussion and third-party reporting I cite by name. Where a figure comes from 2026 third-party reporting rather than official policy, I’ve said so. If a provider has changed its plan since this was written, the official docs win.
The Bottom Line
Verdict: free tiers are fine for validating an idea and risky as an unmonitored foundation. A side project can run on free tiers if every limit has an owner: a keep-alive, an off-provider backup, a monitored quota, and a named upgrade or migration trigger. Without those, the likely outcome isn’t a dramatic shutdown. It’s a slow leak of users who got logged out, hit a paused database, or never got their data back. Use free tiers to validate, and do the survival work before you have users to lose.