Suga's Docker-Lens Heroku Shootout, Audited: What Seven Platforms Really Cost Teams That Ship a Dockerfile

Heroku entered sustaining engineering mode in February 2026: security and stability updates only, no new features, and no new Enterprise contracts for new customers. That announcement turned every "Heroku alternatives" post from a thought experiment into an exit plan. The most useful one for container teams arrived September 15, when Suga's Rak Siva published a guide comparing seven alternatives specifically for Docker workloads — Suga, Railway, Render, Northflank, Fly.io, DigitalOcean App Platform, and Google Cloud Run — with pricing and features verified that day.

It is a good guide, and it has one gap: it profiles the seven platforms without ever price-ordering them. No two-vendor comparison prices the same stack twice, so a team that ships a Dockerfile still cannot answer the only question that matters — what does our exact stack cost on each, and where does each one bill a container-native shape worst? This post is that audit. Same reference workload, seven invoices, one flat-rate Hetzner box as the eighth row.

The audit box: method, sources, and what changed​

Reference workload: a steady-state, always-on stack — a web container (0.5 vCPU, 512 MB), a worker container (0.25 vCPU, 256 MB), Postgres holding about 10 GB, a Redis-compatible cache, and 100 GB of monthly egress. Compute rates come from Suga's September 15 verification; Docker mechanics come from vendor docs and Railway's September 30 Docker guide; Render's 2026 reprice details (metered $0.15/GB bandwidth past a 25 GB Pro allowance, $0.30/GB Postgres storage) come from Render's own August announcements as covered in this blog's pricing ledger. All rows recomputed October 2026 on a 730-hour month, stated to the nearest half dollar, with the database shape made explicit per row because it moves the answer.

Suga's framing was seven unranked profiles plus pick-by-need guidance — no price-ordered verdict, no database-shape column, no self-hosted row. The audited Docker-lens price order for the reference stack is: Hetzner ($5.50), Fly.io ($30), Northflank ($32), DigitalOcean App Platform ($32), Railway ($43.50), Render ($44), Suga ($55.50), Cloud Run ($95). Three corrections fall out of the repricing: Render's flat-$7 story now leaks $11.25 in metered bandwidth at just 100 GB of egress; Fly.io's managed Postgres at $38 a month would more than double its row, so the Docker-shape answer is container Postgres on volumes; and Cloud Run finishes last for a steady-state stack because its state floors cost more than its containers.

The same stack, eight invoices​

Two rows deserve their footnotes up front. Fly.io's row prices container Postgres on volumes because Fly's managed Postgres starts at $38 a month plus $0.28/GB — choosing managed would nearly double the row, which is precisely the kind of Docker-shape decision this audit exists to surface. Cloud Run's row assumes one always-warm instance per service; let them scale to zero and the compute line collapses — but then you no longer have the always-on stack the other seven rows price, and the $66 in state floors stays either way.

What the Dockerfile assumption changes​

Assuming a Dockerfile instead of a detected runtime changes the comparison along four axes: who builds the image and what the build costs, what pulls cost, which architectures run, and where state can live. The table below is the per-vendor answer; the paragraphs after it are the gotchas that only bite container teams.

Build caching is the first place the Dockerfile lens bites. Railway documents the full story: BuildKit with cache mounts, warm builder pools, and a measured 15-second Dockerfile deploy versus 6 seconds for a prebuilt image — with the explicit advice that cache hits are not guaranteed and CI-built images are the escape hatch. Render caches intermediate layers too, but its public-image pull cache introduces a staleness trap: redeploying against a mutable latest tag can silently reuse a cached older image, so Docker teams must pin digests. Fly.io sidesteps the laptop problem entirely with free remote builders — Apple Silicon teams never cross-build — while Cloud Run prices the build outside the runtime: Cloud Build minutes and Artifact Registry storage are separate meters that never appear in a "serverless containers" pitch. And Cloud Run is the strictest about architectures: it rejects arm64 images outright, so an image built on an Apple Silicon Mac without an explicit platform flag fails to start instead of running slowly under emulation.

Persistent disks are the second place, and the spread is brutal. DigitalOcean App Platform and Cloud Run simply have no volumes: DO's container filesystem is ephemeral and capped at 4 GiB, which is why its invoice row is forced into a $7 Postgres plus a $15 Valkey whether you like it or not. Render has disks but punishes their use: attach one and the service pins to a single replica and loses zero-downtime deploys — a direct tax on the stateful-container shape. Railway, Northflank, Fly.io, and Suga all offer real volumes at $0.11–0.15/GB-month, which is why their rows can run Postgres as a container and their worst lines live elsewhere.

Where each of the seven bills you worst​

Suga: the compute rate. At $0.05/vCPU-hour — $36 per vCPU-month — Suga charges the highest always-on compute rate in the field, and pairs it with the joint-highest egress rate at $0.12/GB. The MCP-driven environment setup and cross-container variable references are genuinely the best agent story in the group, but the meter prices that experience accordingly: our modest 1-vCPU-ish stack burns $38 in compute before a byte leaves the region.

Railway: the shape that never sleeps. Per-second metering at $20/vCPU and $10/GB-month is fair for bursty workloads and punishing for steady ones — a container that never idles pays the full meter every second of the month, which is how a small stack reaches $43.50. The quieter sting is storage defaults: Pro volumes default to 50 GB, so a team that never resizes pays $7.50 a month for a 10 GB database.

Render: floors that multiply. Two $7 Starter services, a $6 Postgres, and a $10 Key-Value floor total $30 before storage and bandwidth — every sidecar is another $7, and there is no 0.25-vCPU tier to shrink into. Then the 2026 reprice's metered edge does its work: 100 GB of egress costs $11.25 past the 25 GB Pro allowance, a line item that did not exist in Render's flat-rate era.

Northflank: egress from byte one. Northflank's compute ($12.17/vCPU-month) is the cheapest metered rate in the field and requests are no longer billed at all — but egress is $0.06/GB with no free allowance whatsoever, so the meter runs from the first byte. Runner-up: every database addon bills its own vCPU and RAM rather than a bundled addon price, so small multi-service stacks feel each addon as a separate compute floor.

Fly.io: geography. The $0.02/GB NA/EU egress rate is the cheapest in the field, and the $0.12 India rate is the most expensive — a 6x spread inside one vendor's invoice. A Docker team that picks regions for latency without pricing them can watch the egress line multiply while nothing else changes. Volumes at $0.15/GB and manually-provisioned addons (Fly Postgres, Upstash Redis, Tigris) complete the picture: cheap to run, operator-shaped to assemble.

DigitalOcean: the no-volume ultimatum. No persistent volumes means every stateful need exits the $5-container price list and enters the managed catalogue: $7 Postgres dev plus $15 Valkey entry turn a $10 compute stack into a $32 invoice before overages. Add 1-vCPU minimum containers — a 0.5-vCPU web process buys twice the CPU it needs — and DO is the vendor where the Dockerfile shape fits worst despite the friendly $5 headline.

Cloud Run: state that costs more than compute. Request-based billing is a genuine bargain for idle workloads, but our always-warm reference pays ~$32 for compute and ~$66 for the Cloud SQL and Memorystore floors that ephemeral instances make mandatory. No other vendor's state-to-compute ratio comes close. Cloud Run wins the bursty shape by a mile and loses the steady-state shape by the same distance — which is why workload shape, not brand, is the right way to read this table.

The break-even math on a box you own​

The eighth row needs little arithmetic. A Hetzner CX22 — 2 vCPU, 4 GB RAM, 40 GB SSD, 20 TB of EU transfer — lists at €4.49 a month plus about €0.60 for IPv4, roughly $5.50 all-in. The entire reference stack (web, worker, container Postgres, container Valkey, 10 GB of data) fits inside the 40 GB SSD with room for the OS and a local registry; 100 GB of egress is half a percent of the included transfer. The registry, the warm builder cache, and the disk are already paid for — marginal cost zero, no per-service floor, no egress meter in sight. That is 6x under the cheapest managed row and 17x under the priciest.

The honest question is what moves that verdict, and three variables do. First, egress volume: at 1 TB a month, Suga adds $108, Railway adds $45, Northflank adds $54, Render adds ~$146 past its allowance, Fly.io adds $18–108 depending on region — and the Hetzner row still reads $5.50, because 1 TB is 5% of its pool. Egress is the variable that most vindicates the box, and the reason every metered row's worst line involves bytes leaving the region.

Second, workload shape: let the stack idle 70% of the time and Cloud Run's request billing plus Railway's and Fly.io's per-second meters collapse toward single digits, while the box still invoices $5.50 for capacity nobody uses. The box wins steady-state; the meter wins bursty — the crossover sits wherever your duty cycle does, and preview environments, cron-shaped traffic, and nights-and-weekends internal tools live on the meter's side of it.

Third, labor: the $5.50 row includes no managed Postgres, no point-in-time recovery, no one to page but you. If nobody on the team can resuscitate a database, the managed rows are not overpriced — a single data-loss incident costs more than years of the gap. The box is cheapest measured in dollars and most expensive measured in attention; price both before you pick.

Pick by shape, not by brand​

If the workload is steady-state and boring — the modal small SaaS, the internal tool nobody turns off — the ranking above is the answer, and the box wins by multiples. If it is bursty with long idles, Cloud Run's request billing or Railway's per-second meter undercuts even the flat box once you count the labor of running your own scaler-to-zero. If it needs TCP/UDP, raw sockets, or eighteen regions, Fly.io is the only PaaS-shaped answer; if it needs GPUs, per-millicore K8s control, or BYOC into your own cloud account, Northflank stands alone; if the databases and VPC already live in DigitalOcean or GCP, the platform gravity of App Platform or Cloud Run usually beats the invoice math.

What Suga's guide got right is that there is no single Heroku replacement — only trade-offs between grouping models, state stories, and meters. What the audit adds is the price tag on each trade-off for the team that ships a Dockerfile: the build cache you thought was free, the volume default you never resized, the egress allowance that shrank in a reprice you missed, and the state floor that costs double your containers. Read the meter before you pick the brand.

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.