Start typing to search this publication.
techcirkle
Open menu

Subscribe to techcirkle

Get new posts delivered straight to your inbox.

The Flattened Pyramid: Why Four Seniors Now Beat Eight Mid-Levels

AI tooling compressed implementation but not judgement, which inverted the economics of the traditional delivery pyramid. Here is the new shape.

techcirkle
6 min read
Cover image for The Flattened Pyramid: Why Four Seniors Now Beat Eight Mid-Levels
Development team collaborating on software architecture and code
Development team collaborating on software architecture and code

The standard delivery team shape held steady for about fifteen years: one tech lead, two or three mid-level engineers, three or four juniors. It was not arbitrary. It reflected a genuine economic reality — a large share of the work was volume implementation that a junior could complete under supervision, and supervision was cheaper than doing it yourself.

That premise no longer holds, and the team shape that follows is measurably different. Worth working through why, because it changes how you read a proposal and how you staff a project.

What the pyramid was actually solving for

Break a conventional build into categories:

  1. Design work — data models, boundaries, failure modes, the decisions that are expensive to reverse

  2. Volume implementation — CRUD endpoints, forms, admin screens, test fixtures, migrations, integration clients

  3. Judgement work — the edge case in the billing rules, the undocumented behaviour of the legacy system, the reason that innocuous requirement is actually a two-week problem

  4. Verification — testing, review, ensuring it does what was intended

Historically category 2 was the largest by hours and the most parallelisable. Juniors could do it. Reviewing junior output cost the lead less time than writing it. So you hired a pyramid, and the constraint on delivery speed was how many hands you could usefully coordinate.

Categories 1 and 3 were always senior-only, but they were a smaller share of total hours, so the pyramid's economics worked.

What changed

AI-assisted development compressed category 2 hard. Not eliminated — someone still has to specify, review, and integrate — but a senior engineer with good tooling now produces volume implementation faster than they could previously supervise a junior producing it.

That single change inverts the pyramid's logic. If the parallelisable work is no longer the bottleneck, adding parallel hands stops buying speed and starts buying coordination overhead.

Meanwhile categories 1 and 3 did not compress at all. Tooling does not tell you that the legacy system silently truncates a field, or that your proposed data model makes a likely future requirement impossible. That knowledge is either in someone's head or it is discovered expensively in production.

So the composition of remaining work shifted toward exactly the categories that were always senior-only. The scarce input moved from throughput to context.

The new shape

For a mid-sized build, a strong 2026 team looks closer to:

  • Two or three genuinely senior engineers with tooling fluency

  • One product-minded lead who can make scope calls without escalating

  • A designer

Rather than eight people across four levels.

The arithmetic is uncomfortable for procurement, because per-head cost is higher and the total is usually lower. Four people at £1,100 is £4,400 a day. Eight at £700 is £5,600 — plus coordination overhead, plus the review burden concentrated on whoever holds the architecture, plus the throughput lost to explaining the domain repeatedly.

That last cost is the one nobody itemises and it is frequently the largest.

The obvious objection

"So we should never hire juniors?"

No, and I want to be careful not to overstate this. The argument is about the shape of a time-boxed delivery team on a client project, not about how an engineering organisation should develop people.

Juniors become seniors by doing work under supervision, and if the industry stops creating those positions the pipeline problem in five years is severe. That is a real cost and it is being externalised right now.

But the mechanism has changed. The traditional path — learn by grinding through volume implementation — has largely been automated away. The path that seems to work now is narrower and more deliberate: pair on design decisions, own verification and testing, take responsibility for a bounded subsystem end to end. Fewer hands on the keyboard, more time on reasoning.

That is a harder thing for an agency to fund on a client project, which is precisely why it needs to be deliberate rather than incidental.

How this changes reading a proposal

Three practical consequences.

Team size is not a proxy for capacity. Ask what each named individual will actually do. A proposal listing eight people where four are below senior level is describing the 2019 shape, which suggests either the estimating model has not been revisited or the structure is optimised for revenue rather than delivery.

Watch the seniority ratio over time. The classic bait-and-switch is seniors present for the first two months and reassigned thereafter. Get named individuals with committed percentages in the statement of work and a right to reject substitutions.

Test tooling discipline, not tooling enthusiasm. There is a substantial difference between an engineer using assistance to move faster within a design they hold in their head, and one accepting generated code they cannot fully explain. The second produces a codebase that looks fine at handover and becomes unmaintainable within a year.

The efficient test: ask them to walk you through a real pull request from a recent project and explain why a specific block is written that way. Confident, specific reasoning is what you want. Vagueness about their own recent code tells you what you need to know, and it is a far better probe than asking whether they use AI tooling at all.

The uncomfortable summary

The team shape that delivers best right now is smaller and more expensive per person than the one most agencies still propose and most procurement processes still reward.

Procurement optimises for day rate because day rate is comparable across bids. Total cost of delivery is not comparable, so it gets ignored. Which means the flattened pyramid is currently a slight competitive disadvantage in a bidding process and a significant advantage in delivery — a gap that will presumably close, and has not yet.

Full guide with 2026 UK rate tables, IR35 context, and a six-week selection process: Software Development Agency UK: How to Choose the Right One in 2026.

We staff this way at TechCirkle — custom software development and AI app development for UK clients.

Two business teams shaking hands after successfully negotiating a software development contract
Two business teams shaking hands after successfully negotiating a software development contract

Frequently Asked Questions

Why did the traditional delivery pyramid stop working?

Because it assumed volume implementation — CRUD endpoints, forms, test fixtures, migrations — was the largest and most parallelisable share of work, and that supervising a junior on it cost the lead less than doing it. AI tooling made senior engineers faster at that work than supervision was, which removed the pyramid's economic basis.

What does a strong delivery team look like now?

For a mid-sized build: two or three genuinely senior engineers with tooling fluency, one product-minded lead who can make scope calls without escalating, and a designer. Per-head cost is higher and total cost is usually lower once coordination overhead and repeated domain explanation are counted.

Is a team of eight at a lower rate cheaper than four at a higher rate?

Usually not. Four at £1,100 is £4,400 a day against eight at £700 being £5,600, before adding coordination overhead, concentrated review burden on whoever holds the architecture, and throughput lost to explaining the domain repeatedly. That last cost is rarely itemised and often the largest.

Does this mean junior engineers are no longer worth hiring?

No — the argument concerns time-boxed client delivery teams, not how an engineering organisation develops people. The traditional path of learning through volume implementation has largely been automated, so the effective route is now narrower: pairing on design decisions, owning verification, and taking end-to-end responsibility for a bounded subsystem.

How do I test whether engineers use AI tooling well?

Ask them to walk through a real pull request from a recent project and explain why a specific block is written as it is. Confident, specific reasoning indicates assistance used within a design they hold; vagueness about their own recent code indicates accepted output they cannot explain, which degrades maintainability within about a year.

What should I watch for in a proposal's team structure?

Whether more than half the named people sit below senior level, which suggests the estimating model has not been revisited or the structure is optimised for revenue. Also watch for the seniority ratio dropping after month two — get committed percentages in the statement of work with a right to reject substitutions.

Why do procurement processes still reward the old team shape?

Because day rate is comparable across bids while total cost of delivery is not, so the comparable number gets weighted and the meaningful one gets ignored. That makes a smaller senior team a slight disadvantage in bidding and a significant advantage in delivery — a gap that presumably closes eventually but has not yet.

Subscribe to techcirkle