Heroku Is Gone: We Re-Ran Encore's Exit Map With Real Bills for Render, Railway, Fly.io, and Hetzner

Encore is right that Heroku is gone, and mostly right about where to go. In February 2026 the company put Heroku into "sustaining engineering" — no new features, no new enterprise contracts — and Encore's guide "Heroku Is Gone, Here's Where Developers Are Going" has become one of the most forwarded exit maps: Render for the fastest migration, Fly.io for edge performance, Railway for team DX, Coolify or Dokku on your own VPS for the lowest cost, and Encore itself on your own AWS or GCP account for infrastructure ownership. The map is good. The prices, as always, are where the trip gets interesting.

So here is the re-audit, with every receipt below. For one fixed, typical stack — two web processes, one worker, a small Postgres, a small Redis — the quiet-month bill is $87 on Heroku, ~$37 on Render, ~$25 on Railway, $18 on Fly.io with self-managed Postgres ($48 with managed Postgres), and ~$5 on a flat Hetzner box. But Encore's own warning is the real story: usage-based bills are harder to predict than Heroku's flat dyno model. Run the same stack through a 3x-traffic week and Render still says ~$30–37, Railway climbs toward ~$40, and Fly.io's per-second meter is the only one that can also go down when traffic stops. The full line-by-line breakdown follows.

Three disclosures before the receipts. First, these are list-price recomputes from public rate cards and docs, not scanned invoices — every rate names its plan so you can redo the math. Second, the Heroku leg reuses the same $87 reference stack as this site's earlier Heroku bill audit so the two posts stay comparable. Third, ops time is excluded on all sides, which flatters self-hosting more than the managed options — the decision guide at the end prices that back in honestly.

The reference stack and the ground rules​

The stack is deliberately boring: two web processes, one background worker, one small Postgres, one small Redis, running 24/7 for a 30-day month. No autoscaling heroics, no multi-region, no read replicas. This is the shape of thousands of ex-Heroku apps — a SaaS starter, an internal tool that escaped, a side project with paying users.

Ground rules: always-on unless a platform's scale-to-zero is explicitly modeled, smallest production-sane tier for data services (not hobby-preview rungs with expiry dates), US/EU pricing where regions differ, and list prices as of mid-2026. Rate cards move — Railway in particular has repriced units before — so treat each total as "about this much, for these reasons" and each meter mechanic as the durable part. The mechanic outlives the price.

Render: the flat bill Encore recommends first, and it is flat​

Encore calls Render "the most direct Heroku replacement" and "the shortest path," and on pricing mechanics that recommendation holds up best of the four. Render's model is flat per-service tiers: a Starter web service or background worker is $7/month (512 MB RAM, 0.5 CPU), managed Postgres starts at about $6/month for the Basic-256mb tier, and managed Key Value (Redis) starts at about $10/month. Our stack sums with almost no arithmetic:

Wait — two webs plus a worker is three compute services, so the honest sum is $21 + $6 + $10 ≈ $37/month. Consolidate to one web plus one worker and it is ~$30. Either way, the spike-month column is the point: nothing moves. A 3x-traffic week costs exactly the same as a quiet week until you manually step a service up a tier ($7 Starter to $25 Standard). That is the closest thing left to Heroku's flat-dyno predictability, and it is Render's real advantage — not the headline number, the shape of the bill.

One correction to Encore's text, though. Its Render section warns that "per-service and per-seat pricing can also add up for larger teams." The per-service half is still true. The per-seat half is stale: Render removed per-seat pricing in 2026 and now charges a flat workspace fee plus compute. For a team comparing "unlimited seats" marketing across destinations, that correction matters — it narrows Railway's seats advantage from "Render charges per head" to "Render's workspace fee versus Railway's included seats," a much smaller gap than Encore's wording implies.

Railway: the meter that bills you while you sleep​

Encore pitches Railway on developer experience and unlimited team seats, and says little about the meter — which is where a Heroku refugee gets surprised. Railway's Hobby plan is $5/month including $5 of usage credit, and everything above that is metered: roughly $10 per GB of RAM per month and $20 per vCPU per month at the rates third-party audits used through mid-2026, plus egress and volume storage. The structural fact matters more than the unit rates: RAM accrues for every hour a service exists, whether or not it serves a request. CPU scales with traffic; RAM does not.

Line by line for the reference stack (steady-state, always-on):

This matches this site's standalone Railway audit, and the quiet total genuinely beats Render. Now the spike month: a 3x-traffic week lifts CPU-seconds roughly 3x and often forces RAM reservations up a notch (bigger heap, more connections, fuller Postgres buffers). CPU is the smaller base so tripling it adds single dollars; the RAM step-up plus a sustained-CPU week pushes the month toward ~$35–40. Nothing catastrophic — but notice the asymmetry with Render. Railway's floor also never reaches zero: there is no sleeping state, so "the app exists but nobody uses it this month" still costs the full resident-RAM bill. Encore's guide never mentions dormancy, and for side projects dormancy is the whole ballgame.

The unlimited-seats differentiator, on the other hand, checks out. Paid plans include unlimited seats, which is genuinely unusual against Heroku's and Render's workspace-fee history. For a five-person team the seats math can outweigh a $10 usage delta. Encore got the emphasis right; it just underplayed the meter that pays for it.

Fly.io: the only meter that goes down as well as up​

Encore's Fly.io section contains its most honest pricing sentence: "usage-based, which can make monthly bills harder to predict compared to Heroku's flat per-dyno model." True — and incomplete, because Fly.io's meter is the only one here with a downward direction. Machines bill per second, and with min_machines_running = 0 an idle service scales to zero instead of billing resident RAM all month. Predictability cuts both ways: the bill is harder to forecast and the floor is lower than anywhere except a VPS.

Always-on first, so the comparison stays apples-to-apples:

The Postgres decision dominates everything else on Fly.io. Swap the self-managed database for Managed Postgres at roughly $38/month and the stack jumps to ~$46–50 — the highest hosted total in this audit, for the platform with the cheapest compute. Encore flags this honestly ("managed Postgres has had reliability challenges... new MPG product"), and the price tag is the other half of that sentence: on Fly.io you are choosing between running your own Postgres on a $2 machine or paying managed prices that erase the compute savings.

Where does the meter move first? Not compute — per-second billing means a 3x-traffic week adds single dollars when always-on, and with scale-to-zero a quiet side project can idle at ~$5/month (volumes plus IPs) while a spike costs only the seconds it burns. The gotchas are the fixed lines: one dedicated IPv4 per app at ~$2, egress at ~$0.02/GB that only matters once you are big enough to notice, and that Postgres fork in the road. Fly.io rewards operators who will manage a database and punish nobody else much. That is a defensible trade, but it is an operator trade, not a Heroku trade.

The leg Encore ranks first: your own AWS account, your own meter​

Encore's top recommendation is itself — infrastructure-from-code provisioned into your own AWS or GCP account — and the re-audit has to note the category difference: this is ownership, not cheapness. A small RDS Postgres instance starts around $13–15/month before storage and I/O, compute for three services runs on real EC2/Fargate rates, and data transfer meters from the first GB. A stack shaped like our reference lands around ~$45–70/month on AWS depending on instance sizing and transfer, comfortably above every hosted PaaS except Fly.io-with-managed-Postgres.

That is not a mark against it. Encore's pitch is compliance and ownership — the infrastructure lives in your account, visible in your console, reproducible from your codebase — and teams that need that (regulated data, enterprise procurement, "no vendor may hold our database") were never choosing on the monthly total.

But a Heroku refugee optimizing for bill size should read Encore's ranking as "first by control, not by cost." The guide's ordering buries that distinction, and the meter matters: unlike Hetzner, AWS ownership still meters every dimension. You trade Render's flat tiers for the full cloud bill with better provenance.

The leg Encore understates: one flat box, then the second machine​

Encore files self-hosting under "lowest possible cost" — Coolify, Dokku, or Dokploy on a Hetzner or DigitalOcean VPS — and quotes the tradeoff as "operational responsibility." Both halves need sharpening. The cost half first: our entire reference stack fits comfortably on a Hetzner CX22 (2 vCPU, 4 GB RAM), currently around €3.79–4.49/month (~$4–5) flat. Web, worker, Postgres, Redis, TLS, all of it. The spike-month bill is identical to the quiet-month bill. There is no meter at all — only a capacity ceiling, reached when the box saturates rather than when the calendar turns.

The tradeoff half is where Encore's single-box framing stops one machine too early. Everything it lists — Coolify, Dokku, Dokploy — solves "manage the box you already have." The bill for that simplicity arrives the day you need a second machine: there is no declarative node lifecycle, no fleet-wide provisioning, no story for Postgres failover across hosts, no shared ingress that survives adding capacity. Operators re-solve placement, networking, volumes, and deploys by hand, per box, forever.

That seam — the gap between a remote-management agent for one server and a real multi-machine platform — is exactly what a Cluster-API-based fleet is built to not have: machines arrive as reconciled objects, the second node joins the same way the first did, and the flat-rate economics survive the growth from one box to a pool.

None of this makes the single box wrong. For a side project or an internal tool, a €4 VPS running Dokku remains the best dollar-per-deploy in existence, and this site's own cost audits keep confirming it. It makes the single box a phase. Encore's exit map draws the destination but not the onward road: pick the box with a migration story for outgrowing it, or pick the meter with eyes open.

What to do Monday morning​

• You want Heroku back, cheapest change: Render. ~$30–37/month, flat, git-push and render.yaml carry your mental model over. Accept per-service tiers as the price of predictability.
• You have a team and spiky traffic: Railway. ~$25 quiet, ~$40 spiking, unlimited seats included. Set billing alerts before your first traffic spike, not after — the RAM meter never sleeps.
• You will manage a database to save money, or your users are global: Fly.io. ~$18 self-managed, ~$48 with Managed Postgres, scale-to-zero for anything idle. Decide the Postgres question first; it matters 10x more than the compute rates.
• You need the infrastructure in your own cloud account: Encore on AWS/GCP. ~$45+/month, metered, and worth it when compliance or procurement — not the bill — is the constraint.
• You want the smallest possible bill and accept the pager: One Hetzner box, ~$5 flat. And if the app outgrows the box, skip the second snowflake server — that is the exact moment a Cluster-API fleet starts paying for itself.

Encore's map got the directions right. The bills just add the contour lines: flat tiers where you want predictability, meters where you want elasticity, and flat hardware where you want both — up to the capacity of the box.

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.