Every Connection Is Handmade

The integration that works today breaks tomorrow. Not because you built it wrong. Because you had to build it at all.

Here's what happens. A billing system needs to talk to an insurance processor. They don't speak the same language. Different field names, different formats, different rules for what counts as a valid record. So someone builds a translator. A piece of code that sits between them, reads from one side, rewrites it for the other. It works. Claims flow. Data lands where it should. And the person who built it moves on to the next thing.

The Break

Then the billing system updates. A field that used to be called "provider_id" is now "practitioner_reference." The translator doesn't know. It's still looking for the old name. Claims stop. Somewhere downstream, a queue fills up. An alert fires. Someone gets a call at two in the morning.

That person has to understand both systems. Not one. Both. They have to know what the billing side changed, what the insurance side expects, and how the translator mapped one to the other. They find the renamed field. They fix the mapping. Claims flow again.

Two months later, the insurance side updates their validation rules. Same translator breaks. Same person gets the call.

The Multiply

That's one connection. One translator between two systems.

Now multiply. A hospital connects to five insurance companies, three payment processors, two pharmacy networks, a lab system, and a state reporting database. Each connection is its own translator. Each translator was built by someone who understood both sides at the time. Each one is a single point of failure. And each one breaks on its own schedule.

I've been the person who gets that call. You probably have too. And the thing you learn after the third or fourth time is this: it doesn't matter how well you built it. The translator is a bet that neither side will change. That bet always loses.

The Root

The root cause isn't bad engineering. The root cause is that every connection is custom. Each system defines its own structure — its own field names, its own nesting, its own rules for what a valid record looks like. So every crossing between two systems requires a bespoke translator that knows both vocabularies.

You didn't build an integration. You adopted a dependency.

A dependency on two systems staying exactly the way they were when you wrote the mapping. And the moment either side moves, your translator is out of date. Not broken by a bug. Broken by design.

The Structure

But there's an alternative to the handmade model. If every system used the same keys, the same shape, the same structural rules — you wouldn't need a translator at all. A claim, a payment, a lab result: if they all followed the same grammar, any system could read any other system's output without a custom bridge in between.

The translator exists because the structure doesn't agree. Make the structure agree, and the translator disappears. Not because someone automated it. Because there's nothing left to translate.

Same keys. Same shape. Same rules. No translator needed.