PEC.com
Team-size cost framework

2-engineer platform team cost and the failure modes

Two engineers is the smallest viable platform-team size. Serving 20 to 40 product engineers, our model puts it at $594k to $701k a year, $18k to $30k per developer served. It works as a bootstrap configuration; it does not work as a steady state.

Annual all-in (model)
$594k-$701k
Salary, tooling, the platform's own cloud and overhead. Inputs in the table below.
Sustainable on-call
No
2-person rotation is week-on-week-off. Leads to burnout in months, not years.
Right fit at
20-40 devs
Bootstrap configuration. Hire #3 around 40-50 product engineers.

Why 2 engineers is a real configuration

Our 1:8 to 1:12 planning ratio (our own heuristic, not a survey finding, explained on /team-structure) puts platform-team headcount for a 20 to 40-engineer organisation at 2 to 5 engineers. Two engineers is the minimum that can do anything useful and is the configuration many organisations land at when they first acknowledge platform-engineering work as a discipline rather than something engineers do in their spare time.

The 2-engineer team is not a forever configuration for most organisations. It is the right configuration for the first 12 to 18 months of intentional platform engineering, while the organisation is still under 50 engineers and the platform's scope is limited. After that, the structural fragility of a 2-person team starts to bite and the case for the third hire becomes urgent.

Where the money goes

Salary is the dominant line. The model costs both engineers at the $190k blended loaded rate (see /salary; a senior-plus-senior pairing costs more than that), and 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, so it is the line that grows across the 20 to 40-engineer range. The platform's own cloud (a small cluster, managed CI/CD and observability, a few support services) is modest; product-workload cloud is excluded because it belongs to product engineering. See /hidden-costs for what the overhead line covers.

The model, line by line, for a 2-engineer platform team

The same team costed at the smallest and largest product organisation this page says it fits. 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 inputAt 20 product engineersAt 40 product engineers
Platform engineers2 x $190k loaded2 x $190k loaded
Annual lineAt 20 product engineersAt 40 product engineers
People (loaded salary)$380,000$380,000
Tooling (Standard tier, $5k per product engineer)$100,000$200,000
Cloud for the platform itself (managed)$57,000$64,000
Overhead (15% of salary: on-call, training, recruiting)$57,000$57,000
Total per year$594,000$701,000
Per product engineer served$29,700$17,525

People are 54% to 64% of the total, tooling 17% to 29%. Product-workload cloud spend is excluded: it belongs to product engineering, not the platform line.

The three single-points-of-failure

The structural fragility of a 2-engineer team has three concrete failure modes:

  • On-call rotation. A sustainable on-call rotation needs at least 3 people. With two, on-call is week-on-week-off, which is the equivalent of being on-call 26 weeks a year. Reasonable engineers do not stay in that configuration long; the data from PagerDuty and BMC on engineer burnout is unambiguous about this.
  • Holiday and sickness coverage. If one engineer is on holiday and the other is sick, the platform has no responsible engineer for that day. For a few days a quarter this is acceptable; for a few weeks a year it becomes a regular operational risk.
  • Institutional knowledge. With two engineers, every meaningful platform decision lives in two heads. Documentation discipline can mitigate this but not fully; when one engineer leaves, half of the platform's history walks out the door. A 3-person team is much more resilient to attrition.

What a 2-engineer team can actually deliver

Realistic scope for a 2-engineer team supporting 20 to 40 product engineers in year one:

  • One golden path for the most common service type, with automated scaffolding (typically using a commercial IDP like Port at standard tier, or hosted Backstage, rather than self-host).
  • Managed CI/CD across all repositories with reasonable build-time SLAs. Using a commercial CI/CD service (not self-hosted) to keep the operational cost down.
  • Basic service-catalogue data discipline: every service has an owner, a runbook link, a documentation link.
  • A managed observability foundation using a commercial service (Datadog, New Relic, Honeycomb), with basic dashboards and paging integration.
  • A secrets-management story using either a cloud-native secrets service or a commercial secrets manager at lean tier.

What a 2-engineer team explicitly cannot deliver:

  • Multiple golden paths for different service types.
  • Sustainable 24x7 on-call coverage.
  • Deep self-service infrastructure provisioning beyond what the IDP gives for free.
  • Custom plugins or extensions beyond what a vendor's stock product covers.
  • Mature scorecards covering many engineering standards.
  • FinOps integration.
  • Multi-region operations.

A 2-engineer team that tries to deliver beyond that scope tends to either burn out or under-deliver; the better posture is to scope explicitly to what is achievable and to push for the third hire when the scope demands more.

The cost case for hiring the third

In our model, hiring the third platform engineer adds about $218k a year at the blended loaded rate, overhead included. That money buys three things:

  • Sustainable on-call (1-in-3 rotation), which reduces burnout risk and improves retention.
  • Holiday and sickness coverage, which reduces operational risk.
  • Institutional knowledge resilience: the third engineer typically holds a third of the platform's history, which makes the team much less fragile to attrition.

The cost case is straightforward when one of the failure modes has bitten or is imminent. The harder conversation is when the team is functioning fine and the case is preventative: in that conversation, the right anchor is the cost of attrition for one of the existing two engineers (recruitment, ramp-up, and lost institutional knowledge), set against the cost of hiring the third engineer preventatively.

When 2 is genuinely the right permanent size

Some organisations sit permanently at 2 platform engineers. The configuration that makes this viable:

  • Product organisation is genuinely stable at 30 to 50 engineers with no growth pressure.
  • Heavy adoption of managed services across the entire stack (managed CI/CD, managed observability, commercial IDP, managed Kubernetes or even fully-managed PaaS).
  • The platform team's scope is explicitly limited to golden paths, glue, and adoption work rather than substrate operations.
  • On-call is shared with the broader engineering organisation (typically a follow-the-sun rotation that includes senior product engineers), not just the platform team.

In that configuration, 2 engineers can sustainably run the platform indefinitely. The trade-off is heavy dependency on the vendors involved (which is fine if the vendor relationships are healthy) and loss of the long-term option to differentiate on platform engineering (which matters more for some organisations than others).

Comparison with adjacent team sizes

  • 2 engineers: $594k to $701k a year, suits 20 to 40 product engineers (this page).
  • 5 engineers: $1.46M to $1.95M, suits 60 to 150 product engineers, the MVP configuration.
  • 10 engineers: $3.04M to $3.57M, suits 150 to 250 product engineers, sub-team specialisation crossover.

For the corresponding org-size-driven cost pictures see /cost-for-50-developers, /cost-for-100-developers, and onward.

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 size, tooling bands, cloud formula and overhead rate are our assumptions; see /methodology. On-call burnout research per PagerDuty and BMC published surveys. Model reviewed 25 October 2026.

Frequently asked questions

What does a 2-engineer platform team cost?
In our planning model, $594k to $701k a year, costed at 20 to 40 product engineers. Both engineers are counted at the $190k blended loaded rate, with a fixed 15% overhead on salary (on-call, training, recruiting), standard-tier tooling per product engineer and a managed cloud footprint for the platform itself. Salary is the largest line; tooling grows with the number of product engineers served, which is why the total rises across the range. A senior-heavy pairing costs more than the blended rate assumes (see /salary). The full table is on this page.
Why is a 2-engineer team fragile?
Three single-points-of-failure that disappear at three engineers. First, on-call: a sustainable on-call rotation needs at least 3 people; with two, on-call is week-on-week-off, which leads to burnout within months. Second, holidays: if one engineer is on holiday and the other is sick, there is no-one running the platform. Third, institutional knowledge: with two engineers, every platform decision lives in two heads; if one leaves, half of the platform's history walks out the door. A 2-engineer team is a viable bootstrap configuration; it is not a viable steady state.
What can a 2-engineer team actually deliver?
Realistically: one golden path for the most common service type with automated scaffolding, managed CI/CD across all repositories with reasonable build-time SLAs, basic service-catalogue data discipline (every service has an owner, a runbook link), a managed observability foundation if you use commercial managed services rather than building your own. What it cannot deliver: multiple golden paths, sustainable on-call coverage, deep self-service infrastructure provisioning, mature scorecards, environment-promotion automation, FinOps integration. A 2-engineer team is appropriate for a 20 to 40-engineer organisation in the early bootstrap phase, not for a 50+ engineer organisation that has matured.
When should we hire the third platform engineer?
Either when the product organisation crosses 40 engineers, when the existing two engineers cumulatively report 3+ months of fatigue from on-call, or when the platform-team backlog is so long that work that should take days is taking weeks. The third hire transforms the team from fragile to viable: 1-in-3 on-call is sustainable, holiday coverage works, institutional knowledge is more durable. Plan for the hire 4 to 6 months ahead of needing them; senior platform engineer hires take time at the small organisation size that justifies a 2-engineer team.
What is the per-developer cost when the platform team is 2 engineers?
In our model, at 30 product engineers (the typical organisation size for a 2-engineer platform team) the per-developer cost is about $22k a year, which is high because the fixed platform-team cost amortises across few engineers. At 50 product engineers (where a 2-engineer team is the lean choice) it is about $15k. At 80 engineers (where a 2-engineer team is genuinely under-staffed) the per-developer cost looks low (about $11k) but the platform is failing to deliver and engineers are spending their own time on operational tasks that should be platform work; the real cost is higher when measured as recovered product-engineering time.
Is a 2-engineer team a permanent configuration anywhere?
Sometimes, in organisations that have explicitly chosen a small permanent platform team with high managed-services adoption. Common in 50-engineer SaaS organisations that use a fully-managed CI/CD platform, a fully-managed observability stack, a commercial IDP, and a managed Kubernetes service, leaving the platform team to focus on golden paths, glue, and adoption. In that configuration, 2 engineers can sustainably run the platform indefinitely. The trade-off is dependency on the vendors involved and loss of the long-term option to differentiate on platform engineering.

Updated 2026-11-14