Dora NodaA number has been circulating in 2026 platform-engineering commentary: your cloud spend needs to approach $2 million a year before building your own internal platform actually beats renting one. It sounds like an infrastructure bill. It isn't. Break the $2M down and it's almost entirely engineering payroll — the cost of a team building and running the same capabilities a PaaS gives you out of the box. Recompute it for a team running a self-hosted PaaS on owned hardware instead of building from scratch, and the number most teams should actually be budgeting against is roughly 35-65% of that, not $2M.
What the $2 Million Actually Buys
The first thing the $2M figure gets wrong, if you read it as a cloud bill, is that it isn't one. It's the fully loaded cost of a platform team building and operating the equivalent of a PaaS: the git-push pipeline, the build system, the deploy orchestration, the Kubernetes operators, the on-call rotation that keeps all of it running. Industry benchmarking on platform-team costs breaks down like this across org size:
| App engineers | Platform team size | Annual cost (build + run) |
|---|---|---|
| Under 20 | Fractional, if any | Rarely recoups the investment |
| ~25 (smallest viable team) | 2 engineers | $500K–$700K/yr |
| 50 | 4–6 engineers | $600K–$1.2M/yr |
| 100 | 8–10 engineers | $1.1M–$1.8M/yr ($11K–$18K per developer) |
| 200 | 8 engineers, mature/optimized | ~$2.0M/yr |
The $2M mark lines up with roughly 200 application engineers supported by an 8-person platform team — a ratio platform-engineering benchmarks put at 3-5x ROI once the team matures, which is exactly why the rule of thumb exists: below that scale, a dedicated platform team is expensive relative to what it replaces; at or above it, the math flips. A generic "build your own platform from scratch" project separately runs $500K–$2M+ in salaries alone before it even ships, with a 12+ month timeline — which is why orgs under 20 engineers essentially never recoup the cost. The $2M threshold isn't really about your AWS bill. It's about whether you can staff and keep staffed the team that would otherwise buy you a PaaS.
Recomputing the Threshold on Owned Hardware
Here's what that table misses: it assumes the platform team is building the control plane from scratch. If you run a self-hosted PaaS like bex on a Cluster API-managed fleet of owned hardware, the git-push pipeline, build system, and Kubernetes orchestration already exist — bex built and maintains that layer. What's left for your team is operating the fleet, not building the software that runs on it. That's a different job with a much better staffing ratio: benchmarks on self-service DevOps setups — where developers deploy themselves through a platform instead of filing tickets to a platform team — put the achievable infra-ops ratio as high as 1 engineer per 40-50 developers, against the roughly 1-per-10-12 ratio a from-scratch platform team needs. Recomputing the same org-size range against that ratio, plus real Hetzner hardware pricing after the three rounds of 2026 price increases (CCX13 at €42.99/mo up through CCX63 at €853.49/mo), looks like this:
| App engineers | Infra-ops headcount | Headcount cost (@ ~$190K loaded) | Hetzner fleet (annual) | Total annual cost | $/developer |
|---|---|---|---|---|---|
| 25 | 1 | $190K | $20K–$39K | ~$210K–$230K | ~$8.8K |
| 50 | 1–2 | $190K–$380K | $65K–$105K | ~$255K–$485K | ~$7.4K |
| 100 | 2–3 | $380K–$570K | $155K–$260K | ~$535K–$830K | ~$6.8K |
| 200 | 4–5 | $760K–$950K | $325K–$520K | ~$1.09M–$1.47M | ~$6.4K |
Line these up against the build-your-own numbers and the owned-hardware path runs roughly 35-65% of the from-scratch cost at every size in this range — cheapest relative to DIY at the smaller end (a 25-person org pays ~37% of what a from-scratch platform team costs), narrowing toward the larger end (a 200-person org pays closer to 64%). The saving is almost entirely a headcount-ratio effect, not a hardware discount: Hetzner's fleet line is real money, especially after 2026's repricing, but it's a fraction of either path's total. This is also a different, much lower bar than the question of whether self-hosting makes sense at all — separate commentary on bare-metal and colocation puts that threshold at roughly €5K/month in cloud spend, a number small teams cross long before they're anywhere near platform-team territory. The $2M question and the "should I even own hardware" question are not the same threshold, and conflating them is how a team ends up paying DIY-platform prices for infrastructure decisions that only needed a cheaper VPS.
A Worked Example: 60 Engineers, Two Paths
Put a real headcount on it instead of a range. A 60-engineer product org sits between the 50- and 100-developer rows above. On the build-your-own path, a platform team sized at the standard 1-per-10-12 ratio comes out to 5-6 engineers — interpolating the benchmark bands puts fully loaded cost at roughly $1.0M–$1.3M/yr, the payroll for a team designing and running its own git-push pipeline, build system, and Kubernetes operators.
On the self-hosted-PaaS path, the same 60 engineers need roughly 1-2 infra-ops hires at the 1:40-50 self-service ratio ($190K–$380K/yr), plus a Hetzner fleet sized for that workload (interpolating the hardware bands, roughly $85K–$140K/yr after the 2026 price increases). That totals to somewhere around $275K–$520K/yr — call it $400K at the midpoint.
The delta is real money with a real use: $600K-$900K/yr not spent on a platform team is 3-4 additional senior product engineers, or a couple of quarters of runway for a smaller company. That's the number a 60-person engineering org should actually be putting in front of its CFO — not "$2M or nothing," but "$1.0-1.3M to build it ourselves, or roughly a third of that to run it on hardware we own."
The Honest Caveat: Renting bex Is Still Renting
The gap narrowing from 37% to 64% as org size grows isn't noise — it's the tell. A from-scratch platform team gets cheaper per engineer as it scales, because the fixed cost of designing the control plane amortizes over more developers. A self-hosted PaaS's ops team doesn't get that same lever: its headcount ratio is already near the 1:40-50 ceiling that self-service tooling makes achievable, and hardware cost scales roughly linearly with fleet size either way. Extrapolate the trend and the two lines are headed toward each other, even if this model doesn't have good data on exactly where they'd cross past 200 engineers.
That's the honest version of the caveat the pitch usually skips: running bex still means depending on software someone else built and maintains. It's open source, not a black box, but the day a team decides it needs to stop renting even that — because it wants to fork and customize the control plane itself, or because it's grown into genuine hyperscale that a shared-fleet PaaS design doesn't fit — it's not choosing between "keep renting bex" and "go back to Render." It's choosing to become the platform team in the first row of the first table, at the same $500K-$2M-plus build cost and the same roughly-200-engineer scale where that cost starts to pencil out. Renting bex moves the threshold for getting PaaS-grade capability down from $2M to a few hundred thousand dollars a year across most of the range that matters to a growing engineering org. It doesn't erase the threshold. It just means the org that eventually hits it is choosing to leave a self-hosted PaaS for a fully custom Cluster API control plane, not choosing between a $7/service bill and a $2M payroll line.
Where This Actually Lands
For a team somewhere between 25 and 200 engineers — which is most of the teams reading a "should we build our own platform" post in the first place — the $2M figure was never really the number to plan against. It was the cost of one specific path: build the control plane yourself. Running that same capability on a self-hosted PaaS over owned Hetzner hardware lands at roughly a third to two-thirds of that cost across the range, funded almost entirely by a better ops-to-developer ratio rather than cheaper servers. The number worth writing on a whiteboard isn't "$2M." It's "what does our infra-ops ratio actually need to be if the deploy pipeline is already built" — and for most teams under a few hundred engineers, the honest answer is a fraction of a from-scratch platform team, not a fraction of nothing.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on Cluster-API-managed machines you own, without staffing the platform team that would otherwise cost you seven figures a year. Star the repo on GitHub or deploy your first app today.
Sources
- Platform Engineering Cost Calculator 2026 — IDP Team and Tooling Costs
- 2-Engineer Platform Team Cost: $500k-$700k/yr and What You Cannot Do — PlatformEngineeringCost.com
- Platform Engineering Cost for 50 Developers: $600k-$1.2M/yr — PlatformEngineeringCost.com
- Platform Engineering Cost 2026: $11k-$18k Per Developer — PlatformEngineeringCost.com
- When to Invest in Platform Engineering (and When Not To) - 2026 — PlatformEngineeringCost.com
- Platform Engineer Salary 2026: $132k-$217k (5 Sources) — PlatformEngineeringCost.com
- Internal Developer Platform: Build vs Buy in 2026 — Encore.dev
- DevProd headcount benchmarks, Q1 2026 — Justin Reock / getdx.com
- The Ideal Site Reliability Engineer to Developer Ratio — Zeet.co
- Don't rent the cloud, own instead — Hacker News
- Hetzner cloud server price increases in 2026: full breakdown and alternatives — Northflank
- Hetzner price increase June 2026: CPX and CCX up to +176% — wz-it.com
- Kubernetes on Hetzner Using Bare Metal Servers as Nodes — Hetzner Community
