One team vs. five vendors: the real cost of handoffs

The logic sounds reasonable: hire the best specialist for each layer. One agency for design. A separate shop for backend. A mobile contractor for the app. A DevOps freelancer for infrastructure. You get experts at every level.

What you actually get is a coordination tax that compounds every week — and it's larger than most founders expect before they've lived through it.

Where the time actually goes

On a five-vendor engagement, engineering time breaks down roughly like this:

• ~35% building features
• ~25% in handoff, clarification, and review cycles
• ~20% debugging integration issues between parts built independently
• ~20% on alignment meetings, status updates, and context-setting

That means less than half the hours you're paying for go toward actually moving the product forward. The rest is friction — necessary friction, in the sense that someone has to do it, but friction nonetheless.

The vendors aren't doing anything wrong. Handoff overhead is structural: it's the cost of keeping four separate context windows in sync on a shared problem.

The integration bug tax

Components built by independent teams integrate badly with surprising regularity. Not because the teams are incompetent, but because the assumptions each team makes about the other's output are invisible until they collide in staging.

Common examples:

• The API schema the backend team built doesn't match the shape the frontend team assumed — discovered in week 8
• The design system the design agency produced doesn't account for real data lengths or error states — discovered in UAT
• The mobile contractor built offline sync against an API contract that the backend team changed — discovered post-launch

Each of these is fixable. The cost is a week of debugging and a week of rework, repeated across however many integration points you have.

What integrated teams actually cost

The counter-argument is almost always: "A full-stack team is more expensive per hour." Sometimes that's true. But the all-in cost calculation rarely favours fragmentation.

An integrated team of four senior engineers working for four months will typically deliver more than seven people across five vendors working for the same period — because the integrated team spends its time building rather than coordinating.

The useful metric isn't hourly rate. It's delivered features per dollar, tracked against a fixed scope. That number almost always favours integration over specialisation once the product has more than two or three moving parts.

When specialisation makes sense

This isn't an argument against specialists. It's an argument against fragmenting ownership.

There are cases where a specialist vendor makes sense:

• One-off, well-defined deliverables with a clear interface (brand identity, security audit, legal review)
• Specialist capability that's genuinely scarce and genuinely needed (ML research, hardware design)
• Augmenting an existing integrated team with a specific skill for a sprint or two

The key distinction is whether the specialist needs to stay in sync with the rest of the product continuously, or whether they can hand off a deliverable and exit. Continuous sync is expensive; a clean handoff is not.

One team, clear ownership, shared context. It's less interesting to describe than a curated vendor portfolio, but it ships faster and breaks less.