Org-size cost framework

Platform engineering cost for 100 developers: $1.1M to $1.8M a year

100 product engineers is the size at which the cost picture is cleanest, the per-developer band is most favourable, and the ROI from platform investment is most reliably positive. Here is the line-by-line.

Platform team size

6-10 engineers

7 to 8 is typical. Lower band for decentralised cultures; upper for regulated or reliability-heavy.

Annual all-in

$1.1M-$1.8M

The cleanest cost band in the org-size spectrum. Salary dominates; tooling and cloud are smaller lines.

Per-developer

$11k-$18k

The 'sweet spot' band per CNCF and Gartner surveys. Lowest per-engineer cost in the spectrum below 200 engineers.

Why this is the anchor cost picture

The site's headline cost number ($11,000 to $18,000 per developer per year, $1.1M to $1.8M total at 100 product engineers) is anchored at the 100-engineer scale on purpose. It is the cleanest organisation size at which the platform-engineering math reliably works:

The platform-team fixed cost has amortised enough across product engineers that per-developer cost looks reasonable.
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 needed yet.
The DORA and DX Core 4 research signals that connect platform investment to engineering velocity are strongest at this scale.

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

The 1:10 to 1:12 platform-to-product engineer ratio cited across CNCF Platforms Working Group, Gartner peer community, and platformengineering.org surveys puts the typical platform team at 100 engineers in the 8 to 12 range. In practice the lower end of that (6 to 8) is more common because organisations under-invest in platform engineering relative to what surveys recommend, and because some platform-team capacity is augmented by SRE-type roles embedded elsewhere.

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.

Salary line: the 65 to 75 percent share

At a typical mid-senior weighted loaded cost of about $190,000 a year per platform engineer (or about $234,000 at the senior loaded rate; see /salary), the salary line dominates:

6-engineer team: about $1.14M loaded.
8-engineer team: about $1.52M loaded.
10-engineer team: about $1.90M loaded.

At 100 product engineers, platform-team salary is typically 65 to 75 percent of total platform spend. Tooling is the next-largest line at 12 to 18 percent. Cloud infrastructure for the platform itself is 5 to 9 percent. Hidden overhead (on-call premiums, training, recruiting amortisation) is 5 to 10 percent. The salary line drives almost everything else; if you change the platform-team size by one engineer, you change total platform spend by about 12 to 15 percent.

Tooling line: the standard tier reality

For a 100-developer organisation at the standard tooling tier (see /tooling-budget), expect about $4,500 to $6,000 per product engineer per year of tooling spend, or $450,000 to $600,000 total. The breakdown is roughly:

CI/CD platform: $60k to $130k a year (see cicdcost.com).
Observability stack: $120k to $250k a year (see monitoringcost.com).
Secrets management: $25k to $50k a year.
Infrastructure-as-code orchestration: $35k to $70k a year.
Service catalogue / developer portal: $30k to $90k a year for hosted or commercial; less if self-hosted Backstage.
Container orchestration management: $50k to $110k a year for managed control plane and policy.

The single-largest tooling line is almost always observability. Organisations with high-cardinality metric sprawl or per-byte log-ingest pricing models tend to land at the high end. Organisations that have invested in sampling discipline, retention policy, and per-team budgets land at the low end.

Cloud and infrastructure

The platform itself runs on cloud compute: CI runners, observability ingest, secrets-manager backend, Kubernetes control planes for shared clusters, developer-portal hosting if self-hosted. For a 100-developer organisation, expect $80k to $160k a year for the platform's own cloud footprint, sitting at about 6 to 10 percent of total platform spend.

This is separate from the cloud spend driven by your product workloads (usually accounted for under product engineering). A clean platform cost picture flags this boundary explicitly; an organisation that rolls product cloud into platform cost will see a much larger platform number than the comparable peer.

Hidden overhead

About 5 to 10 percent of total platform spend is hidden overhead that does not show up as obvious line items but is real cost:

On-call stipends ($300 to $1,500 per engineer per month, plus productivity drag from interrupted sleep).
Training budget ($3,000 to $10,000 per engineer per year for certifications, conferences, courses).
Recruiting amortisation (agency fees or in-house recruiter time spread over a 3 to 4-year tenure).
Internal advocacy time (office hours, lunch-and-learns, golden-path roadshows, scorecard reviews, typically 0.5 of a platform engineer's time at this scale).

For a 100-developer platform team, hidden overhead is typically $80k to $140k a year. See /hidden-costs for the full breakdown.

The three-year cost arc

Platform engineering at 100 developers is not constant year-to-year. The three-year arc typically looks like:

Year 1. Hiring is concentrated (the team grows from whatever it was to its target size), tooling has setup work (initial procurement, integration, training), and some build-vs-buy decisions get revisited. Total: $1.2M to $2.0M loaded.
Year 2. The team is stable, the tooling is in steady state, the golden paths are being authored and adopted. Total: $1.1M to $1.8M loaded, the steady-state band.
Year 3. Tooling negotiations land (multi-year discounts, vendor consolidation), the team's efficiency improves with experience, the platform's value is measurable enough that ROI conversations are settled. Total: $1.0M to $1.6M loaded.

Total three-year cost: about $3.3M to $5.4M at 100 developers. That number is the right input to a CFO-facing ROI conversation; for the framework on how to present that conversation see /roi.

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 cost picture changes as you move up and down the org-size spectrum:

50 developers: $600k to $1.2M a year, $12k to $24k per developer (higher because the fixed cost amortises less).
250 developers: $3.5M to $5.5M, $14k to $22k per developer (slightly higher because sub-team coordination kicks in).
500 developers: $7M to $11M, $14k to $22k per developer.
1,000 developers: $14M to $22M, $14k to $22k per developer.

The 100-developer band is the local minimum of per-developer cost. Above 200 developers, sub-team coordination overhead and the rise of platform management push per-developer cost back up; below 80 developers, the fixed cost amortises less and per-developer cost climbs.

Salary figures per BLS OEWS and Levels.fyi. Platform-to-product ratio per CNCF and Gartner survey data. Verified 2026-05-11.

Frequently asked questions

Why is 100 developers the anchor number?

It is the cleanest org size at which the platform-engineering math reliably works. Below 80 engineers, the platform-team fixed cost amortises across too few product engineers and per-developer cost looks high. Above 200 engineers, sub-team specialisation and management overhead start to add complexity. At 100 engineers, you have a single coherent platform team in the 6 to 10-engineer range, you sit comfortably in the $11k to $18k per-developer cost band, and the ROI numbers from DORA and DX Core 4 research start to look unambiguously good. Most cost framings on this site default to 100 because it is the example that most cleanly demonstrates the picture.

How many platform engineers does a 100-developer organisation need?

Six to ten, with seven or eight being typical. The 1:10 to 1:12 platform-to-product ratio is the centre of the band; the 1:8 end is where you go if reliability or compliance pressure is high (regulated industries, large-volume e-commerce, anything that loses money fast when production breaks); the 1:15 end is where you sit if your engineering culture is comfortable with more decentralised ownership. Below six engineers the team cannot maintain sustainable on-call plus build forward; above ten engineers without sub-team structure the team gets coordination-heavy.

What does the year-1 plus year-2 plus year-3 budget look like?

Year one: $1.2M to $2.0M loaded, slightly above steady-state because hiring is concentrated and tooling has setup work. Year two: $1.1M to $1.8M, the steady-state band. Year three: $1.0M to $1.6M as some tooling negotiations land and the team's efficiency improves. Total three-year: roughly $3.3M to $5.4M. The numbers move proportionally if you target 1:8 (higher) versus 1:12 (lower) ratio.

How much of the $11k to $18k per-developer cost is each line?

For a typical 100-developer organisation at the midpoint of the band ($1.4M annual), the lines are: about 65 to 75 percent platform-team salary ($910k to $1.05M), 12 to 18 percent tooling ($170k to $250k), 5 to 9 percent cloud infrastructure for the platform itself ($70k to $125k), 5 to 10 percent hidden overhead ($70k to $140k). Salary is the dominant line and the one that scales most directly with platform-team size.

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 platform-team fixed cost amortises across too few engineers and the per-developer cost climbs above $18k, which can make the platform investment harder to justify; see /cost-for-50-developers for that picture.

How the team shape evolves.

Build vs buy

Decision framework at this scale.

ROI

CFO-facing ROI conversation.

Run your numbers

Plug in your specific inputs.