Dora NodaA Hacker News thread titled "Kubernetes is up to 80% cheaper compared to PaaS like Heroku" racked up hundreds of comments in 2026 — and the top reply wasn't a spreadsheet, it was a war story: "I cut my bill from $270 to $45 by moving to Kubernetes on DigitalOcean." That's an 83% saving. Another commenter reported 75%. The thread's premise felt settled before anyone opened a pricing calculator.
Then the counter-thread arrived: engineers pricing the same move who discovered their "cheap Kubernetes" now needed an on-call rotation, weekly upgrades, and a persistent 30 to 50 percent utilization rate. One team documented 15 hours a week — 1.1 full-time engineers — just keeping the cluster alive. At $150,000 a year per engineer, that's a $13,750 monthly tax that never appeared on the Hetzner invoice.
So which number is real? We re-ran the 80% claim against August 2026 pricing — Railway, Render, Fly.io, and Hetzner after two repricings — for three workloads you actually run. The raw compute saving is real. The ops-adjusted saving is a different story, and the line between them is where most teams should be making the decision.
Short answer: Kubernetes on cheap VMs still beats PaaS on raw compute by 50 to 83% depending on workload size, even after Hetzner's 2026 hikes. Once you price a realistic ops burden, a solo dev and a small team are often cheaper on PaaS; a 10-service fleet with a dedicated platform person is where self-hosted Kubernetes earns its keep.
That table first, then the receipts.
TL;DR — The Three-Workload Verdict
| Workload | What it is | PaaS bill (2026) | Hetzner K8s bill (2026) | Raw saving | With ops tax |
|---|---|---|---|---|---|
| A. Side project — 1 service, 0.5 vCPU / 1 GB, always-on | Railway Hobby $15/mo · Render Starter $7/mo | CX22 (2 vCPU, 4 GB) €5.49/mo (~$6) | 50–60% cheaper on Render price | PaaS wins once you add even 2 hrs/mo of ops ($250 at $150k salary) | |
| B. Standard SaaS — 3 services (API + worker + Postgres), 2 vCPU / 4 GB total | Railway ~$60/mo · Render 3× Standard ~$75/mo + $7 DB | CX32 (4 vCPU, 8 GB) | ~78–83% cheaper on compute | Break-even to +40% cheaper with 0.2 FTE ops ($2,500/mo) | |
| C. Growing fleet — 10 services, 8 vCPU / 16 GB, multi-env | Railway ~$200–240/mo · Render 10×Standard ~$250/mo | 2× CPX31/CX32 fleet | ~80–87% cheaper on compute | ~45–60% cheaper with 0.5 FTE ops ($6,250/mo) |
Numbers use public 2026 list pricing (Railway $10/GB RAM and $20/vCPU per month, metered per-second on top of a $5 Hobby credit; Render $7 Starter at 0.5 CPU/512 MB and $25 Standard at 1 CPU/2 GB; Hetzner Cloud EU prices post–June 15, 2026). Ops tax converted at $150,000 fully-loaded per engineer per year. Your salary, utilization, and how much you enjoy being paged will move the break-even point — which is exactly the point.
What the HN Thread Actually Claims
HN #37379078 asks a fair question: "Kubernetes is up to 80% cheaper compared to PaaS like Heroku — what do the authors even mean?" The thread collects two kinds of answers.
The war stories. The most-upvoted shape is a before/after migration invoice. The canonical example predates the thread but gets recited inside it: a Heroku bill of roughly $270 a month replaced by a DigitalOcean Kubernetes bill of $45 — an 83% drop. The mechanism is always the same: bin-packing. Heroku charges per dyno whether the dyno is busy or idle; Kubernetes lets you pack an API, a worker, and a small Postgres onto the same droplet. One team's $270 Heroku layout was three Standard dynos plus add-ons that became three pods on one $20 droplet with headroom.
The skeptics. The second shape is the engineer who tried to replicate the trick and found the second invoice. Typical objections in the thread: managed Kubernetes itself isn't free (EKS/GKE control-plane fees, load balancers, persistent volumes), upgrades evict pods at awkward hours, monitoring and logging need separate tooling, and the cluster runs at 30 to 50 percent utilization because you must hold headroom for rolling deploys and spikes. One commenter summarized it as "you pivoted from building your product to building a PaaS."
Both sides are right. The thread is arguing about two different bills — the infrastructure line and the engineering-hours line — as if they were one number. Separating them is the only way to audit the 80% claim honestly.
The 2026 PaaS Meter, Line by Line
If your last mental model of PaaS pricing is "Heroku dynos," 2026 has moved on. Every vendor now meters differently, and the shape of the meter matters more than the headline price.
| Platform | Pricing shape (Aug 2026) | What a 1 vCPU / 2 GB always-on service costs | Gotchas |
|---|---|---|---|
| Railway | $5/mo Hobby credit (counts toward usage) + $10/GB RAM/mo + $20/vCPU/mo + $0.10/GB egress + $0.15/GB disk, billed per minute | ~$40/mo (20 + 20 + ~0 base after credit) if fully used 24/7; ~$15/mo for 0.5 vCPU/512 MB | Credit burns fast; two near-identical GB figures (RAM vs disk) differ 67× in cost; no free tier for anything that stays running |
| Render | Flat per-service tiers: Starter $7/mo (0.5 CPU, 512 MB), Standard $25/mo (1 CPU, 2 GB), Pro $85–$450/mo | $25/mo flat (Standard) | Predictable but you pay per instance provisioned — idle services cost the same as busy ones; Postgres storage billed separately at $0.30/GB |
| Fly.io | Per-second Machine billing while started (shared-cpu-1x/256 MB ~$2.02/mo if left on) + NAT gateway + metrics + egress per GB | ~$8–15/mo for a small always-on service before NAT/metrics | Cheapest headline, most line items; inter-region private networking and volume snapshots became separately metered in early 2026 |
| Heroku (reference) | Eco/Basic dynos $5–7/mo (sleep), Standard $25–50/mo per dyno | $25–50/mo per dyno | Still the "80% cheaper than Heroku" baseline everyone quotes — useful as a ceiling, not a current decision |
Railway's own comparison page makes the trade-off explicit: a 0.5 vCPU / 512 MB always-on service is $7 on Render but $15 fully used on Railway; a 1 vCPU / 2 GB service is $25 on Render but $40 on Railway. Railway wins when aggregate usage is low or bursty (you pay per second actually consumed). Render wins when a service is always-on and fully packed — which, for a SaaS API that never sleeps, is exactly the common case.
Railway's Hobby $5 credit is widely misunderstood. It is not five dollars off forever — it is five dollars of usage included each month, after which you pay the $10/GB and $20/vCPU meter. A single small API plus a background worker crosses the credit in the first week. The invoice math is per-minute, and the disk-vs-RAM pricing gap means two services with similar GB numbers can differ 130× in cost contribution from the same resource line.
The Hetzner Side After Two Hikes — Why 2026 Numbers Matter
Every "self-host on a €4 Hetzner box" argument you have bookmarked was priced before April 2026. Hetzner repriced cloud servers twice this year, and the second hike was not a tweak.
| Line | What it is | Pre-2026 price (EU) | After April 1 (+30–37%) | After June 15 (cumulative) |
|---|---|---|---|---|
| CX22 (Intel shared, 2 vCPU / 4 GB) | The box every tutorial quotes | €4.15/mo | €5.49/mo | €5.49/mo (CX held here) |
| CPX21/CPX31 (AMD shared) | The "production small" AMD line | ~€7–15/mo | ~€8–20/mo | 2.4–2.75× original |
| CCX13/CCX23 (dedicated vCPU) | The line most prod fleets actually run | €16.49 / €39.99/mo | ~€22 / ~€54/mo | €42.99 / €102.99/mo (2.1–2.7× original) |
Sources for the delta: Hetzner's own April and June adjustment pages, plus third-party trackers that re-verified each SKU in July (see the byteiota and vps-gpu-price-index breakdowns that flagged CX22 at €5.49 as the new entry tier — any post still quoting €3.79 or €4.35 is stale).
Two consequences for the Kubernetes math:
1. The cheapest valid comparison is CX/CAX, not CCX/CPX. If you read "Hetzner went up about 30%" and thought your dedicated CCX fleet did, you underpriced by more than 2×. For cost comparisons, quote the CX/CAX line at +30–38% or the CCX/CPX line at +140–173% — not a blended "about 30%."
2. Bin-packing still saves, but the box you pack matters. The classic trick — three Heroku/Render services onto one Hetzner VM — still works on CX/CAX. A CX32 (4 vCPU, 8 GB) at roughly €11–13/mo holding an API, a worker, and a small Postgres is three Render Standard services ($75) on one box that costs one-sixth as much on compute alone. On CCX after the hikes, the same consolidation saves less per core and you should benchmark whether CX with headroom is sufficient before defaulting to dedicated.
Even after the hikes, Hetzner's included bandwidth (20 TB on CX22) versus hyperscaler egress at $0.09/GB remains the quiet multiplier. A mid-traffic SaaS pushing 500 GB/mo pays ~$45 in egress on AWS/GCP/Azure pricing — more than the entire Hetzner box — before any compute is billed.
The Ops Tax the 80% Leaves Out
This is the section the original 80% claim never prices, and the one that decides whether a team should actually move.
Four line items, all in engineering time rather than invoices:
1. Ongoing maintenance has a headcount cost. The CNCF's 2026 survey pegged average Kubernetes-specific engineering time at roughly $180,000 per year — covering cluster upgrades, security patching, monitoring configuration, and incident response. Independent operator reports are consistent at the team level: one three-engineer team documented 15 hours a week — every week, for two years — on cluster maintenance alone, or about 1.1 full-time engineers. At a $150,000 fully-loaded salary, that's $13,750 a month in time that never appears on a cloud invoice but is very much a bill.
2. Upgrades and evictions are operational risk, not just chores. Kubernetes node upgrades evict pods. If you haven't invested in PodDisruptionBudgets, graceful termination, and node-drain runbooks, that eviction is a customer-visible blip during business hours. Managed Kubernetes reduces this but doesn't eliminate it — someone still owns the rollout window and the rollback plan.
3. Utilization is structurally low. Research and operator data consistently put average Kubernetes cluster utilization at 30 to 50 percent. You overprovision by design: headroom for rolling deploys, headroom for spikes, and resource requests that exceed actual usage because "the workload runs smoothly at 40% of requests and there is no signal to revisit." Low utilization is not a bug — it's the price of reliability — but it means your $6 CX22 is often a $12-per-usable-core CX22.
4. Observability and incident response scale with the cluster, not the app. Heroku/Render/Railway ship logs, metrics, and alerting as part of the platform. On self-managed Kubernetes you assemble and operate Prometheus, Grafana, Loki, and an incident rotation — or you pay a vendor for each. The cost is either salary or SaaS spend; neither is zero.
Convert this to a monthly number your finance team can compare:
| Ops burden | Weekly hours | FTE at 40 hrs | Cost at $150k/yr | Cost at $180k/yr |
|---|---|---|---|---|
| Solo dev, light touch (managed K8s, one cluster) | ~2 hrs | 0.05 | ~$625/mo | ~$750/mo |
| Small team, one prod cluster | ~8 hrs | 0.20 | ~$2,500/mo | ~$3,000/mo |
| Growing fleet, on-call + upgrades | ~20 hrs | 0.50 | ~$6,250/mo | ~$7,500/mo |
| Full platform team (what the 15 hrs/week anecdote reports × 3 engineers ÷ team) | ~45 hrs | 1.10 | ~$13,750/mo | ~$16,500/mo |
Compare those rows to the raw compute savings in the verdict table above. That's the whole decision.
When 80% Is Real — and When It's Fantasy
Map your team onto this matrix and price the ops row that matches your reality, not the one in the blog post that taught you Kubernetes was cheap.
| Team | Workload shape | Verdict |
|---|---|---|
| Solo dev / 1–2 engineers, side project or single service | 0.5–1 vCPU, always-on, low traffic | PaaS. Raw compute saving of $5–30/mo is smaller than even 2 hours of monthly ops. Render Starter at $7 or Fly at ~$8 with no on-call is the cheaper total cost. |
| Small team 2–5, standard SaaS (API + worker + DB) | 2–4 vCPU, mostly steady traffic | Toss-up, sensitive to ops maturity. Self-hosted saves 70–80% on compute (~$60 vs ~$13). If you can keep ops to 0.1–0.2 FTE (managed K8s, opinionated tooling), you still come out ahead. If ops drifts to 0.5 FTE, PaaS is cheaper. |
| 5–15 engineers, 5–15 services, multi-env | 6–16 vCPU, bin-packable, preview envs | Kubernetes usually wins on total cost. Compute saving of $150–250/mo per environment outweighs a 0.3–0.5 FTE platform investment, especially with preview environments that would be per-service charges on PaaS. |
| Any team, bursty / spiky workloads | High variance, low average utilization | Depends on PaaS meter shape. Railway per-second billing can beat a fixed Hetzner box that idles at 20% — the PaaS you pay per second actually used is cheaper than the VM you pay for 24/7. Always-on SaaS APIs are the opposite: flat box wins. |
| Any team, no one wants to be on call | — | PaaS, regardless of compute math. If the org has no one who will own upgrades and incidents, the ops tax is not a line item — it's an unbounded risk. Budget as you would for any single point of failure. |
Three rules of thumb that survive the full audit:
-
Never compare headline compute without an ops row. A table that shows "$270 vs $45" and stops is marketing, not a total cost of ownership.
-
Reprice Hetzner at June 2026 levels before quoting "cheap VMs." CX is still cheap. CCX/CPX is not what it was. Your comparison is only honest if the Hetzner side uses post-hike numbers.
-
The break-even is a people question, not a cores question. The cheapest infrastructure that no one will operate is the most expensive infrastructure you own.
The Third Path: PaaS Ergonomics on Your Own Machines
The HN thread frames the choice as binary: pay Heroku's margin or operate Kubernetes yourself. That binary is why the 80% number keeps cycling as a gotcha.
The boring synthesis is that the two were never really in tension. A git-push PaaS built on Kubernetes under the hood — Cluster API provisioning Hetzner machines you own, with a Render-compatible deploy surface on top — gives you the per-service bill you can audit without inheriting the single-box ceiling the moment you need a second machine. You still pay the compute (now at CX/CAX prices you can actually predict) and you still pay an ops budget — but the ops budget is for one platform, not a bespoke cluster per team.
That's the bet behind Bex.co — the open-source, AI-native Render alternative where git push gets you a running HTTPS service on machines you own, with an API your agents can drive the same way your developers do. If the economics above pushed you toward self-hosting but the ops table gave you pause, a platform that turns the 15-hours-a-week cluster into someone else's product is the line item that moves.
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.
Sources and Further Reading
- HN discussion #37379078 — "Kubernetes is up to 80% cheaper compared to PaaS like Heroku" (thread with $270→$45 and 75% anecdotes)
- Railway pricing docs — Hobby $5/mo credit, $10/GB RAM and $20/vCPU per month metered per second, plus $0.10/GB egress
- Render vs Railway pricing comparison — 0.5 vCPU/512 MB at $7 vs $15, 1 vCPU/2 GB at $25 vs $40
- Render pricing — Starter $7/mo (0.5 CPU, 512 MB), Standard $25/mo (1 CPU, 2 GB)
- Hetzner press room — April 1, 2026 cloud price increase (30–37% in DE/FI, 38–40% in US) and June 15, 2026 repricing (CCX/CPX 2.1–2.75× in DE/FI, up to 3.1× in US)
- byteiota — "Hetzner June 2026 Price Shock: CCX and CPX Are Different Now" — CCX23 $39.99→$102.99
- vps-gpu-price-index — post–June 15 verification: CX22 at €5.49, CPX22 +144%, CPX32 +154%, CCX13 +169%, CCX23 +173%
- CNCF 2026 survey via Tech Insider — ~$180,000/yr average Kubernetes-specific engineering time
- "Kubernetes Ate 15 Hours of My Week. Every Week. For 2 Years" — 1.1 FTE maintenance burden on a 3-engineer team
- Cyber Sierra — 30–50% average Kubernetes cluster utilization and knowledge-debt framing.