Best Heroku Alternative for Django in 2026: Appliku vs Railway vs Render Priced Against One Hetzner Node

Heroku killed its free tier in November 2022 and never looked back. Four years later, a production Django app on Heroku — web dyno, Celery worker, Postgres, Redis — starts around $140 a month, and every additional process multiplies the meter. That bill is the reason "Heroku alternative for Django" guides keep getting written, and the best of them, Appliku's 2026 comparison, puts the field at roughly this: Render from about $38 a month, Fly.io $15–35, Railway $20–30, Appliku on your own server $20–40, Heroku itself $140 or more.

This post takes that comparison at face value and rechecks it line by line. Same reference Django app, priced on every meter, against the row the managed guides underplay: the identical stack self-hosted on one flat-rate Hetzner node. Here is the verdict up front, with receipts below.

Prices are September 2026 list prices for the reference app defined below; every platform reprices eventually, so treat the ratios as the durable part. The punchline is stable across pricing tweaks: Django's boring monolith shape — one codebase, one web process, one worker, one database — gains the least from per-service metering, because there is almost nothing to scale independently.

The reference Django app (so every row is comparable)​

Price comparisons lie by pricing different things. Ours is fixed: a small-production Django SaaS, the shape Appliku's guide and most migration stories describe.

• Web: gunicorn behind TLS, 512MB–1GB of RAM, always on.
• Worker: one Celery worker plus beat for scheduled tasks.
• Postgres: ~1GB dataset with daily backups; point-in-time recovery wanted at the production tier.
• Redis: doubles as cache and Celery broker, 256MB is plenty.
• Traffic: low to medium — hundreds of requests per minute at peak, not Hacker News front page.
• TLS and deploys: free automated certificates, git-push deploys, zero-downtime restarts.

Two tiers matter on every platform: the starter row (cheapest always-on config that runs this stack) and the production row (redundant-ish compute, backed-up Postgres with PITR, non-evictable Redis). Quoting only one tier is how every vendor wins its own comparison. We quote both where the platform has both.

Line-item recompute, platform by platform​

Heroku: the baseline at ~$22 entry, ~$140+ production​

Heroku's meter is per dyno plus per addon, and Django needs at least two dynos plus two addons. Eco ($5 for 1,000 shared hours) sleeps and shares, so the honest entry row is Basic at $7 per dyno, always on: $14 for web plus worker, Postgres Mini or Essential-0 at $5 (1GB), Key-Value Store (Redis) Mini at $3. Total: ~$22 a month for one small web process and one small worker.

Production is where the meter bites. Standard-1X dynos are $25 each, so web plus worker is $50 before data. Postgres Standard-0 (64GB, PITR, high availability story) is $50, Redis above Mini starts around $15, and monitoring plus logging addons land at $15–30. Total: $130–160 a month, matching both Appliku's "$140 or more" and Northflank's 2026 teardown. The jump from entry to production is roughly 6x, driven by dyno class and Postgres tier moving together.

Render: ~$31 starter, ~$102 standard​

Render prices each process and each datastore separately, which reads cheap per line and adds up fast. Starter web service ($7, 512MB) plus starter worker ($7) plus starter Postgres ($7, or Basic 256MB at $6) plus starter Key Value for Redis ($10 for 256MB) totals ~$31 a month. That is the real floor for our stack: Render's free Postgres expires after 30 days, so it is a trial, not a tier.

The standard row — Standard web ($25, 2GB) plus Standard worker ($25) plus Postgres with PITR ($20 and up) plus 1GB Key Value ($32) — lands around **$100–105 a month**. Add the $25 Pro workspace if you want full-stack previews and autoscaling. Appliku's "Render from about $38" sits between our starter recompute and the first production-shaped config; the gap is Postgres and Redis tiers, which is exactly where Django's bill lives.

Railway: ~$20–30 typical, metered by the second​

Railway inverted the model: a plan minimum (Hobby $5 with $5 of usage credit, Pro $20 per seat with $20 credit) plus metered compute at roughly $10 per GB of RAM per month and $20 per vCPU per month, with egress at $0.05 per GB. Postgres and Redis are services on the same meter, not fixed-price addons — you pay for the container resources they consume.

For our reference app, a 512MB web service plus a 512MB worker plus small Postgres and Redis containers meter out to the $20–30 a month band Appliku quotes, with the plan minimum acting as a floor rather than a ceiling. The honest caveat runs both ways: idle staging apps cost less than fixed-price tiers, but there is no flat cap — a memory-hungry worker or a traffic spike shows up on the invoice, and egress is metered from the first byte past credit.

Fly.io: ~$15–35 typical, cheapest compute, asterisk on data​

Fly.io has the cheapest raw compute in this lineup: a shared-cpu-1x Machine with 256MB runs about $1.94 a month, 512MB around $3.50–4. Web plus worker plus a small self-managed Fly Postgres plus Upstash Redis on its free 256MB tier can total under $10 in theory. In practice, production-shaped Django lands at $15–35 a month: bigger Machines, persistent volume storage, paid Upstash Redis (~$10) once you outgrow the free tier, and the Postgres decision.

That decision is the asterisk. Self-managed Fly Postgres is explicitly marked Unsupported, and Managed Postgres starts at $38 a month — more than our entire reference budget on some platforms. Teams that stay cheap on Fly.io pair it with an external Postgres (Neon, Supabase) or accept the unsupported tag. Price the data layer you would actually run in production, not the cheapest row on the pricing page.

Appliku + Hetzner: ~$20–40 all-in, metered by server, not service​

Appliku is bring-your-own-server: you pay the cloud provider for the VM and Appliku for the management layer. Appliku's plans run Free ($0: one server, one app, workers and databases included) to Hobby ($10: unlimited apps and deploys) to Growth ($18: three servers, database backups). The server is yours — a Hetzner CX22-class box with 2 vCPUs and 4GB of RAM at roughly €4–6 a month holds the whole reference stack, and Appliku's own guide puts a small-to-medium Django SaaS (web, Celery worker, Postgres, Redis) on a single server under €8 of infrastructure.

All-in math: $5–8 of Hetzner plus $0–18 of Appliku lands at **$20–40 a month** on a paid plan, less on Free. The structural difference is that the second Django app on the same server costs ~$0 in infrastructure — the meter is per server, not per service. For a team with staging plus production, or three small client apps, that is where the comparison flips hardest against per-service platforms.

The self-hosted row: the same stack for ~$5 of infrastructure​

Remove Appliku's management fee and the infrastructure row is just the VM: a Hetzner CX22 (2 shared vCPUs, 4GB RAM, 40GB NVMe, 20TB of traffic) at €3.49–4.49 a month, roughly $4–5. Web, worker, Postgres, Redis, and TLS all fit; Django monoliths are famously undemanding, and 4GB covers this stack with headroom. A CX23 (€5.49) or dedicated-vCPU CPX22 (~€10) buys margin for growth without changing the architecture.

The honest version of this row prices the labor, not just the VM: you operate Postgres backups, Redis persistence, OS patching, certificate renewal, and the deploy pipeline. Tooling moves that labor around — Dokku, Coolify, CapRover, or a git-push PaaS you host yourself — but only you can delete it by paying a managed platform. Section 5 prices that tradeoff explicitly instead of pretending the $5 row is free.

What the managed premium actually buys for Django​

"Managed" is not one feature; for Django it is a checklist, and platforms score differently per line. This is the table that decides migrations more than the price table.

Three observations fall out of the checklist. First, release-phase migrations are the Django-specific feature most worth paying for: every platform here has some version, so "does it run migrate before traffic switches" should be a migration acceptance test, not an assumed yes. Second, Postgres quality varies more than compute quality — PITR, forking, and restore UX are where the Heroku-to-cheap-platform regret stories come from, so test a backup restore before you commit. Third, the generic rows (TLS, zero-downtime deploys, log tailing) are table stakes everywhere now; they justify no premium by themselves.

The self-hosted row, honestly priced​

The $5 VM row deserves its skeptics' hearing, because the invoice is honest and the labor is real. Here is what operating the reference stack on one Hetzner node actually obligates you to, and what each item costs in practice.

Postgres is the load-bearing decision. On one node, Postgres runs in Docker with a persistent volume, nightly pg_dump or WAL archiving to object storage, and a tested restore. Managed platforms sell PITR and one-click forking; self-hosted, you script dumps plus off-site copies and rehearse the restore quarterly. Tools like pgBackRest or a control plane with scheduled backups compress this to an afternoon of setup and minutes a month — until the day you need a point-in-time restore, when you will be glad you rehearsed.

Redis is simpler than teams fear: persistent AOF plus a volume snapshot covers cache-plus-broker duty at this scale, and losing the cache tier is a performance incident, not a data-loss event. The Celery broker side wants visibility (queue depth, dead-letter handling via Flower or a Django admin integration), which no managed Redis gives you for free either.

The platform layer — git-push deploys, TLS issuance and renewal, process supervision, log aggregation — is what Appliku, Dokku, Coolify, or a self-hosted PaaS provides. This is the correct comparison point for the managed premium: not "VM versus Heroku" but "VM plus control plane versus Heroku." An open-source git-push layer on your own machines keeps per-service metering at zero while recovering the deploy UX teams actually miss: push, release tasks, health checks, traffic switch.

The breakeven math is blunt. Against Heroku production ($140), one Hetzner node plus a $10–18 control plane pays for itself if it saves your team roughly one hour a month at any plausible engineering rate. Against Render starter ($31) or Railway (~$25), the dollar savings are smaller and the decision should hinge on control — fixed IPs, data residency, unlimited staging apps, no per-service multiplier as you add the second worker — rather than the invoice alone.

Migration playbook and verdict​

If the tables above point you off Heroku, the migration itself is a known quantity — Django's deploy conventions (PORT binding, start command, DATABASE_URL, release tasks) are the same ones every alternative inherited from Heroku. The checklist that covers all five destinations:

1. Build image: keep the heroku/python buildpack where the target supports buildpacks (Railway, Render, Appliku); otherwise write the small Dockerfile (Python slim, requirements install, gunicorn CMD) that Fly.io and self-hosted targets expect.
2. DATABASE_URL: export with pg_dump, import into the target Postgres, then cut over with maintenance mode plus a final delta dump; verify extensions (PostGIS, pg_trgm) exist on the target first.
3. Static and media files: run collectstatic in the build step and serve via WhiteNoise for static; move user uploads to object storage (or a persistent volume on your own server) — ephemeral filesystems eat uploads on every platform here.
4. Celery broker URL: point worker and beat at the new Redis URL, drain queues before cutover, and confirm beat runs exactly once (two beats double-schedules tasks).
5. Release-phase migrations: wire migrate into the target's release hook and test on staging with a production-shaped dump; a migration that locks a hot table is the classic cutover failure.

The verdict, by team shape: stay on Heroku only if per-dyno pricing is noise against your revenue and you value its Postgres UX above the $140 floor. Pick Render or Railway if you want managed hosting with a smaller bill and accept per-service metering as you grow. Pick Fly.io if edge latency matters and you have a Postgres answer you trust. Pick Appliku plus Hetzner if you want git-push UX on infrastructure you own with a per-server cost ceiling. And self-host the stack on one Hetzner node behind an open-source control plane if your Django app is what most Django apps are — a monolith that fits on one box and gains nothing from being metered as five services.

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.