Sevalla Charges $160 for 4 vCPU/8 GB on GKE: What the Same Box Costs on Render, Fly.io, Railway — and Flat-Rate Hetzner

Sevalla will rent you 4 vCPU and 8 GB of RAM for $160 a month. Hetzner will rent you the same 4 vCPU and 8 GB for about one-tenth of that — and throw in 20 TB of bandwidth.

Both prices are real, both are for the same nominal compute, and neither is lying. Back4App's February 2026 guide, still the most-cited Heroku-alternatives roundup this year, puts them on the same page for a reason: Sevalla's Standard S4 at $160/mo (4 vCPU/8 GB, CPU-optimized C1 at $18/mo at the small end) sits two slots below Heroku's $250/mo Performance M and two slots above Render's $7/mo Starter in its comparison table, with Fly.io's per-second Machines and Railway's trial-credit model filling the gaps in between. The guide's ranking is deliberately apples-to-oranges — that is the point. The PaaS market in 2026 does not converge on one number for the same workload. It produces three different kinds of invoices for the same workload, none of which behave the way owned hardware does.

This post re-prices that workload on one page: the table first, then why the three hosted pricing models cannot converge even when they try, where bandwidth turns a close race into a blowout, and what "one predictable number" on a Hetzner box under Cluster API actually collapses to — including the two 2026 Hetzner repricings everyone quoting a pre-hike price quietly ignores.

1. The bill in one table — the same 4 vCPU/8 GB, five invoices​

We fix the workload so the money has to move, not the workload. One service sized at 4 vCPU / 8 GB RAM / 160 GB disk, always-on (730 hours, no sleep, no scale-to-zero credit), one team, VAT excluded, NA/EU region unless labeled. Egress shown at 200 GB/month — the first volume that forces every platform to bill a bandwidth dimension. Postgres/storage counted where bundled; otherwise cheapest managed equivalent added. Prices from Sevalla docs (S4 $160/mo), Render docs (Starter $7, Standard $25, Pro Plus $175 for 4 vCPU/8 GB), Fly.io docs (shared-cpu and performance Machines per-second, volumes $0.15/GB-mo, egress $0.02 NA/EU / $0.12 Africa/India, egress IPs $3.60/mo since Jan 2026), Railway docs ($20/vCPU-mo and $10/GB RAM-mo equivalent, $0.05/GB egress, Hobby $5 / Pro $20 plan floor), and Hetzner Cloud (CPX/CX/CCX families, 20 TB included traffic per large instance).

Sensitivity that matters: at 0 GB egress, Render Hobby at one small service ($7) and Fly.io at small Machines win the sticker contest and Hetzner's bandwidth advantage is invisible. At 1 TB egress, Railway adds $50, Fly.io NA/EU adds $20 (Africa/India $120), Render adds $0–$150 depending on whether you cleared the included band, and Hetzner still adds $0 — the ranking flips to bandwidth, not compute. At three services, Render's per-service multiplication (3× $25 Standard = $75 before workspace fees) overtakes Railway's per-second sum for the same total vCPU.

The headline is not that Hetzner is cheapest. It is that one side of the table has one line and the other side has four to six lines that each move independently — and only one side lets a vendor add a new line next quarter.

2. Back4App's February 2026 frame — and what it left for you to recompute​

Back4App's "Best Heroku Alternatives in 2026" (updated February 2026) is the cleanest snapshot of where the PaaS market landed after Heroku went into sustaining mode. It ranks ten options — Back4App itself, Sevalla (Kinsta's application-hosting brand, built on GKE), Render, Fly.io, DigitalOcean App Platform, Railway, Vercel, Upsun, Coolify, and AWS Elastic Beanstalk — with pricing, free-tier, and migration notes on one page. Two editorial choices make it useful and also incomplete in exactly the way a cost comparison needs to correct:

It prices the tier, not the workload. Sevalla Standard S4 is listed as $160/mo for 4 vCPU/8 GB (the GetDeploying comparison mirrors the same S4 at $160 and C1 at $18). Render Starter is $7/mo for 0.5 vCPU/512 MB, Scale tiers track differently. Fly.io and Railway are usage-metered, so the guide can only quote rates, not a total. The table is honest about the pricing model but cannot show the monthly total for the same workload without fixing hours, egress, and region — which is why two readers leave the page with opposite conclusions about which PaaS is cheapest.

It inherits the GKE line without pricing it. Kinsta's own Sevalla/GKE case study and pricing page describe the product as "production infrastructure without hyperscaler complexity" — pay for what you run, no per-seat pricing, no Kubernetes overhead — while running on Google Kubernetes Engine underneath. That positioning is why Sevalla can offer a flat $160 without a seat meter and also why that flat price is GKE rent plus Kinsta's margin plus operations. Google's GKE Autopilot pricing in 2026 runs roughly $0.0356/vCPU-hour and $0.0039/GB-hour (TrustRadius/GCP price sheets), which for 4 vCPU/8 GB always-on is already on the order of $100–$125 before any PaaS markup — Sevalla's $160 is not arbitrary, it is that arithmetic plus a control plane you do not operate.

Back4App's guide does its job as a directory. The recompute it invites — and this post does — is to hold the workload constant and let the invoice shape be the variable.

3. Three pricing models that cannot converge on one number​

The same 4 vCPU/8 GB looks like three different products because it is three different products once billing starts.

GKE-rented: Sevalla (and any PaaS that resells a hyperscaler)​

You pay for the VM the PaaS rented from Google, plus the PaaS's own margin and operations. The meter is underneath you (GCP bills Kinsta/Sevalla) and invisible to you — which is the feature. There is no seat to count, no per-second math to do, no egress surprise on Sevalla's invoice because the bandwidth rides inside the flat rent. The cost is predictability itself: one number, every month, whether your app did 20 GB or 200 GB. The price of that predictability is that the floor cannot undercut the hyperscaler it sits on. Sevalla's $160 cannot beat Hetzner's $18–$40 on compute alone because Google's own per-hour price is already multiples of Hetzner's flat rent — before either platform adds human operations.

When this wins: teams that need GKE's regional footprint, compliance posture, or autoscaling without operating GKE themselves, and that value a single recurring line over the absolute floor.

Fixed-tier: Render​

You pay for the allocation, not the second. Starter $7 (0.5 vCPU/512 MB), Standard $25 (1 vCPU/2 GB), Pro Plus $175 (4 vCPU/8 GB) — plus a workspace subscription (Hobby $0, Pro $25/mo, Scale $499/mo since April 2026) and disk at $0.25/GB-mo now billed separately from compute. The meter is coarser but simpler: pick the bundle, pay for the month, no per-second arithmetic. The trap is granularity. A 4 vCPU/8 GB workload fits Pro Plus exactly ($175) but assembling it from Standards wastes either vCPU or RAM — two Standards give 2 vCPU/4 GB for $50, four give 4 vCPU/8 GB for $100 but as four services with four health checks, logs, and deploys. And three services at Standard is already $75 before the workspace fee, which overtakes a metered bill for the same total resources.

When this wins: small, stable service counts where the bundle fits and the workspace stays on Hobby $0. One API and one worker at Starter/Standard is Render's sweet spot — which is also why quoting Starter $7 against Sevalla $160 is a category error, not a savings claim.

Per-second-metered: Fly.io and Railway​

You pay for the second. Railway bills $0.000463/vCPU-minute ($0.028/vCPU-hour) and $0.000231/GB-minute ($0.014/GB-hour), plus $0.05/GB egress (current docs; vintage plans $0.10), plus a $5/mo Hobby or $20/seat Pro floor. Fly.io bills shared-cpu-1x from ~$0.000021/vCPU-second, volumes at $0.15/GB-mo, egress at $0.02/GB NA/EU, $0.04 APAC/SA, $0.12 Africa/India, plus a per-app egress IP since January 2026. The meter is precise and honest — you pay for exactly the seconds you consumed, nothing for idle — which is also why an always-on 4 vCPU/8 GB workload cannot be cheap on this model. Four vCPU and eight gigabytes running 730 hours is not bursty; it is the shape a flat rent is priced to beat. The metered model shines when workloads do sleep — preview environments, cron workers, and scale-to-zero APIs — not when they never do.

When this wins: bursty, low-average-utilization workloads and teams that genuinely autoscale to near-zero. For an always-on API plus worker, the meter is a tax on uptime.

Three models, three invoices, none converging — because they are not pricing the same thing. One prices hyperscaler rent, one prices an allocation bundle, one prices uptime by the second.

4. Bandwidth is the wedge that decides the real ranking​

At 200 GB egress, bandwidth is already the largest single line on two of the five hosted invoices and the dimension with the widest spread in 2026.

• Hetzner: 20 TB included per large instance (CX/CCX/CPX) in EU/US, 1–2 TB on the smallest CX. Overages, when they happen, run about €1/TB. Your 200 GB is ~1% of the allowance. Moving the same 200 GB to Africa versus Europe does not change the price.
• Fly.io: $0.02/GB in North America/Europe, $0.04 in Asia-Pacific/South America, $0.12 in Africa/India. Same byte, 6× price by region. Two new 2026 billing lines — inter-region private networking at Machine rates and volume snapshots metering separately since January/February 2026 — sit on top.
• Railway: $0.05/GB on current docs (some comparisons still quote the older $0.10/GB line). No regional premium, but no free band either — every gigabyte meters.
• Render: 100 GB included on Hobby, ~1 TB on Pro, then $0.15/GB. Below the included band the marginal byte is free; above it, it is the steepest per-GB rate in the table.
• Vercel (for scale): 1 TB included on Pro, then $0.15/GB — which is why 200 GB comparisons flatter Vercel for web workloads.

The worked sensitivity makes the point concrete. With 200 GB, add $10 on Railway, $4 on Fly.io NA/EU ($24 in Africa/India), $0 on Render Hobby/Pro if still inside band, $0 on Hetzner, and ~$18 on a hyperscaler at $0.09/GB. With 1 TB, add $50 on Railway, $20 on Fly.io NA/EU ($120 in Africa/India), up to ~$135 on Render beyond its Pro included band, and still $0 on Hetzner — the same included 20 TB absorbs it. The spread between $0 on a bandwidth-included box and $120 on Fly.io Africa/India for the same terabyte is why a "compute-only" comparison understates the real invoice by the largest single line.

If your app serves images, exports, or any outbound-heavy API, bandwidth is not an asterisk. It is the bill.

5. What "one predictable number" actually collapses — and what it still costs​

The Hetzner line in the table is deliberately boring: one rent, every month, same number. For a CPX32 (4 AMD shared vCPU, 8 GB RAM, 160 GB NVMe) or the newer CX33 class that replaced it, that rent in 2026 lands around €17–€35/mo ($18–$38) in EU/US; a CCX23 (4 dedicated vCPU, 16 GB RAM) for workloads that need pinned cores lands around €42–€60 ($46–$65). Those ranges, not a single frozen price, are the honest way to quote Hetzner in late 2026.

Hetzner repriced twice in 2026 on top of the DRAM supercycle every cost post this year has had to reckon with. A broad hike on April 1 lifted cloud, dedicated, and storage (Object Storage base €4.99 → €6.49, AX42 dedicated €47.30 → €57.30 in the documented examples, roughly +30–37% across families and regions) and a second, steeper adjustment on June 15 standardized SKUs into -1/-2/-3 tiers and jumped CCX/CPX families 2.1–2.75× and shared lines ~30% in some regions, attributed to a ~90–95% QoQ DRAM contract-price surge in Q1 and continued pressure into Q2 as AI/HBM demand consumed roughly 40% of world DRAM output. Existing instances kept their old price until a rescale or new order; new capacity pays the new price. Quoting a pre-April number in August without that note is how "self-host on a Hetzner box" stops being a comparison and becomes nostalgia.

Two things remain true after both hikes. First, even at post-June levels, the Hetzner flat rent plus its included bandwidth is still a fraction of any hosted invoice for the same always-on 4 vCPU/8 GB with real egress — the relative advantage survived even as the absolute number moved. Hacker News threads through mid-2026 kept landing on "even after +30–50%, Hetzner is the cheapest option" with the same caveat: cheap is not free, and predictable is not zero-ops.

Second, the predictable number is not the only number. Operating a Cluster API fleet has real, non-invoice costs: provisioning and lifecycle (Cluster API Provider Hetzner, CAPI/CAPH upgrades), networking (load balancers at ~$8/mo per LB, floating IPs), storage operations (volumes, snapshots, backups), and the human time to run control planes, upgrades, and on-call. A self-hosted PaaS like bex does not eliminate that work — it standardizes it. The financial argument is not "hardware is free" but that a fleet where the Hetzner bill is the only bill does not sprout a new metered dimension next quarter because a vendor decided to bill inter-region traffic or snapshots. The vendor whose whole stack you own cannot add a line item you did not approve.

That is what "collapses into one predictable number" actually claims — and where the claim earns its keep or does not. For an always-on 4 vCPU/8 GB service with even modest outbound traffic, the collapse is worth the ops. For a weekend prototype that sleeps, the metered pause is worth more than the flat rent.

6. When each model actually wins — a decision rule, not a ranking​

There is no universal cheapest. There is a cheapest for your shape.

• Pick Sevalla's GKE-backed flat ($160) if you want GCP's footprint and operations handled for you, with one recurring number and no seat or per-second math — and you accept that the flat sits above raw hardware because it is raw hardware plus Google plus Kinsta/SecNumCloud-grade operations. For regulated or region-sensitive workloads that need a hyperscaler address without operating GKE, the premium is the product.
• Pick Render's fixed tiers if your service count is small and stable, the bundle fits (Starter/Standard for a solo API + worker), and you stay inside the included bandwidth and on Hobby $0. Crossing into Pro workspace ($25) or Pro Plus ($175) or multiplying Standards is the cliff where the per-service arithmetic overtakes the sticker.
• Pick Fly.io or Railway per-second if your workload is bursty, scales to near-zero, or lives as ephemeral preview environments. For an always-on, always-warm API + worker, you are paying a metered premium for uptime you never stop consuming — the worst shape for a per-second bill.
• Pick Hetzner flat under Cluster API (bex) if your workload is always-on, bandwidth-real (200 GB is already the wedge, 1 TB makes it obvious), and you want the invoice that does not change when a vendor invents a new billing line. Provision for the steady state you run every day, not the burst you hit once a month — the build-node-pool tradeoff from burst git-push traffic is exactly where a fixed fleet overpays if sized for peak, which is why a platform that owns the fleet still wants elastic bursting for the top of the curve, not for the baseline.

If you are migrating off Render or Heroku and your bill's largest surprise last quarter was bandwidth, not compute, start with the bandwidth-included comparison before you re-price vCPU — it will move the ranking more than any instance swap. And if you are evaluating after June 2026, re-price Hetzner at June numbers, not February blog-post numbers, before you declare a delta.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Sevalla, Render, Fly.io, and Railway each optimize a different billing dimension; bex optimizes for the dimension none of them can bill you for twice: the box itself, flat every month, bandwidth included, on a Cluster API fleet you control. Star the repo on GitHub or deploy your first app today.

Sources​

• Back4App — "Best Heroku Alternatives in 2026 — Compared & Ranked" (updated February 2026) — 10-way comparison including Sevalla, Render, Fly.io, Railway; Sevalla S4 and C1 tiers, free-tier/migration notes.
• Sevalla / Kinsta pricing and docs — Standard S4 $160/mo (4 vCPU/8 GB), CPU-optimized C1 $18/mo (1 vCPU/1 GB); "Pay for what you run. No Kubernetes overhead. No per-seat pricing."; Kinsta→Sevalla GKE case study ("production infrastructure without hyperscaler complexity").
• GetDeploying — Hostinger vs Sevalla; Koyeb vs Sevalla — Sevalla S4 $160/mo (4 vCPU/8 GB), C1 $18/mo corroboration.
• Google Cloud / GKE pricing — GKE Autopilot ~$0.0356/vCPU-hour, ~$0.0039/GB-hour (TrustRadius/GCP sheets, 2026); used to bound the GKE-rented floor under Sevalla's flat.
• Render docs & pricing (2026) — Starter $7/mo (0.5 vCPU/512 MB), Standard $25/mo (1 vCPU/2 GB), Pro Plus $175/mo (4 vCPU/8 GB), workspace Hobby $0 / Pro $25 / Scale $499 (April 2026 overhaul), disk $0.25/GB-mo, bandwidth included bands then $0.15/GB.
• Fly.io docs (2026) — Machines per-second billing, volumes $0.15/GB-mo, egress $0.02 NA/EU / $0.04 APAC/SA / $0.12 Africa/India, egress IP billing since Jan 1 2026, inter-region private networking & snapshot metering added Jan–Feb 2026.
• Railway docs & pricing (2026) — $0.00000772/vCPU-sec, $0.00000386/GB-sec, egress $0.05/GB (vintage $0.10/GB), Hobby $5 / Pro $20 per seat, $20/vCPU-mo + $10/GB RAM-mo equivalents.
• Hetzner Cloud pricing & price-adjustment notices (2026) — April 1 broad hike (~30–37%, AX42 €47.30→€57.30, Object Storage €4.99→€6.49), June 15 SKU standardization with CCX/CPX up 2.1–2.75× and shared lines ~30% on new orders/rescales (existing grandfathered); 20 TB included traffic per large instance, overage ~€1/TB; DRAM contract-price surge ~90–95% QoQ Q1 2026 (TrendForce/IDC characterization as structural, not cyclical).
• Supporting comparisons — Techsy "Railway vs Render vs Fly.io: Benchmarks & Pricing (2026)", Sliplane self-hosting pricing tables (Fly.io ~$18, Render ~$35, Railway ~$67+$20 for 2 vCPU/2 GB benchmarks), Hetzner community pricing trackers (CCX13 €42.99 dedicated 2 vCPU/8 GB post-hike reference).