Hetzner's June 2026 Price Hike Doubled Some Instances — Here's the Recomputed Break-Even Against Render and Railway

Hetzner raised prices twice in 2026. The April adjustment made headlines with a "37%" headline number. The June 15 adjustment was worse, and the headline number undersold it: some instance families didn't go up 37% — they went up 209%. A CPX41 in Hetzner's US region that cost $46.49/month before June 15 costs $141.49/month after it. Meanwhile, in the same announcement, the CX and CAX lines — Hetzner's cheapest shared-vCPU and ARM tiers — moved by roughly 30%, the number everyone quoted.

That gap matters more than the average. If you built your self-hosting cost model around whichever instance family you happened to pick eighteen months ago, the June 2026 adjustment just changed which family that was by a factor of two to three, and most "Hetzner vs Render" comparisons floating around right now are quoting pre-hike numbers, post-hike numbers for the wrong tier, or an average across tiers that don't average meaningfully. Below is the actual table, a recomputed topology cost on each Hetzner tier, and the same topology priced on Render and Railway.

What Actually Changed on June 15​

Hetzner's own price-adjustment page breaks the increase out by instance family and region, and the spread inside a single announcement is the story:

A CCX23 (dedicated, 4 vCPU) went from €31.49 to €85.99/month in Germany — a 173% increase — and its USA equivalent went from $39.99 to $102.99, a 157% increase. A CPX52 went from €36.49 to €100.49, +175%. Against that, a CAX21 (4 ARM vCPU, 8 GB) moved from €7.99 to €10.49, +31%, and a CX23 (2 vCPU shared) moved from €3.99 to €5.49, +38% on a base so small the absolute delta is €1.50.

Existing contracts are grandfathered — the new prices apply only to new orders and rescales starting 8am CEST on June 15. Hetzner attributes the hike to a DRAM and NVMe cost shock: memory-market trackers put DRAM contract prices up roughly 90–98% quarter-over-quarter in Q1 2026 as AI hyperscalers redirected wafer capacity toward high-bandwidth memory, each gigabyte of which consumes about triple the fab capacity of a standard DDR5 module. This followed an April 1, 2026 increase (up to 37%, same root cause) — June is the second hike inside three months, and CPX/CCX customers who shrugged off April's number just got hit again, harder.

The Recompute: Same Topology, Four Ways​

Take the topology most self-hosted setups actually run: one web service, one background worker, one Postgres instance. Size it modestly — 2 vCPU / 4 GB for web and worker, 4 vCPU / 8 GB for Postgres, which needs the extra headroom for buffer cache and connections. Here's what that costs on four different choices, all Germany/Finland pricing, all post-June-15:

Read that table straight through and the headline isn't "Hetzner got more expensive" — it's that the CPX post-hike total ($85) is 3.4x the CX/CAX post-hike total ($25) for identical workloads, because CPX and CX are priced on entirely different curves after June 15, not two points on the same one. Pre-hike, CPX and CX/CAX were close enough that the choice barely mattered (€29.97 vs. roughly €22 — a 36% gap). Post-hike, picking CPX out of habit costs more than the entire Render bill for the same topology, which is the actual finding here: the instance-family choice, not the vendor choice, is now the bigger lever on a Hetzner bill.

CX and CAX absorbed the smallest increase because Hetzner's own product tiering places them as the commodity/entry tier competing on price against every other cheap-VPS vendor; CPX and CCX are the tiers Hetzner sells against AWS/GCP compute-optimized instances, where the company apparently decided it had more room to reprice. Whatever the reasoning, the practical rule for 2026 is: if a self-hosted node pool defaults to CPX or CCX, price it against CX/CAX before renewing anything.

Against Render and Railway​

Render's paid tier starts at $7/month per service — one price for web, the same $7 for a background worker, and Postgres starting at $7/month (Starter) with storage billed at $0.30/GB/month past the included allowance. The same three-service topology (web + worker + Postgres) lands at $21/month on Render's cheapest paid tier — competitive with, not more expensive than, the post-hike CX/CAX total, though Render's $7 Postgres tier is thin on storage and connection limits compared to a self-managed instance with a full 40–80 GB disk.

Railway prices usage, not instance size, at roughly $20 per vCPU-month and $10 per GB-RAM-month on top of a $5/month Hobby plan, plus $0.15/GB-month for volumes and $0.05/GB for egress. Run the same topology's actual resource draw (2+2+4 vCPU, 4+4+8 GB RAM) through that rate card and the compute alone prices out north of $150/month before volumes or egress — which is why independent write-ups of "what a typical full-stack app costs on Railway" converge on $35–100+/month once more than a toy workload is running, not the $5 Hobby-plan number the pricing page leads with.

The honest reading: post-hike Hetzner CX/CAX and Render's Starter tier are now close enough in raw dollars that "self-hosting is obviously cheaper" stops being true at this scale — the case for owning the boxes shifts from "it's cheaper" to "it doesn't get 2-3x more expensive again the next time a DRAM cycle hits a vendor's margin," and to not paying Render's or Railway's per-request/per-GB metering once traffic actually grows, which is where Railway's usage model diverges hardest from a flat monthly VM cost.

The ARM Trade-Off Nobody's Cost Model Mentions​

The CAX line's ~30% increase (versus CPX's ~170%) makes Ampere Altra ARM instances the cheapest compute Hetzner sells by a wide and growing margin — which only helps if the workload actually runs on arm64. Most modern Docker base images (node, python, postgres, nginx) publish multi-arch manifests and Just Work. What doesn't:

• Native npm/pip packages with prebuilt x86 binaries and no arm64 wheel/prebuild — anything wrapping a C extension without a maintained ARM build (some older image-processing, ML-inference, or crypto libraries) fails at npm install or import time, not at deploy time, which is the worse place to find out.
• Third-party base images from smaller vendors that only publish linux/amd64 — check with docker manifest inspect <image> | grep architecture before committing a node pool to ARM.
• Self-built binaries and any FFI to a vendored .so/.dll compiled for x86 — these need a cross-compile or an arm64 build stage, not just a base-image swap.

For a self-hosted PaaS's default node pool, the pragmatic split is: CAX for stateless web/worker services (where a bad ARM build fails loudly and immediately in CI), CX for anything running third-party binaries you don't control, and a quick docker manifest inspect check in the build pipeline before a tenant's app ever reaches a scheduling decision — catching an arch mismatch at build time costs a failed CI run; catching it after a node pool migration costs a production incident.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, provisioned through Cluster API onto whichever Hetzner instance family (CX, CAX, or otherwise) actually fits the workload, not whichever one a guide happened to recommend before the last price adjustment. Star the repo on GitHub or deploy your first app today.