We Took the $828/Year Heroku-to-Render Rails Migration One Hop Further: What Self-Hosted on Hetzner Actually Costs

In May 2026, a developer documented moving a production Rails app off Heroku and onto Render: web process, Sidekiq worker, same heroku.yml topology translated almost line-for-line into Render's render.yaml Blueprint format. The result was a monthly server bill that dropped from $108 to $39 — $828 a year back in the developer's pocket, for what the writeup describes as an afternoon of mostly mechanical work.

That's a real, well-documented number, and it's also not the end of the road. The same web-plus-worker pair, run self-hosted behind a Cluster-API-managed Kubernetes fleet instead of stopping at Render, lands between $27 and $55 a year in compute at a realistic tenant density — and with Postgres and Redis added into the same self-hosted stack, a realistic full-topology number lands between $53 and $118 a year, against Render's own full-stack estimate of roughly $672 a year. Neither is one cherry-picked number: both depend heavily on how many other apps share the machine and which Hetzner region you're in, and one of those two variables got meaningfully worse a month before this post was written. Here's the math, done honestly, using the original developer's own before-and-after figures as the baseline.

What the Original $828/Year Actually Measured​

Worth being precise about scope before extending it. The original writeup's $108 → $39 delta covered compute only — the web dyno/service and the Sidekiq worker dyno/service. Postgres and Redis were already running on managed services external to Heroku before the migration, and stayed there after it; they weren't part of the $69/month saved because they never touched Heroku's or Render's bill in the first place. The migration itself was mostly a config translation exercise, not a database migration.

That scoping choice makes the original number very clean, but it also means "what the same app costs self-hosted" has two honest answers depending on what "the same app" includes:

1. Compute only — the same narrow scope as the original $828/year figure, extended one hop further.
2. Full topology — web, worker, Postgres, and Redis all self-hosted, since a platform built to not offer managed databases as a product doesn't get to wave that part away when the topology explicitly includes it.

Both numbers are below, because reporting only the first would understate what "self-hosted" really costs once the database stops being someone else's problem.

The Cost Ladder, Compute Only​

Real, cited unit prices, extended from the developer's own $108/$39 baseline:

That self-hosted range isn't fuzziness — it's the honest sensitivity to one variable: how many other tenants' apps share the node with yours. A Rails web process plus a Sidekiq worker at this app's scale needs roughly 1 vCPU / 2 GB combined — call it one "unit." Put that unit on a Hetzner CX43 (8 vCPU / 16 GB, €15.99/month post-price-adjustment, roughly $18.35) and the number depends entirely on how many units share the box:

Six tenants per node, leaving roughly 25% capacity unused for ingress controllers, metrics agents, and traffic spikes, is a defensible real-world number — not the theoretical max. At that density, this app's compute cost drops to about $37 a year: a 92% cut past Render's already-discounted $468/year, and a 97% cut from Heroku's original $1,296. At one tenant per node — i.e., you're not actually sharing infrastructure with anyone — the number is $220/year, which is still cheaper than Render but nowhere near as dramatic, and arguably not worth the operational lift over just staying on Render.

Adding Postgres and Redis: The Number the Original Article Didn't Have To Answer​

The original developer's Postgres and Redis stayed on a third-party managed service throughout, so their cost never entered the $828/year figure. A self-hosted continuation on a platform that doesn't sell managed databases as a product doesn't get that luxury — Postgres and Redis have to run somewhere, and "somewhere" here means containers on the same fleet, backed by real block storage.

Pricing that honestly: a small production Postgres instance plus Redis for an app this size needs roughly another 0.5 vCPU / 1 GB of compute (in line with what Heroku's own Postgres Mini and Redis Mini plans target), plus persistent storage. Hetzner's block storage runs €0.0572/GB/month (about $0.066), so 10 GB of Postgres data plus headroom for WAL and a snapshot costs roughly $0.66/month — genuinely close to a rounding error next to compute.

Full stack per app — web, worker, Postgres, Redis — now needs about 1.5 vCPU / 3 GB combined, versus 1 vCPU / 2 GB for compute alone. That changes how many tenants fit per node, so the sensitivity table looks different too:

Stacked against the two platforms it's descended from:

The $53–$118/year range at realistic (2–9 tenant) density is the number this post's title owes the reader — not the compute-only $37, and not a bare "self-hosting is basically free" hand-wave. At the low end that's roughly a 92% cut against Render's full-stack estimate. It also comes with a caveat that matters more here than anywhere else in this ladder: this buys infrastructure, not a managed-database product. Automatic failover, point-in-time recovery, and patch management are things a team wires up itself on top of that compute-and-storage line — a self-hosted platform that doesn't offer managed databases isn't hiding that cost in the sticker price, it's just not charging for it at all. Weigh that trade-off against what a managed Postgres add-on is actually worth to your team before treating this range as directly comparable to Render's $56/month.

The Wrinkle: Hetzner Raised Prices a Month Before This Math Worked​

None of the numbers above are cherry-picked to make self-hosting look better than it is — and the timing here makes that worth stating plainly. On June 15, 2026, Hetzner raised cloud pricing across its CPX and CCX lines by as much as 150–200% for new orders and rescales. The cost-optimized CX line this post's math relies on saw a smaller but real increase too:

Two things compound here, and both matter to whether the $53–$118/year numbers above are realistic for a given team:

• The cheap CX line is EU-only. It's sold in Hetzner's German and Finnish datacenters, not in US or Singapore regions. A team that needs infrastructure closer to US traffic has to use the CPX line instead — the one that took the full 150–200% hit.
• CPX pricing post-hike changes the math meaningfully. Running the same full-topology calculation on a US-region CPX32 (4 vCPU / 8 GB, ~$41.99/month) instead of an EU CX43 fits only about two apps at this footprint (RAM-bound) and lands closer to $260/year per app — still a real cut below Render's $672, but nowhere near the EU-region $53–$118 range.

None of that erases the case for self-hosting. It does mean the honest answer to "what does it cost" is "it depends where you run it and how many tenants you're sharing it with" — not a single flattering figure that ignores the variable that actually drives the result.

Why the Savings Come From the Platform, Not the Hardware​

The clearest way to see what's actually doing the work here: the one-tenant-per-node case ($220/year compute-only, no bin-packing) is a real number, but it's a much smaller win than the six-tenant case ($37/year), and it requires exactly the same amount of manual docker-compose-style operation a solo Hetzner VPS always has — no rolling deploys, no automatic rescheduling if a node dies, no shared control plane amortizing its own overhead across many apps at once.

The 92%+ cuts in the tables above aren't a property of Hetzner hardware being cheap — Hetzner just got meaningfully less cheap a month ago, and the numbers still hold up. They're a property of a Cluster-API-managed fleet bin-packing many tenants' workloads onto shared nodes, the same way Render's own $25–$39/month pricing already reflects Render running many customers' services on shared infrastructure and marking up the difference. Self-hosting that same bin-packing model on hardware you own, instead of hardware a vendor owns and re-sells to you at a margin, is the actual mechanism — not "cheap VPS beats managed platform."

This is the same bin-packing model bex.co runs on: push a git repo, and the app schedules onto a Cluster-API-managed fleet's existing shared capacity instead of a dedicated VM billed per app. bex doesn't sell managed Postgres or Redis — the $53–$118/year range above is what self-hosting those alongside the app actually costs in infrastructure, with the operational ownership that implies. Star the repo on GitHub or deploy your first app today.