All Articles
StrategyNov 4, 202615 min

Platform Engineering vs Hiring More Developers: How to Decide What Actually Speeds Up Delivery

When delivery slows down as the company grows, the reflex is to open more developer roles. Sometimes that is right. More often the bottleneck is friction that every new hire inherits. This is the decision test I use with CTOs: what the evidence says about platform engineering, the headcount maths nobody runs, and a cost model you can fill in with your own numbers.

Michele Cimmino

CEO & Founder · Lasting Dynamics

If delivery is slowing down while your engineering team grows, hire more developers only when the work is waiting for hands. If the work is waiting for environments, reviews, pipelines, approvals and answers, fund platform engineering instead, because every developer you add will inherit the same friction and add coordination on top of it. You can tell the two apart in two weeks with four delivery metrics and one honest survey, and you can decide the budget with a break-even calculation: a four-person platform team serving sixty developers pays for itself if it gives each of them back less than three hours a week.
That is the short answer. The long answer matters because both options are expensive, both take months to show results, and the wrong one makes the problem worse before anyone notices. Most of the material on this topic is written by tool vendors explaining what platform engineering is. Very little of it helps the person who has to choose between a job requisition and a platform budget in the next planning cycle.

Who this guide is for

You are a CTO, a VP of Engineering or a founder-CEO with somewhere between thirty and a hundred and fifty engineers. Releases that used to take days now take weeks, the senior people spend their time unblocking others, and the board or the CFO is asking whether the answer is more people. I have had to make this call in my own company and with clients in finance, insurance and healthcare. What follows is the method, not a product.

The Question Behind the Question

Nobody really asks whether they should do platform engineering. They ask why a feature that should take two weeks takes two months, and whether more people would fix it. The honest first answer is that slow delivery has two very different causes, and they call for opposite treatments.
  • A capacity problem: the backlog is well understood, work flows to production without long waits, and the team simply cannot type fast enough to meet the roadmap. More developers help here, after their ramp-up.
  • A friction problem: work sits in queues. Developers wait for a test environment, for a pipeline that fails for reasons unrelated to their change, for the one person who knows how to deploy service X, for a security review that happens at the end. More developers make this worse: more work enters the same queues.
  • A focus problem: the team is busy on the wrong things — too many parallel initiatives, priorities that change weekly. Neither hiring nor a platform fixes this; a product and portfolio decision does.
Most organisations between thirty and a hundred and fifty engineers have some of all three, but one dominates. The rest of this article is about finding out which one, and about what to do when it is friction.

What Platform Engineering Is, in One Paragraph

Platform engineering is a small team that builds and runs an internal developer platform: the paved road that product teams use to create a service, test it, deploy it, observe it and keep it secure without opening a ticket or knowing how the plumbing works. The platform team treats the other developers as its customers and the platform as a product, with a roadmap, adoption metrics and support. In practice it ships things like:
  • Golden paths: templates that create a new service with build, tests, deployment, logging and security scanning already wired in.
  • Self-service environments: a test or preview environment in minutes, not a request to another team.
  • Standard pipelines: one CI/CD path that most services use, maintained by the platform team rather than reinvented by each squad.
  • Observability and alerting defaults: dashboards and alerts that exist from day one of every service.
  • Security and compliance baselines: secrets management, dependency scanning, access control and audit evidence built into the road instead of checked at the end.
  • A developer portal or catalogue: where to find services, owners, documentation and the buttons for the actions above.
It is not a renamed operations team that still works through tickets, and it is not the installation of a developer portal product. Teams that buy the portal first and ask what it is for later end up with a well-designed catalogue of the same old friction.

What the Evidence Says — and What It Does Not

The evidence on platform engineering is better than the marketing around it, and more nuanced. The most useful source is the DORA research programme run by Google Cloud, whose 2024 report surveyed more than 39,000 professionals. Here is what the published sources say, with the dates they were published:
FindingNumberSource (date)
Users of an internal developer platform: individual productivity8% higherDORA Accelerate State of DevOps 2024, quoted by TechTarget (7 Nov 2024)
Users of an internal developer platform: team performance10% higherDORA 2024, quoted by TechTarget (7 Nov 2024)
Same group: delivery throughput and change stability8% and 14% lowerDORA 2024, quoted by TechTarget (7 Nov 2024)
Platform initiatives may cause a temporary performance dip before improvements appearQualitative findingGoogle Cloud, announcing the 2024 DORA report (23 Oct 2024)
AI adoption in delivery: throughput and stability−1.5% and −7.2%Google Cloud, 2024 DORA report (23 Oct 2024)
Developers losing 8 or more hours a week to inefficiencies69%Atlassian State of Developer Experience 2024, 2,100+ respondents (14 Jan 2025)
SIXT: developers served by platform engineers800 developers, 40 platform engineersplatformengineering.org (14 Feb 2025)
Read the first three rows together. People who use an internal platform report being more productive and working in better-performing teams, yet the organisations measured also showed lower throughput and lower stability. DORA's own explanation is a curve: early gains, a dip in the middle while the platform is immature and mandatory, then recovery as it matures and becomes something developers choose. These are correlations from a survey, not a controlled experiment, and they should be read that way. But they kill two myths at once: that a platform is a quick win, and that it is a fad with no measurable effect.

Plan for the dip, or you will cancel the platform in month six

The most common failure I see is not a bad platform. It is a good platform cancelled during the dip, because nobody told the board that delivery metrics would wobble while teams migrate. Write the expected dip into the business case, choose leading indicators (adoption, time to first deploy for new services, waiting time in the pipeline) and report those monthly until the lagging delivery metrics catch up.

Why Adding Developers Slows You Down First

Fred Brooks wrote in 1975, in The Mythical Man-Month, that adding people to a late software project makes it later. Part of the reason is arithmetic: the number of possible communication paths in a group of n people is n(n−1)/2. Teams split into squads precisely to avoid this, but every shared service, shared pipeline and shared on-call rota reconnects them. This is how the potential coordination load grows:
People who must coordinatePossible communication pathsGrowth vs 10 people
10451×
201904.2×
4078017×
601,77039×
1004,950110×
Nobody actually talks to 1,769 colleagues, and good team boundaries cut the number dramatically. The point of the table is the shape, not the values: headcount grows linearly, coordination grows with the square. A platform attacks exactly that term, because a developer who deploys through self-service does not need to coordinate with the person who used to deploy for them. Hiring, on its own, adds to it.
There is also the ramp-up. In my experience a good developer joining a codebase of some size needs three to six months to be fully productive, and during that time they consume hours of senior attention every week. If the senior people are already the bottleneck, the first months of a hiring wave reduce delivery capacity. That is acceptable when the hires will pay it back. It is a bad trade when the new people will spend their productive years waiting in the same queues.

The Decision Test: Capacity Problem or Friction Problem?

Before deciding, spend two weeks collecting evidence. You do not need a tool for this; a spreadsheet and some honest conversations are enough. These are the signals I look for, and what each one points to:
SignalPoints to hiringPoints to a platform
Lead time from commit to productionShort and stableLong, or mostly spent waiting
Where a ticket spends its timeIn active developmentIn queues: environments, reviews, approvals, deploy slots
Time for a new developer to ship to productionDaysWeeks, with help from seniors
How services are created and deployedOne consistent wayEach team does it differently
Who gets interruptedNobody in particularThe same three to five senior people
Change failure rate and recovery timeLow failures, quick recoveryFrequent rollbacks, slow diagnosis
Developer survey: hours lost per weekLowSeveral hours, on the same causes
The first and last rows matter most. The four DORA metrics — deployment frequency, lead time for changes, change failure rate and time to restore service — tell you how the system behaves. The survey tells you why. If lead time is long but active work is a small fraction of it, you have a friction problem, and more developers will wait faster.
  1. Pull the last three months of commits, deployments and incidents and compute the four DORA metrics per team.
  2. Sample twenty recently finished tickets and note how long each spent waiting versus being worked on.
  3. Ask the three most recent hires how long it took them to ship their first change to production, and what blocked them.
  4. Run a short anonymous survey: hours lost per week and the top three causes, in the developers' own words.
  5. List the people who are interrupted most often and what they are asked for.

The Cost Comparison, Done Honestly

Once you know the problem is mostly friction, the remaining question is money. Here is a simple model. Take an organisation with sixty developers and the choice between hiring four more product developers or funding a four-person platform team. Assume, for simplicity, the same fully loaded cost per person for both roles; in reality platform engineers usually cost somewhat more, which you can add. Four people out of sixty is 6.7% of the developer capacity. So the platform team breaks even when it gives back 6.7% of the time of the sixty developers it serves: about 2.7 hours per developer in a forty-hour week.
QuestionHire 4 product developersFund a 4-person platform team
Nominal capacity added+4 developers (6.7%)None directly; returns time to 60 developers
Break-even conditionNew hires reach full productivity and coordination cost does not risePlatform returns at least ~2.7 hours a week to each developer
Time to first effect3–6 months of ramp-up (my experience)Weeks for quick wins, a dip during migration (DORA 2024)
Does the effect compound as you grow?No — each hire adds coordinationYes — each new developer starts on the same paved road
Main riskMore people waiting in the same queuesA platform that nobody adopts
Now compare the break-even with the evidence. Atlassian's survey found that 69% of developers lose eight hours or more a week to inefficiencies. A platform team only needs to recover about a third of that to pay for itself, before counting the second-order effects: faster onboarding of every future hire, fewer incidents, and senior people back on design work. The model is illustrative and you should plug in your own salaries and survey results. Its value is that it turns a debate about preferences into a question with a number: can this team return 2.7 hours a week to each developer within a year? If the survey says developers lose one hour a week, the answer is probably no, and you should hire.

My rule of thumb on size

Below roughly twenty-five to thirty engineers I almost never recommend a dedicated platform team. At that size one or two senior engineers can own the paved road part-time, and the money is better spent on product capacity. Between thirty and eighty, a small platform team of three or four people, run as a product, is usually the best investment you can make in delivery speed. Above that, the question is no longer whether but how many. At Lasting Dynamics we went through exactly this sequence, and the mistakes we made on the way are in the list below.

When Hiring More Developers Is the Right Answer

  • Lead time is short and work does not wait. Your system flows; you simply have more roadmap than people.
  • You need skills you do not have. A mobile team, a data engineer, a security specialist: a platform cannot replace missing expertise.
  • You are under twenty-five engineers. The fixed cost of a platform team is too high a share of the total.
  • The product is still searching for fit. Standardising the road before you know where it leads is premature; speed of experimentation matters more.
  • The new work is separate. A new product line with its own stack and little coupling to the existing system adds few communication paths.
When you do hire, hire well: the way you structure, contract and onboard an external or dedicated team decides whether it adds capacity or friction. I covered that in how to hire a dedicated software development team.

When a Platform Team Is the Right Answer

  • Most of the lead time is waiting. Environments, deploys and reviews dominate the clock.
  • New developers need weeks to ship their first change. Every future hire will pay that tax.
  • Each team builds its own pipelines and infrastructure. You are paying for the same work many times, with uneven quality.
  • A few senior people are a permanent bottleneck. Their knowledge needs to become self-service.
  • Compliance evidence is assembled by hand before audits. It should be produced by the road itself.
  • You plan to grow the team by a third or more in the next eighteen months. The platform compounds; hiring into friction does not.

The Middle Path Most Companies Should Take First

The choice is rarely binary. Matthew Skelton and Manuel Pais, in Team Topologies (2019), describe the idea of a thinnest viable platform: the smallest set of documented standards, templates and self-service capabilities that removes the most friction. For many companies the right first step is not a team of six and a portal; it is two engineers for two quarters with a narrow mandate:
  • One golden path for the most common type of service, from creation to production.
  • Self-service preview environments for that path.
  • One shared pipeline, owned and maintained, that most teams can adopt without changes.
  • Documentation good enough that a new hire can follow the path alone.
  • Two metrics reported monthly: adoption of the path and time to first deploy for new developers.
If adoption grows and the metrics move, you have the business case for a real team. If nobody adopts the path, you learned it for the price of two people for six months, not a year of a department.

How to Staff a Platform Team Without Building a New Silo

The risk of a platform team is that it becomes the operations team of ten years ago: a group that owns the infrastructure, works through tickets and decides on behalf of developers. These are the rules that prevent it:
  • Give it a product owner. Someone whose job is to understand what the internal customers need and to say no to the rest.
  • Make adoption voluntary where you can. If teams use the road because it is easier, you have a product. If they use it because they must, you have a policy, and you will see the DORA dip in full.
  • Measure the platform by its customers' outcomes: time to first deploy, lead time and the survey, not tickets closed.
  • Staff it with developers, not only with infrastructure specialists. People who have suffered the friction design better roads.
  • Rotate product engineers through it. A quarter on the platform team spreads knowledge and keeps the platform honest.
On ratios: SIXT has published that forty platform engineers serve eight hundred developers, one to twenty. That is the ratio of a mature platform at large scale, not a starting point. A company of sixty will usually start with three or four people, a higher ratio, and grow the team much more slowly than the product organisation.

AI Coding Assistants Change the Equation, Not the Answer

A new version of the question I hear is: why hire developers or build platforms when AI assistants make each developer faster? The same 2024 DORA research found that higher AI adoption was associated with an estimated 1.5% drop in delivery throughput and a 7.2% drop in delivery stability, and its authors pointed back to the basics: small batches and robust testing. AI moves the bottleneck from writing code to reviewing, testing and deploying it, which is precisely the territory of a platform. More code arriving faster at the same manual gates produces longer queues, not faster delivery. The guardrails that make AI-generated code safe in production — review gates, test floors, limited blast radius — are things a platform team builds once for everyone. I described them in the enterprise guardrail playbook for vibe coding.

Regulated Industries: The Platform Is Where Compliance Lives

In banking, insurance, healthcare and energy, the case for a platform is stronger, for a reason that has nothing to do with speed. Change management, segregation of duties, audit trails and access control are obligations, and in most organisations they are satisfied by manual evidence collected before each audit. A paved road can produce that evidence automatically on every change. Note the name collision: the DORA metrics discussed above come from Google's DevOps research; the EU Digital Operational Resilience Act, also called DORA (Regulation (EU) 2022/2554, applicable since 17 January 2025), is a different thing, but a well-built platform helps with both. If your friction comes from a legacy core that every change must touch, a platform will not remove it alone; that is a modernisation decision, which I covered in the legacy modernisation guide for banking and insurance.

Mistakes I See Repeatedly

  • Buying the portal first. A developer portal shows the friction more clearly; it does not remove it.
  • Making the platform mandatory on day one. You get the dip without the goodwill.
  • Measuring the platform team by its own output. Tickets closed and features shipped by the platform say nothing about the developers' time.
  • Building for the most advanced team. The road should serve the median team; the advanced ones will find their own way and should be allowed to.
  • Hiring a wave of developers and planning the platform for later. Every month of hiring into friction makes the migration bigger.
  • Deciding without numbers. Both sides of this debate argue from intuition. Two weeks of measurement settle most of it.

A 90-Day Plan

  1. Weeks 1–2 — measure. The four DORA metrics per team, waiting versus working time on twenty tickets, time to first deploy for recent hires and the anonymous survey.
  2. Week 3 — decide. Classify the problem as capacity, friction or focus; run the break-even model with your own costs and survey results; take it to the leadership team with the expected dip written down.
  3. Weeks 4–6 — start thin. If it is friction, assign two senior engineers to the thinnest viable platform with a product owner and a narrow mandate: one golden path, preview environments, one pipeline.
  4. Weeks 7–10 — first adopters. Move two volunteer teams onto the path, fix what they hate, document what they needed to ask.
  5. Weeks 11–13 — review. Compare adoption, time to first deploy and the survey with week 2. Fund the team, change the mandate, or stop — and resume hiring with confidence that the new people will not wait.

Conclusion

Platform engineering versus hiring more developers is not a question of fashion or philosophy. It is a diagnosis. If the work waits for hands, hire. If it waits for everything else, every new hire will wait too, and a small platform team run as a product is the cheapest way to give the whole organisation back its time. Measure for two weeks, write the break-even down, start thin, plan for the dip, and let adoption decide how big the platform becomes. If you need someone outside the organisation to run that diagnosis or to lead engineering through the change, that is the kind of work a fractional CTO does.

If you want an independent second opinion

I help CTOs and CEOs answer exactly this question with their own data: the two-week diagnosis, the break-even model, and the first ninety days of a platform or a hiring plan. I have no platform product to sell you, and sometimes the answer is that you should hire.
Deciding whether that internal tooling should be built at all, or bought off the shelf? I use a five-question score for it in my build vs buy software framework.

AI-ready answers

Frequently Asked Questions

Should we invest in platform engineering or hire more developers?+

Hire more developers when work waits for hands: lead time is short and stable and the backlog simply exceeds capacity. Fund platform engineering when work waits for everything else: environments, reviews, pipelines, approvals and a few overloaded senior people. Every developer you add inherits that friction and adds coordination. Measure for two weeks with the four DORA metrics, waiting versus working time on twenty tickets, time to first deploy for recent hires and an anonymous survey of hours lost per week.

When does a platform engineering team pay for itself?+

With the same fully loaded cost per person, a four-person platform team serving sixty developers equals 6.7% of their capacity, so it breaks even if it gives each developer back about 2.7 hours in a forty-hour week. Atlassian's State of Developer Experience 2024 found that 69% of developers lose eight hours or more a week to inefficiencies, so recovering about a third of that loss covers the cost before counting faster onboarding and fewer incidents.

How many developers do you need before a platform team makes sense?+

As a practitioner's rule of thumb, below roughly twenty-five to thirty engineers a dedicated platform team is rarely worth it: one or two senior engineers can own a thin paved road part-time. Between thirty and eighty, a three- or four-person platform team run as a product is usually the best investment in delivery speed. Mature platforms reach far higher ratios: SIXT reports forty platform engineers serving eight hundred developers.

Independent delivery diagnosis

Is your delivery slowing down as the team grows?

I help CTOs and CEOs find out whether the bottleneck is capacity or friction, model the cost of each option with their own numbers, and run the first ninety days of the plan. No platform to sell — sometimes the answer is to hire.

Let’s Talk