PEC.com
Org-size cost framework

Platform engineering cost for 100 developers, line by line

With a 6 to 10-engineer platform team, our model puts the platform line at $1.9M to $2.77M a year all-in, or $19k to $28k per product engineer served. Every input is listed below and adjustable on the calculator.

Platform team size
6-10 engineers
Our planning range. Lower end for decentralised cultures; upper for regulated or reliability-heavy.
Annual all-in (model)
$1.9M-$2.77M
Salary, tooling, the platform's own cloud and overhead. Inputs in the table below.
Per developer served
$19k-$28k
Total divided by 100 product engineers. Platform engineers are not in the denominator.

Why this is the anchor cost picture

100 engineers is the default example across this site because it is the size at which a single platform team works:

  • The platform team is large enough (6 to 10 engineers) to maintain sustainable on-call, build forward, and absorb attrition.
  • The team is small enough that a single coherent team structure works; no sub-team specialisation or management layer needed yet.
  • The platform-team fixed cost spreads across enough product engineers for the per-developer figure to be a useful budgeting number.

That is why most cost framings on this site (the homepage hero, the calculator's default, the build-vs-buy framework) use 100 engineers as the example. This page goes line by line through that anchor.

The 6 to 10-engineer platform team

Our general 1:8 to 1:12 planning ratio (see /team-structure for where that band comes from, and why it is our heuristic rather than a survey finding) would put the platform team at 100 engineers at 9 to 13. We model 6 to 10 here instead, partly because some platform-team capacity is augmented by SRE-type roles embedded elsewhere, and partly because looser ratios are widespread: published guidance elsewhere often sits at 1:15 to 1:25.

The honest band is 6 to 10 platform engineers for a 100-developer organisation:

  • 6 engineers is the lean end. Works for organisations with a strong engineering culture, mature managed services in place, and an explicit decision to keep the platform team small. Allows 1-in-6 on-call rotation, light specialisation, but no formal manager (the senior engineer wears the hat).
  • 7 to 8 engineers is the typical size. Allows sustainable 1-in-7 or 1-in-8 on-call, specialisation across CI/CD, infrastructure, and developer experience, and the first formal manager role (or a senior IC carrying tech-lead responsibilities).
  • 9 to 10 engineers is the upper end. Common in regulated industries, reliability-heavy organisations (large e-commerce, fintech, real-time systems), or organisations where compliance overhead pushes the platform team to grow faster than product engineering.
  • 11+ engineers at 100 product engineers tends to indicate either over-investment or that the organisation is on its way to a larger size and the platform team is hiring ahead.

Where the money goes

Salary is the dominant line and the one that moves with team size: at the $190k blended loaded rate (see /salary), each platform engineer adds about $218k a year once on-call, training and recruiting overhead are counted. Tooling scales with the number of product engineers, not the platform team, which is why its share falls as the team grows. The platform's own cloud (CI runners, observability ingest, shared cluster control planes, portal hosting) is the smallest line; product-workload cloud is excluded because it belongs to product engineering. See /tooling-budget for what the tooling line covers and /hidden-costs for the overhead items.

The model, line by line, for 100 product engineers

Low end = the smallest team on this page, high end = the largest. These are our planning assumptions, not survey data: the $190k blended loaded rate, tooling bands, cloud formula and overhead rate are set out on /methodology, and you can change every one of them on /calculator.

Headcount inputLowHigh
Platform engineers6 x $190k loaded10 x $190k loaded
Annual lineLowHigh
People (loaded salary)$1,140,000$1,900,000
Tooling (Standard tier, $5k per product engineer)$500,000$500,000
Cloud for the platform itself (managed)$85,000$85,000
Overhead (15% of salary: on-call, training, recruiting)$171,000$285,000
Total per year$1,896,000$2,770,000
Per product engineer served$18,960$27,700

People are 60% to 69% of the total, tooling 18% to 26%. Product-workload cloud spend is excluded: it belongs to product engineering, not the platform line.

Build vs buy at 100 developers

The build-vs-buy decision shifts at 100 developers. The platform team is now large enough that some in-house build is rational, but not so large that build-everything makes sense. The typical pattern:

  • Buy. CI/CD platform, observability stack, secrets management, IaC orchestration, developer portal (commercial or hosted), container orchestration management. These have mature commercial markets and the build cost is rarely worth it at this scale.
  • Build. The golden paths and scaffolding (because they are organisation-specific), the integration glue between bought components (because it is your stack), the FinOps tooling (because cloud-cost shape is organisation-specific), and the team-level developer-experience tooling (because the most useful tooling matches your team's workflow).
  • Mix. Service catalogue (hosted commercial or open-source Backstage with custom plugins), scorecards (commercial rubric engine with custom rules), CI optimisation (commercial platform with custom pipeline templates).

See /build-vs-buy for the full decision framework.

Comparison with nearby sizes

The same model at the other org sizes on this site, each with the team size set out on its own page:

  • 50 developers: $973k to $1.19M a year, $19k to $24k per developer.
  • 100 developers: $1.9M to $2.77M, $19k to $28k per developer (this page).
  • 250 developers: $6.55M to $8.43M, $26k to $34k per developer, as a Director and engineering managers join.
  • 500 developers: $13M to $19M, $26k to $38k per developer.
  • 1,000 developers: $25M to $34M, $25k to $34k per developer.

Per-developer cost in the model is driven mostly by the platform-to-product ratio you choose, not by org size: tighten the ratio and the figure rises, loosen it and it falls. See /cost-per-developer for the figure at each ratio.

Every figure on this page is output from our own planning model over the inputs in the table above, not survey or benchmark data. The blended loaded rate, team sizes, tooling bands, cloud formula and overhead rate are our assumptions; see /methodology. Model reviewed 25 October 2026.

Frequently asked questions

Why is 100 developers the anchor number?
It is the size at which a single platform team works: big enough (6 to 10 engineers) to run a sustainable on-call rotation and build forward, small enough that no sub-teams or management layer are needed yet. Below about 80 engineers the fixed cost of a minimum team spreads across fewer product engineers; above about 200 the team splits into sub-teams and management headcount appears. Most cost framings on this site default to 100 for that reason, including the calculator.
How many platform engineers does a 100-developer organisation need?
Six to ten in our planning model. That is a ratio of about 1:10 to 1:17, looser than our general 1:8 to 1:12 planning band because some capacity at this size usually sits in SRE or embedded roles. The tighter end suits reliability- or compliance-heavy organisations (regulated industries, large e-commerce, anything that loses money fast when production breaks); the looser end suits cultures comfortable with decentralised ownership. Below six engineers the team struggles to run on-call and build forward at the same time; above ten without sub-team structure it gets coordination-heavy. The ratio is our heuristic, not a survey finding: see /team-structure.
How does the cost split by line?
In our model, people (loaded salary) are 60% of the total with 6 engineers and 69% with 10; tooling is 18% to 26%; the platform's own cloud is about 4%; overhead (on-call, training, recruiting) is a fixed 15% of salary. Salary is the line that scales with team size: each extra platform engineer adds $218k a year including overhead. The full table is on this page.
What can a 6 to 10-engineer team actually deliver by year three?
A mature platform deployment for a 100-developer organisation should include: 2 to 4 golden paths covering the most common service types; mature CI/CD with build-time SLAs and pipeline observability; a managed observability stack with team-level dashboards and SLO tracking; secrets management with policy as code; a service catalogue with high data freshness; 3 to 5 working scorecards covering reliability, security, ownership, on-call, documentation; self-service environment provisioning for the most common workload types; on-call rotation for the platform itself with mature escalation policies. Beyond that, the team starts to invest in second-order improvements (paved-road tooling, FinOps integration, advanced developer-experience metrics).
When does the 100-developer cost band stop working?
It stops working in two directions. Up: above 200 product engineers, the single-team structure becomes coordination-heavy and you need sub-team specialisation, which adds management overhead and changes the cost profile. The next coherent band is the 250-developer picture (see /cost-for-250-developers). Down: below 80 product engineers, the fixed cost of a minimum team spreads across fewer engineers, which can make the platform investment harder to justify; see /cost-for-50-developers for that picture.

Updated 2026-11-14