Dora NodaA production Django app on Heroku — one web process, one Celery worker, a scheduler, Postgres, and Redis — now bills at $140 or more every month, on a platform Salesforce moved to sustaining engineering in February 2026. The same stack prices out at $15–$35 on Fly.io, $20–$30 on Railway, and roughly $38 and up on Render. That gap is the whole exit conversation in one sentence.
But generic PaaS shootouts consistently misprice Django apps, because they benchmark a single stateless web process against a database. A real Django deployment has a worker dyno that never sleeps, a Postgres tier that jumps in $50 steps, and a Redis broker most comparisons forget to bill. This post recomputes the exit math line by line for the stack Django teams actually run, then checks when the ranking flips.
The exit bill, up front
The reference workload below is the boring, typical Django production shape: a gunicorn web process, one Celery worker, one beat/scheduler process, a managed Postgres, and Redis as the Celery broker. Heroku figures are current list prices; alternative totals follow the 2026 Django-focused Appliku Heroku-alternatives roundup, cross-checked against each vendor's pricing page where noted.
| Line item | Heroku | Render | Railway | Fly.io | Hetzner (one flat-rate box) |
|---|---|---|---|---|---|
| Web process | $25 (Standard-1X) | ~$7 (Starter) | usage (~$5–10) | ~$2–6 (shared-cpu Machine) | included |
| Celery worker | $25 (Standard-1X) | ~$7 (Starter worker) | usage (~$5–10) | ~$2–6 (second Machine) | included |
| Scheduler / beat | $7 (Basic) | ~$7 (cron or worker) | usage (~$1–3) | ~$2 (small Machine) | included |
| Postgres | $50 (Standard-0) | ~$7–20 (Starter) | usage (~$5–10) | ~$2–10 (Fly Postgres or external) | included |
| Redis | $15 (Premium-0) | ~$10 (Key Value) | usage (~$2–5) | ~$2–5 (Upstash or Fly Redis) | included |
| Total | ~$122–140+/mo | ~$38+/mo | ~$20–30/mo | ~$15–35/mo | ~€4–8/mo |
Two things to notice before we go further. First, the Heroku column lands at $122 on conservative list prices — one Standard-1X web, one Standard-1X worker, a Basic scheduler, Postgres Standard-0 at $50, and Redis Premium-0 at $15. Appliku's $140+ figure assumes slightly more headroom (a Standard-2X web dyno at $50, or a larger Postgres tier), which is where most production Django apps actually sit. Either way, it is triple digits before traffic exists.
Second, the Hetzner column is not a typo. A CX22 cloud server (2 vCPU, 4 GB RAM, 40 GB disk, 20 TB of traffic) lists around €4 per month, and the ARM-based CAX11 is in the same band. The entire reference stack — web, worker, beat, Postgres, Redis — fits on that one box with room to spare. The catch, which we will price honestly later, is that the box does not operate itself.
Why Django apps bill differently than the generic shootout workload
Generic Heroku-alternative rankings benchmark something like "one web service plus a database." That shape flatters every vendor and misleads every Django team, because it drops the three lines that make Django expensive:
The worker never sleeps. A Django app with background jobs runs Celery workers as separate, always-on processes. On Heroku that is a second dyno at full price — another $25/mo for Standard-1X — not a fractional add-on. Platforms with scale-to-zero (Fly Machines, Railway's per-second usage) only charge for the worker's actual CPU seconds, which is why the worker line is where metered platforms pull away hardest.
Postgres jumps in cliffs, not slopes. Heroku Postgres Essential-0 is $5/mo and Essential-1 is $9/mo, but the moment you need production features (forking, follow, real connection headroom), Standard-0 starts at $50/mo and Standard-2 at $200/mo. Django's ORM is connection-hungry — each gunicorn worker holds connections — so Django apps hit the Standard tiers earlier than the shootout workload assumes. That single tier jump is often a bigger swing than the entire compute bill on an alternative.
Redis is a line item, not a freebie. Celery needs a broker, and Heroku Redis Premium-0 starts at $15/mo. Generic comparisons that benchmark "web plus Postgres" silently drop this $15 from Heroku's column while the alternatives bundle cheap Redis (Render Key Value from ~$10, Railway usage-based, Fly plus Upstash). Forgetting the broker understates Heroku's bill by more than the whole Fly.io total.
Any exit math that omits these three lines is answering a different question than "what does leaving actually save us."
Recomputing the bill, platform by platform
Here is how each column in the table is derived, so every cell is reproducible from public list prices.
Heroku: $122–140+/mo, list price, no negotiation. Standard-1X dynos at $25 each for web and worker, a Basic dyno at $7 for the scheduler, Postgres Standard-0 at $50, Redis Premium-0 at $15. Eco dynos ($5/mo) exist but sleep, which disqualifies them for anything with a Celery worker. Note what is not in this total: Heroku charges per dyno per process type, so a second worker or a staging app multiplies the compute lines directly. And since Salesforce moved Heroku to a sustaining engineering model in February 2026 — security and reliability patches, no new features, no new enterprise contracts — this bill is the permanent floor. It will never get cheaper through platform improvements.
Render: ~$38+/mo. Render prices each process type as its own service: a Starter web service ($7), a Starter background worker for Celery ($7), a cron job or small worker for beat ($7), Starter Postgres ($6–7), and a Key Value (Redis) instance (~$10). That sums to the high $30s on paid tiers, matching the roundup. Render's free tier exists but spins web services down after 15 minutes of inactivity, so it cannot host the worker half of a Django stack. The step up to production-grade Standard instances ($25 per service, $65+ for larger Postgres) is the cliff to watch — Render's bill roughly doubles the moment you outgrow Starter.
Railway: ~$20–30/mo, metered. Railway's Hobby plan carries a $5/mo minimum that includes $5 of usage; Pro is $20/mo with $20 of usage included, and everything beyond bills per-second for vCPU, memory, and egress. A Django web process, worker, beat, Postgres, and Redis typically consume $20–30 of metered usage at modest traffic. The honest caveat is variance: usage billing means a traffic spike or a runaway Celery task shows up on the invoice, whereas Render's per-service pricing is fixed. Railway's own docs position $5–15/mo for a small app plus database; the full five-process Django stack sits a tier above that.
Fly.io: ~$15–35/mo, cheapest metered option. Fly Machines bill per-second with a tiny base — a shared-cpu-1x Machine with 256 MB starts around $2/mo before usage. The Django shape maps to three small Machines (web, worker, beat) plus Postgres (self-managed Fly Postgres on a small volume, or an external free-tier provider) and Redis (Upstash or Fly Redis). Community practice is explicit that Celery and Django should run on separate Machines rather than sharing one via a supervisor script, so the honest count is three Machines, not one. Total: $15 at the quiet end, mid-$30s with real traffic and a larger Postgres volume.
Hetzner flat-rate: ~€4–8/mo of compute, plus your operations time. One CX22 or CAX11 box (~€4/mo) runs all five processes as containers or systemd units, with Postgres and Redis on the same disk. A larger CPX or dedicated-vCPU box (€8–15/mo) covers headroom. This is the number the BYOS (bring-your-own-server) vendors anchor on: Appliku's managed layer on top of your Hetzner box lands the managed total around $20–40/mo, which is the apples-to-apples comparison against Railway and Render — raw Hetzner is cheaper only if your ops time is free.
What the meters don't show: the migration half of the price
The monthly bill is half the exit math. The other half is the one-time migration cost, and it varies by platform in ways that favor teams who count it before they move.
Buildpacks vs. Dockerfiles. Heroku's Python buildpack means most Django apps deploy with zero container knowledge — a requirements.txt, a Procfile, and git push. Render and Railway both accept that shape (Render has native Python runtimes plus render.yaml; Railway uses Nixpacks build detection), so the migration is mostly config translation. Fly.io wants a Dockerfile, full stop. Writing and hardening your first production Dockerfile — multi-stage builds, non-root user, gunicorn signal handling, static-file collection via WhiteNoise or an object store — is a day or two of real work the first time. It is worth doing, but it is not free.
Procfile to platform config. Every platform reinvents the Procfile: render.yaml service definitions, Railway's service settings, fly.toml process groups, or raw Compose files on Hetzner. The translation is mechanical for web/worker/beat splits, but Heroku conveniences like release-phase migrations (release: python manage.py migrate) and the Scheduler add-on need explicit replacements — a deploy hook, a cron service, a beat container — on every target.
Postgres behavior, not just Postgres dollars. Teams underestimate this one. Heroku Postgres conveniences — fork, follow, point-in-time rollback on Standard tiers, pg:push/pull — have no one-click equivalent on most alternatives. Migrating the data itself is a pg_dump/restore window with a write pause; rebuilding fork/follow workflows for staging environments is ongoing toil. If your team forks production weekly for debugging, price that workflow's replacement before you move.
Regions and egress. Heroku runs in a handful of AWS regions; Fly.io runs at the edge in dozens. Moving to Fly can improve latency for a global user base while cutting the bill — a genuine win-win that the dollar table understates. Egress is the reverse check: Hetzner's 20 TB included traffic dwarfs every metered platform's allowance, so a media-heavy Django app (user uploads, generated reports) widens Hetzner's lead the moment bandwidth enters the bill.
When the ranking flips: sensitivity, not a single number
A single table invites the wrong conclusion — that one platform is "cheapest" full stop. Two realistic changes reorder the ranking, and both are common in the Django cohort.
Flip 1: the database outgrows the starter tiers. Suppose the app's data or connection count forces Heroku Postgres Standard-2 at $200/mo. Heroku's total jumps past $300/mo while Render's larger Postgres tiers or a Hetzner-hosted Postgres (still €0 marginal on the same box) absorb the same growth for a fraction of that. The bigger the database need, the worse per-tier managed pricing looks against flat-rate capacity. This is the single most common reason Django exits accelerate after the first year: the app grows into a Postgres cliff, not a compute cliff.
Flip 2: the worker count grows — or shrinks to zero. At three Celery workers, Heroku adds $50–75/mo of dynos while Fly.io and Railway add a few dollars of usage each; metered platforms extend their lead roughly linearly with worker count. But the flip runs both ways: a side project that idles 20 hours a day pays nearly full freight on Render (fixed per-service pricing) while Fly Machines scale to zero and Railway bills near-nothing for idle. The idle Django app is Fly.io's best case and Render's worst — same stack, opposite ranking, driven entirely by duty cycle.
The durable lesson: price your shape (database size, worker count, duty cycle), not the shootout's shape. The table above is the starting point, and these two variables are the sensitivity analysis.
The exit math for the Django cohort
Heroku in sustaining mode means the $140+/mo baseline is not a number that improves with patience — no new features, no new pricing creativity, just maintenance. Against that frozen bill, every alternative in the table saves 70–90% on metered cost for the same five-process Django stack, with the framework-specific lines (worker, Postgres tier, Redis broker) doing most of the work the generic comparisons miss.
For teams that want Heroku's git-push feel without the per-dyno meter, the honest shortlist is small: Railway or Render for the closest Heroku-like experience, Fly.io for the lowest metered bill and the best global latency, and a flat-rate Hetzner box — managed or self-operated — once the Postgres tier math dominates. Any of them beats paying triple digits for the privilege of a frozen platform.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Star the repo on GitHub or deploy your first app today.
