Four vendors, one call, and a plan for when one of them dies

Nov 18, 2026Architecture Under Constraint5 min read

The question that decided the architecture of this system was asked by an operations director, not an engineer, and it was this: what happens to a new employee’s first morning if one of your suppliers has a bad day?

The only place the four services are one thing is in the experience of the person on the call.

The system runs a structured joining call. A new employee, a member of the HR team, and an AI that carries the scripted part of the conversation and answers questions. My team at Aditi built it for a staffing client this year.

Making it work involves four independent third-party services. A communication platform carrying audio and video, a voice service, a model doing the reasoning, and an avatar service rendering a face, which is optional and off unless HR switches it on. Four vendors, four billing relationships, four status pages, four ways for somebody’s first day to go wrong.

The honest answer to the operations director’s question is that all four will have a bad day eventually. So the architecture is mostly about which of those days the new employee is allowed to notice.

The obvious answer and why it is wrong

The tempting response to four suppliers is to find one that does all of it. Several vendors will sell you that, and the pitch is good: one integration, one bill, one support contact.

We did not, and the reasoning was not about capability.

A single supplier for a real-time experience means the failure modes are perfectly correlated. When they are down, everything is down, and there is no partial service to fall back to because every part of the call comes from the same place. You have swapped four small risks for one large one, and made the large one entirely someone else’s to fix.

There is also a slower problem. In a category moving this fast, the voice quality leader today is not the leader in eighteen months. A bundled stack means you upgrade all of it or none of it, and in practice that means none of it, because the migration is too big to justify for one component.

So four suppliers, deliberately, and the cost of that decision is paid in one place: the integration layer has to be honest about the fact that these things are separate.

The boring pattern that does the work

Every external service sits behind an interface owned by the application, not by the vendor. IAcsClient, IElevenLabsClient, IDIdClient, IOpenAiClient, IVectorStoreClient.

This is ports and adapters and there is nothing novel about it. I am including it because the interesting part is not the pattern, it is where we did and did not apply it, and the discipline that makes it worth anything.

The discipline is that the interface is shaped by what the application needs, not by what the SDK offers. It is very easy to write an interface that is a thin passthrough of a vendor’s API, complete with their vocabulary and their object model. That compiles, satisfies the letter of the pattern, and buys nothing, because the vendor’s concepts have leaked through the seam and out into the application. You find out on the day you try to swap it.

There is a concrete piece of evidence that this one was done properly. The vector store has two implementations behind the same interface: a self-hosted one and a managed cloud one. Both exist in the codebase, and one configuration setting chooses between them. That was not an academic exercise. Because the seam was real, changing which one runs in production was a setting rather than a project.

I would not claim we got this right everywhere. The seam around the media platform is thinner than the others, because real-time media has state that does not abstract cleanly, and pretending otherwise would have produced a worse interface, not a better one. Some things resist the pattern and it is better to notice than to force it.

Cost as an architectural property

Here is the detail I like most, because it is a business constraint that turned into a line of code.

The avatar is the most expensive component per minute and the least essential to the call. So it can be switched off mid-conversation, and the comment in the code says exactly what that means:

/// Flips the avatar on/off on an active OnboardingCall and pushes an AvatarToggled
/// SignalR event to the per-call group so both HR dashboard and joiner browser react.
/// D-ID billing stops the moment the joiner browser closes its WebRTC peer in response.

Billing stops when the browser drops the connection. Not when a flag is set server-side, not at the end of the call. The cost control is the client tearing down a peer connection, and the server-side toggle only exists to tell it to.

That is worth sitting with, because it is the kind of thing that separates a system somebody has run from one somebody has designed. If the toggle had only flipped a database column, the feature would have demonstrated correctly, looked right in review, and cost money for months before anyone reconciled an invoice.

The general form: when a component bills by the minute, the mechanism that stops the billing has to be the mechanism that stops the work, and you have to know which one that is.

Degrading in the right order

Four suppliers means ranking them by what their absence costs, and the ranking is not the same as the ranking by cost or by impressiveness.

The media channel is unrecoverable. If audio fails there is no call. Everything else is negotiable.

The voice is important but replaceable in the moment, because there is a human on the call who can talk.

The avatar is entirely optional. It is a warmth feature. Losing it makes the call plainer, not broken. Which is why it is the one with a toggle already built, for cost reasons, that doubles as the outage response.

The model is important but not urgent, because the scripted segments are content, not generation, so they run without it. When the model is not confident in an answer, the question is flagged to the human and the AI stays silent. The case where the model call itself fails is not handled yet: the joiner’s request errors, and HR can still type an answer by hand. That is a design intent still to build, and I would rather say so than present it as done.

That ranking is why the call assembles in the order it does, and why the whole system does not simply refuse to start when one supplier is unreachable. The failure mode we designed for is not “everything works or nothing does”. It is a call that gets progressively plainer as things go wrong, with the human on the line absorbing the difference, and the new employee experiencing something between a slightly less polished conversation and a normal video call with a colleague.

That is the actual answer to the operations director’s question. Not that it will not happen. That when it happens, the person having their first day gets a call that is less impressive rather than a call that does not happen.

What I would tell someone starting this

Count your correlated failures, not your integrations. Four vendors with independent outages is a better position than one vendor whose outage takes everything. The integration count is the visible cost and it is not the thing that matters.

Shape the interface around your application’s needs, not the SDK’s surface. The test is whether a second implementation is a configuration change or a project. If you have never written a second one, you do not yet know which you have.

Rank your dependencies by cost of absence. Not by price, not by how central they feel. Then make the assembly order and the degradation order follow that ranking.

For anything billed by the minute, find the mechanism that actually stops the meter. It is often further down the stack than the flag you added.

Accept that some things do not abstract. Real-time media state is one. A thin seam you understand beats a thick one that lies.

The four services do not know about each other. The only place they are one thing is in the experience of the person on the call, and keeping it that way is not a product feature you can buy.

Share this post