One lead developer, two agencies, and no CTO.

What you have probably noticed

Every missed date has two explanations, one from each agency, and they point at each other. The work that sits between the two systems, the part where one agency's output becomes the other's input, is late in a way nobody can quite pin down. Your lead developer is the only person who understands both sides, so he spends his week reviewing work he has no authority to reject, answering integration questions for both suppliers, and building the pieces neither agency will touch. The roadmap, if you can call it that, is two backlogs that do not add up to a plan. And the one meeting where both agencies are in the room ends with actions for your lead and none for them.

The tell is the blame. When something breaks at the join between the two systems, each supplier has a clean, honest account of why it is the other one's fault. Both accounts are usually true. That is the signal that you are not looking at a quality problem. You are looking at a role that does not exist.

What it actually means

You are asking one person to do three jobs with the authority to do none of them. He is the builder, the reviewer of two suppliers, and the integration point between them, and he was given none of those mandates on paper. Meanwhile the thing that is genuinely missing is ownership of the seam: the contract between the two systems, the order in which the two agencies ship, and the single roadmap that spans both. Each agency can be perfectly competent inside its own scope and the whole can still fail, because the join is nobody's scope.

That missing role is a CTO's. Not the part people picture, the architecture diagrams and the hiring. The unglamorous part: deciding who builds what, where the systems meet, and whose date moves when two of them collide. You do not have anyone doing that, so it defaults to the lead developer, who cannot tell an agency its scope was wrong because he does not own the contract, or to you, who cannot read the work well enough to adjudicate. This is the same gap the accidental software company runs into, arrived at from a different direction: not one system that grew too big to own, but two suppliers that grew too far apart to coordinate.

What to do about it, without firing your suppliers

The instinct is to collapse to one agency so there is one throat to choke. Sometimes that is right. More often it trades a coordination problem for a lock-in problem and costs a rebuild to get there. Try this order first.

1. Name one technical owner with a real mandate. One person owns the roadmap across both agencies and holds the authority to accept or reject either supplier's work. Often that person is already inside: the lead developer who understands both systems. Promote him, give him the title and the pay step, and take building off his plate so he can own instead of code. If he cannot step up or does not want the job, a fractional CTO holds the seat a few days a month while you decide, rather than leaving it empty.
2. Make the seam someone's explicit job. One roadmap, not two backlogs: a short list of what the combined system must do in the next two quarters and in what order the two agencies ship to get there. One architecture authority who decides the interface between the two systems and settles whose date moves when they collide. The owner above does this, or signs off on it. The seam stops being the place where work disappears once it is written down as somebody's responsibility.
3. Grade both agencies against outcomes, then decide. Someone has to read both contracts and both codebases in the same fortnight and say which supplier is actually delivering. Rewrite the scopes to pay for outcomes instead of named profiles and billed hours. Usually one agency is the problem and one is fine. You keep the one that delivers, hold the other to a rewritten scope, and replace only the supplier that still misses once the seam is owned and the scope is clear. That is a scalpel, not the rip-and-replace the first instinct reaches for. In one case I wrote up, the fix was one promotion and one renegotiated contract, not a new set of suppliers.

None of this requires a full-time hire or a new platform team. It requires a few days a month of oversight from someone who has owned software before, which is the shape of work the SME practice is built for. Most companies in this position are one promotion and one rewritten scope away from a roadmap they can actually read.

When this is fine, and when not to overcorrect

Two agencies is not automatically a problem. If one supplier clearly owns the whole stack, delivers against outcomes, and your lead developer has the authority and the time to grade the work, you have a structure, not a gap. Two suppliers with a clean interface and one owner over both is a normal, healthy setup. The problem is the ownership vacuum, not the vendor count.

The overcorrection cuts the other way, and it is expensive. An owner who has just felt this pain will sometimes hire a full-time CTO, stand up an internal team, and start pulling work back in-house for a problem that needed one owner and two rewritten contracts. A full-time interim CTO is the right call for a narrower case: delivery has already stopped, the internal lead is leaving, or a restructuring is coming and you want it run by someone without history in the building. For everything short of that, match the leadership to the gap. The gap here is ownership of the seam, and that is a few days a month, not a new hire and a rebuild.

Frequently asked

Written from patterns I've seen across engagements. If any of it sounds too specific to be general, that's why.