One Heroku Calculator, Three Different Winners — and What Happens When Self-Hosted Is the Fourth Option

The most honest thing about the best Heroku migration guide of 2026 is a recommendation that looks like a bug. Feed its cost calculator a standard Rails app on a $177/month Heroku bill, ask for the cheapest way out, and it recommends Railway at $68 — while showing Fly.io at $54 right there in the same output. The calculator knows Fly.io is cheaper. It down-weights it anyway, because production-grade Postgres HA on Fly is engineering time wearing a price tag, and it refuses to pretend otherwise.

That calculator is the centerpiece of NexGenData's Heroku Is Getting Expensive: A 2026 Cost Calculator + Migration Guide (June 2026, with a companion heroku-cost-calculator actor that prices your actual setup). Its load-bearing feature is a priority parameter — cost, simplicity, or speed — and the same workload gets a different winner under each one. This post does two things: it reruns that workload a fourth time with a flat-rate box you own as an explicit option, with the crossover math worked out, and it pulls out what the calculator's design teaches about writing migration guides that admit tradeoffs instead of crowning one vendor.

The calculator's three answers, in 30 seconds​

The reference is a Rails app the calculator prices at $177/month on Heroku. Here is what each priority returns:

• Cost → Railway at $68/month (high confidence), a ~61% cut saving $109/month or $1,308/year. Fly.io's raw $54 is cheaper on paper but carries medium confidence with the note "Requires managing Fly Postgres HA manually for prod-grade setup." Render lands at $96 ("Cleanest Heroku-feel; preview apps built in"), DigitalOcean at $108, and Cloudflare at not-applicable — a Rails app doesn't map to Workers without a rewrite, and the calculator says so instead of inventing a number.
• Simplicity → Render, on built-in preview apps, the closest deploy feel to Heroku, and the lowest ops burden.
• Speed → Fly.io, on multi-region primitives nothing else in the list can match.

Two more outputs deserve attention because most migration guides would never emit them. When simplicity is the priority and the savings are under ~$200/month, the recommendation string is "probably stay on Heroku and revisit in 12 months." And a postgres_only_migration flag models moving just the database — Supabase Pro at $25/month for 8GB is name-checked — because migrating only Postgres often saves more than moving compute. A calculator willing to recommend its own irrelevance is one you can trust with the numbers that follow.

The fourth rerun: the same workload on a flat-rate box​

Now the rerun the guide doesn't include. Same Rails reference, same three priorities, fourth option: the whole stack on one flat-rate Hetzner box. Our September ledger puts an AX41-class dedicated machine (6 cores, 64 GB, NVMe, 20 TB-class traffic allowance) at roughly $45–55/month; call it $50. It fits this workload several times over, with self-run Postgres and Redis on board.

The cost row needs its crossover worked, not waved at. The guide says the Heroku bill scales roughly linearly for a while, so model staying put as $177 × T against $50 + ops for the box, with engineering time at a loaded $100/hour:

That range is the calculable traffic line: somewhere between "already winning if your ops load is truly an hour a month" and "winning at two-and-a-half times this traffic if it isn't." And the narrowest honest comparison is brutal for the box: against Railway's $68, the hardware saves $18/month — erased by about eleven minutes of unexpected ops attention at $100/hour. If you price engineering time at zero, self-hosting always wins and the comparison is fiction. The calculator already applies this rule to Fly.io's Postgres; the fourth rerun just applies it to us too.

Cost: the hardware wins, the ops budget decides​

On raw dollars there is no contest: $50 of flat hardware against $68–177 of managed bills, and the gap widens with traffic because managed pricing is a slope and the box is a step function. The guide's own scaled example — two Performance-M dynos, Standard-2 Postgres, Premium-0 Redis approaching $800/month — still fits on the same $50 box with room to spare.

But the honest cost-priority answer is the crossover table above, not the hardware line. Below ~1× traffic with a realistic ops budget, you are paying yourself $200–400/month in attention to save $100–130 in bills — worse than staying put, and the guide's "revisit in 12 months" logic applies to self-hosting just as well as it applies to Heroku. Past ~2×, the managed slope has climbed far enough that even a generous ops budget can't close the gap, and the box wins on cost the way it always threatened to. The traffic line isn't a slogan; it's $177 × T = $50 + ops, and you get to plug in your own T.

One more cost honest-to-goodness: Hetzner repriced in June 2026 — dedicated-vCPU lines up 2.1–2.73×, shared-AMD cloud up to ~3× in the US — so the $50 anchor is a September number, not a law of nature. The flat row still reprices the old-fashioned way (once, in public, as one number), but anyone writing "hardware costs $X" without a date is writing fiction on a delay.

Simplicity: the box loses on day one​

This is the priority where the fourth option fails cleanly, and the post is better for saying so. Under Render's $96 you push code and get previews, managed Postgres with backups, TLS, and log drains. Under the $50 box you own every one of those: Postgres backups and restores, OS patching, TLS renewal, deploy plumbing, and the 2 a.m. page when the disk fills. No honest scoring puts eleven-minutes-a-month attention next to zero and calls it a tie.

What would have to be true for the box to compete on simplicity is a git-push layer on top of it — bex, Coolify, Dokploy, Kamal — that restores the push-and-preview loop on flat hardware. That narrows the gap from "run your own PaaS" to "operate one PaaS-shaped appliance," but it doesn't close it: the appliance still needs upgrading, and its Postgres is still yours when a restore goes sideways. Until that layer is set up and boring, Render's simplicity crown survives the fourth rerun untouched. The guide's stay-put rule even covers this case from the other side: if migrating to a box saves you under ~$200/month in bills while costing weekends in setup, the spreadsheet answer and the correct answer disagree, and the correct answer is the weekend.

Speed: it depends which latency you mean​

Speed splits, because "fast" is two different promises. If your users live in one region and your workload is database-heavy, the box is genuinely quick: dedicated cores with no noisy neighbors, NVMe instead of networked disks, and Postgres on localhost instead of across a cloud network hop. Single-region p95 is a fight the $50 box can win against any managed row.

If your users are global, Fly.io wins and the box isn't close. Multi-region machines, anycast, and read replicas near the reader are primitives a single Hetzner region cannot emulate, and no amount of localhost Postgres compensates for 150ms of ocean. The guide picks Fly.io for speed without hedging, and the fourth rerun seconds that — with the one-region carve-out stated plainly. Know which latency your readers actually feel before you let either side claim this priority.

Where self-hosted honestly doesn't win​

Collecting the losses in one place, since a fourth option that only ever wins is marketing:

• Global latency, as above. One region is one region.
• Day-one ops. Setup weekends, backup drills, and upgrade runbooks are real costs the managed rows price into the bill.
• Compliance re-audits. The guide flags Heroku Shield (HIPAA, PCI-DSS high-trust, SOC 2 with audit trails) as a reason to stay: if your BAA is signed and your auditor is comfortable, re-certifying a box you operate can dwarf years of compute savings.
• Rewrite-class workloads. The calculator returns not-applicable for Rails-on-Workers rather than a fake number; some apps genuinely don't map to a single box either (spiky-to-zero traffic that bills nothing on usage metering, workloads needing managed primitives you can't self-run cheaply).
• The anchor moved. June's Hetzner repricing means every "just buy a box" number needs a date stamp and a re-check cadence — the same nightly pricing refresh the calculator runs for managed vendors.

What this calculator teaches about writing migration guides​

The meta-lesson is the part worth stealing. Four design choices make this guide honest in ways most vendor comparisons aren't:

1. The priority parameter. Refusing a single right answer forces the reader to state what they actually optimize for — and surfaces that cost, simplicity, and speed genuinely disagree. Every migration guide should make its reader pick before it picks for them.
2. Confidence plus down-weighting. Fly.io at $54 with medium confidence and an ops flag beats both "$54, cheapest, migrate now" and silently dropping the row. Uncertainty shown beats uncertainty hidden.
3. "Stay put" as a valid output. A guide that can recommend doing nothing earns trust for every recommendation to do something. The ~$200/month simplicity threshold is the kind of concrete tripwire most guides avoid because it shrinks their funnel.
4. Partial migration as a first-class flag. The Supabase-$25 Postgres-only path admits the bill has lines and only some need moving — a more useful unit of advice than wholesale replatforming.

And three gaps the next version should close: there is no self-hosted option (this post's whole point), ops time is flagged but never dollarized into the estimates, and enterprise discounts are flagged-not-modeled — fine, as long as the flag stays visible. A calculator that fixed all three would be the rare migration tool that prices the thing migrations actually cost: attention, not instances.

Run your own numbers before your next renewal. Plug in your real bill, pick the priority you actually hold at 2 a.m. — not the one that flatters your architecture — and see whether the spreadsheet agrees with your roadmap. If it says stay, staying is also a decision worth documenting.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with flat-rate economics instead of a meter on every dimension. Star the repo on GitHub or deploy your first app today.