Hetzner's April Price Hike, Three Months Later: Why a 37% Raise Still Leaves Your 3-Node Fleet Cheaper Than Render and Railway

Three months after Hetzner raised cloud server prices by up to 37%, the invoice tells a different story than the headline did.

On April 1, 2026, Europe's cheapest cloud vendor announced a 30–37% increase across its cloud fleet in EU regions and 38–40% in the US, citing a DRAM and NAND shortage that had pushed memory prices up 90% in a single quarter. The smallest box on the menu — the CX22 with 2 vCPU and 4 GB RAM — went from roughly €3.29 to €4.35 a month. Even after the hike, that number still looks quaint next to a managed PaaS: Render's Starter tier charges $7 per service for half a vCPU and 512 MB, and Railway's Hobby plan starts at $5 a month before metering every vCPU at $20 and every gigabyte of RAM at $10.

But the quaint number isn't the whole bill, and the comparison at sticker-price parity isn't the honest one. A 3-node CX22 fleet gives you 6 vCPU and 12 GB RAM with 60 TB of included bandwidth. Three Render Starters give you 1.5 vCPU and 1.5 GB for the same $21 cost — an 8× resource gap hiding behind a similar monthly total. Price the same 6 vCPU and 12 GB honestly and Render needs its Standard tier while Railway's meter lands near $80 before egress. Below is both views, side by side — then a bandwidth sensitivity table that explains why the self-hosting margin narrowed on compute but still clears once bytes start moving.

The answer up front — priced two ways:

In the entry-tier view, Hetzner is cheaper but the comparison is lopsided — you get four times the RAM per dollar. In the resource-parity view, the margin reappears clearly. Neither view alone tells the truth; the gap between them is the finding.

What the April Hike Actually Changed — and What It Didn't​

Hetzner's own price-adjustment notice, mirrored in community announcements that week, laid the increase out by region:

The cause Hetzner named was blunt: AI demand had consumed fab capacity, pushing DRAM contract prices up roughly 90–98% quarter over quarter in Q1 2026 and NAND flash up more than 30%. Each high-bandwidth-memory module consumes about three times the fab area of a standard DDR5 chip, so as hyperscalers redirected wafer starts toward HBM, commodity memory — the stuff inside every CX22 — became scarcer and more expensive in the same quarter.

Three facts that matter more than the percentage:

The cheapest box stayed the cheapest. The CX22 (2 vCPU, 4 GB RAM, 40 GB NVMe, 20 TB included traffic) moved to €4.35/month post-hike in EU regions. Hetzner publishes excluding VAT; US pricing tracks separately in dollars. The next step up, the CX32/CAX21 class, cleared €8–€10; dedicated and performance tiers (CCX, CPX) started higher still before June repriced them again out of this story's range.

The April hike was not the June hike. A second adjustment on June 15 doubled or tripled CCX and CPX dedicated-performance lines while CX and CAX moved only ~30% again. If you read a "Hetzner doubled prices" headline in July, that was June's story, not April's. This post isolates the April hike — the one that changed the default self-hosting baseline every cost comparison since has had to quote.

Share-sharing softened the blow. The CX and CAX lines run on shared physical cores: one host core divided across tenants absorbs a per-gigabyte memory shock better than a dedicated vCPU where the whole DIMM is yours. Hetzner's own notice shows the spread clearly — shared tiers rose ~30%, dedicated tiers absorbed more. The platform that keeps tenants on shared vCPUs for bursty, multi-tenant web workloads was structurally less exposed to the April shock than the one that dedicates cores.

A footnote on naming: in early 2026 Hetzner retired the CX22 identifier and began shipping its successor as CX23 with identical specs. Documentation and Cluster API provider configs may list either name for the same slot. Where this post says CX22, read CX22/CX23 — the price band is the point, not the suffix.

The Fleet: What a 3-Node CX22 CAPH Cluster Actually Costs​

A Cluster API with Hetzner (CAPH) fleet declaratively manages machines: you define a MachineDeployment of three nodes, point it at a server type and location, and the controller provisions, joins, and heals them. For many small-to-medium PaaS workloads, three CX22s is the minimal highly available topology — enough to survive one node loss with quorum intact, enough to bin-pack a handful of apps, a Postgres primary, and system overhead without per-service reservation.

Line by line, Germany/Finland pricing, post-April-hike:

In US regions, apply the slightly higher +38–40% band to the base, and note the bandwidth inclusion drops — Hetzner US and Singapore locations bundle roughly 1 TB per server rather than 20 TB, with overage still near $1.17/TB. For EU-hosted tenants — the default for European data-sovereignty posture — the 60 TB pool is the operative number: you would need to push more than 60 terabytes in a month to see a billed bandwidth line.

That last fact is not decoration. It is the entire second half of this article.

Same Workload, Hosted: Render and Railway Priced Like Invoices​

Render and Railway bill differently — one reserves fixed slots, the other meters consumption — so the same workload produces two differently-shaped invoices. Below is the honest math for both, quoted in the units you'll see on the invoice and converted to the units you budget in.

Render: $7 Starter, and what $7 actually reserves​

Render's cheapest paid compute is Starter: $7/month per service for 512 MB RAM and 0.5 vCPU, always-on. Workspace plans are separate:

*Render's 2026 repricing cut Hobby egress from 100 GB → 5 GB and Pro from 100 GB → 25 GB in some reports; the numbers above reflect the pricing-page display at writing and H2 guidance. Check your workspace invoice for the operative allowance.

Priced at entry-tier parity — three services, three Starters, the way a team migrating three lightweight apps would first try it:

That $21 matches the Hetzner fleet's $14 only if you ignore that it reserves 8× less RAM. To reserve the same 6 vCPU / 12 GB the fleet gives you, Render cannot stay on Starter — Starter caps at 0.5 GB per instance. You need Standard at $25/month (1 vCPU, 2 GB, always-on) or larger:

A single-service teams can live happily on three Starters at $21 if the apps are genuinely small. The moment the fleet's actual footprint is 12 GB — which a 3-node CAPH cluster implies for anything beyond three toy services — the hosted number to beat is not $21 but the Standard-tier range above. Quoting $21 against a 12 GB fleet is the comparison that produced last year's "self-hosting is only $7 cheaper" headlines; reprice at resource parity and the gap is $60 or more on compute alone.

Railway: $5 Hobby plus $20/vCPU and $10/GB, metered per second​

Railway bills consumption, not reservation: every second a container runs, it accrues. The rate card, quoted the way docs display it and converted to budgeting units:

Hobby is $5/month including $5 of usage as credit; Pro is $20/seat including $20. The consumption rates are the same; the credit is the only difference at Hobby scale.

Run a single always-on API shaped like half the CAPH fleet (3 vCPU / 6 GB, enough for web + worker + a small Postgres):

Scale that down to the minimal always-on shape many hobby projects actually run — 1 vCPU / 1 GB — and the raw compute is $30/month, $25 after credit, before egress or Postgres. That is why independent 2026 write-ups of Railway pricing converge on "$10–$15/month for a toy hobby app, $35–$100+/month once you add a second service and a real database" rather than the $5 plan price. A client-side decodes: the Hobby plan's headline number is a base fee with credit, not a cap.

For resource parity with the full 6 vCPU / 12 GB fleet, double the first table:

Not every workload needs full parity — a hosted platform bin-packs containers efficiently and sleeps idle services. But the Hetzner fleet's resources are reserved and included at $14; Railway bills the consumed slice at $20/$10 per unit and never sleeps a database. Comparing Railway's $5 plan price to the fleet's $14 total without metering the actual consumption is the category error that makes hosted PaaS look cheaper than it invoices.

Where the Margin Actually Lives: Egress​

Compute margins narrowed after April. A 3-node CX22 fleet that cost roughly $10–$11 before April now costs ~$14 — closing about $3 of gap against Render's $21 entry-tier total, and tightening the headline further under the later June repricing this post sets aside. If the workload is compute-bound and bandwidth-light, the hosted premium for not operating your own fleet can look defensible.

Once the workload moves bytes, the bill flips. Hetzner EU bundles 20 TB per server; Render and Railway meter egress by the gigabyte. Below is a sensitivity table holding compute constant at the 3-node / 3-service baseline and varying only monthly egress — the shape of an app that serves images, exports, API responses, or user downloads to the public internet:

*If Hobby is 5 GB (April 23, 2026 cut), add ~$28 at 100 GB and ~$443 at 1 TB to Render's column. Your workspace tier and overage rate ($0.30 vs $0.15) determine the line.

Total invoice at 1 TB egress, 3-service baseline:

The compute delta after April — a few dollars — is real but small. The egress delta at even modest bandwidth — hundreds of dollars — dwarfs it. Hetzner's per-terabyte overage, once the 60 TB pool exhausts, is about $1.17/TB — roughly 250× cheaper per gigabyte than Render's $0.30/GB and 40× cheaper than Railway's $0.05/GB. That is not a discount; it is a different accounting model — bulk-included capacity you provisioned with the machine versus per-request metering you pay in perpetuity.

Not every app moves a terabyte. A purely internal tool serving 10 GB a month never sees this table matter. But for the class of apps that do — public-facing APIs, image-heavy frontends, data exports — bandwidth is where "self-hosting is cheaper" stops being a compute-price argument and starts being true in the way that compounds every month the platform's own pricing page never graphs for you.

Why the two views reconcile. Entry-tier hosting looks competitive because the cheapest hosted instance and the cheapest Hetzner box happen to cost a similar amount of dollars before you match resources — $7 versus $4.35 is close only while 0.5 GB per service is enough. The moment the workload outgrows "half a gigabyte" — a Postgres instance with a warm buffer cache, a Next.js app with edge middleware, parallel preview deploys — the hosted platform either needs larger (pricier) instances or more of them, while the fleet's three boxes keep absorbing containers at zero marginal compute cost. The egress table then layers a second multiplier on top. Together, they are why a blog post that prices a toy workload and a blog post that prices a busy one reach opposite conclusions from the same rate cards.

So When Does the Hosted Premium Still Make Sense?​

Owning the fleet is not free — the €13.05 above is only the hardware line. Honesty requires three caveats:

Operations time is real. A Cluster API-managed fleet automates node provisioning, health checks, and certificate rotation, compressing what might otherwise be 5–10 hours a month of hand-rolled server work to the 1–2 hour range for a stable deployment. At a $25/hour hobbyist opportunity cost, that's roughly $25–$50 a month of implied time before the hardware bill. At a professional's $75/hour blended rate and heavier production scaffolding, it can be an order of magnitude more. Railway's $10–$15 solo-project quote wins outright at small scale the moment your own hour has any value — no box-price argument changes that until traffic or service count grows.

Managed databases change the math. Hetzner does not run your Postgres for you; backup verification, failover testing, and extension maintenance are your job on an owned fleet. Render's $7 Postgres and Railway's volume-backed Postgres are managed services, and for some teams that single distinction outweighs the egress tables above. Owned hardware skips the markup; it also skips the pager somebody else would have carried.

Regional pricing matters. The 20 TB inclusion is an EU-region figure. In Hetzner US locations the included egress is closer to 1 TB per server — still generous compared to hosted metering, but not the 60 TB pool that makes the European table read like a trick. Size the pool against the region your tenants actually run in, not the more flattering one.

With those caveats priced in, the decision rule is straightforward:

• Bandwidth-light, few services, no ops appetite (<100 GB egress, 1–3 services): Hosted PaaS is competitive — Render's Starter tier at $21 and Railway's $25 hobby shape invoice cleanly, and the operational overhead of owning the box exceeds the compute savings. The April hike did not change this.
• Bandwidth-moderate or growing (>100 GB egress, or service count rising past Starter sizes): The self-hosted fleet's bundled bandwidth compounds the advantage Hetzner's commodity CX line kept through the hike. The margin narrowed on compute and persisted on bytes — and bytes only grow with success.
• Scaling past resource parity (6+ vCPU / 12+ GB reserved): The hosted invoice scales linearly with each service while the fleet adds containers at flat cost. The breakeven moves further from the hosted tier with every new workload you schedule onto already-paid-for capacity.

Three months of invoicing after April 1 makes one thing clear that the announcement-week coverage couldn't: Hetzner's increase was structurally regressive — it landed hardest on expensive dedicated lines and lightest on the shared vCPU tier that powers small-fleet self-hosting — so the cheapest way to run a 3-node PaaS on Hetzner is still the same cheap path it was in March. What changed is that the cost of not owning that path — the egress arithmetic managed platforms meter by the gigabyte — is now the decisive variable, not a footnote.

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 fits the workload. The April hike didn't make Hetzner expensive; it made counting bytes the question that decides your next invoice. Star the repo on GitHub or deploy your first app today.