I have been listening to a particular sentence in architecture reviews for about twenty-five years. It has changed clothes several times, but underneath it is always the same: they have an API, so integration is straightforward.
My standard response has become a slightly worn joke, but I have never found a better one. Having an API means you can now get to the problem much faster. It is accelerating to the scene of the accident.
Connection was never the difficult part. The difficult part is mediation — reconciling what each side means, guaranteeing that a message was received and can't later be denied, agreeing what happens when one party is down, and doing all of it in a way that survives an audit. That is the special sauce, and REST gave us none of it.
What makes this particularly frustrating is that we had solutions. I started my career at Perwill, working across BT EDI*Net, GNS Tradanet — later GXS — and the other value-added networks of the era. By the mid-nineties, EDI had answers to most of these problems. Then the industry discarded them, because they came wrapped in something genuinely awful, and spent two decades reinventing them one production incident at a time.
What EDI actually solved
Let me be clear that I am not nostalgic. EDIFACT and X12 are hostile formats. Onboarding a trading partner took months. The tooling was expensive and the networks charged by the kilocharacter. Nobody should want it back.
But look at what a trading partner agreement contained, and compare it to what a typical API integration contains today.
Agreed semantics, negotiated up front. Before a single message flowed, both parties agreed what each segment meant, which code lists applied, what was mandatory, and how to represent quantities and units. This was slow and tedious. It was also the only part that actually mattered, and it happened before anyone built anything.
Delivery guarantees separated from business meaning. A functional acknowledgement told you the message arrived and parsed. That is a different question from whether the receiving business accepted the order, and EDI kept the two strictly apart. Modern systems collapse them constantly — a 200 response means the HTTP request succeeded, which tells you approximately nothing about whether anything happened.
Non-repudiation. Signed receipts meant neither party could later claim they hadn't received a document. In a commercial relationship where money moves, this is not a nice-to-have. AS2 formalised it and it is still, quietly, how a great deal of retail trade moves.
An operational contract. Windows, volumes, retry behaviour, escalation. Both sides knew what to expect and what happened when expectations were missed.
Four hard problems, addressed as first-class concerns. The transport was almost incidental — and that was the point.
The trade we made
Then HTTP and JSON arrived, and the cost of connecting two systems collapsed. That was a genuine and enormous gain. I am not arguing otherwise.
But the four guarantees above had been bundled with the awful format, and when we threw out the format we threw out the bundle. Worse, we didn't notice, because the failure mode is delayed. A REST integration works beautifully in development, in staging, and for the first several months in production. The problems surface later, at volume, usually at a quarter end, usually to someone in finance.
Cheap connection didn't eliminate the hard problems. It relocated them — from a negotiation you have before you build, to an incident you have eighteen months afterwards.
Where it actually breaks
Semantics. This is the big one, and it is invisible until it isn't. Both systems have a quantity field. Both are integers. One means cases, one means individual units, and nobody wrote that down because the field names matched.
I have spent a large part of my career on exactly this. The same herbicide arriving as ROUNDUP PRO BIACTIVE 360 — 20L from one supplier and GLY 540 from another is not an API problem. Both suppliers have perfectly good APIs. The problem is that no one ever agreed what a product identity is, and an API specification has no place to record such an agreement. EDI at least had a code list.
Quality of service. Synchronous request/response quietly couples your availability to theirs. Their maintenance window is now your outage. Their rate limit is now your throughput ceiling. Their p99 latency is now inside your transaction. Nobody agreed to any of this; it arrived as a consequence of the integration style.
Evidence. Ask a modern integration to prove that a specific document was received on a specific date and could not have been altered afterwards. In most cases the honest answer is a log line, if the retention window hasn't rolled. EDI answered this in 1995 with a signed receipt.
Change. Trading partner agreements were versioned artefacts that both parties signed. API versioning is mostly a convention, honoured until someone ships a "non-breaking" change that breaks you. The difference isn't technical — both approaches can version — it's that one had a counterparty who had agreed to something.
What the mediation layer is for
This is the argument I made when I founded Adaptris in 1999, and I have not had cause to revise it much. The value in integration sits in the layer between the endpoints, and it does four things the endpoints cannot do for themselves.
It translates meaning, not just format. Format conversion is trivial and always was. Semantic mediation — canonical product identity, unit-of-measure normalisation, code list mapping, reference data that both sides resolve against — is where the work is. This is also, incidentally, where AI has just become genuinely useful, because entity resolution across messy real-world catalogues is a problem that resisted rules for thirty years.
It decouples availability. Durable queueing between systems means their outage is your delay rather than your outage. This is the oldest lesson in the field and it is still routinely ignored, because synchronous calls are easier to reason about right up until the moment they aren't.
It is where evidence lives. The endpoints record what they did. The mediation layer records what passed between them, when, in what state, and what happened next. When a regulator or an auditor asks, this is the only place that can answer.
It absorbs change. One party changes, one mapping changes, nobody else notices. Point-to-point integration means every change is negotiated N times.
None of this is fashionable. All of it is where the failures actually occur.
What I would actually do
Not "bring back EDI". Four things, none of which require anything old:
- Write the semantic agreement down, before you build. Not the OpenAPI spec — that describes shape, not meaning. What each field means, which code lists apply, what units, what nulls signify, who is authoritative when the two disagree. This is the single highest-return document in any integration and almost nobody writes it.
- Separate transport acknowledgement from business acceptance. Two events, two records. If your system cannot distinguish "received" from "accepted", it will eventually tell you a story that isn't true.
- Put something durable between the systems. A queue, a log, a broker. Whatever fits — but do not let your availability be the product of everyone else's.
- Decide what evidence you need while you can still capture it. If someone will ask in two years what was received and when, that requirement belongs in the design, not in a later archaeology project. You cannot retrofit evidence you never recorded.
Where I might be wrong
This sounds like an argument for heavyweight middleware. It could easily become one, and the ESB era produced plenty of centralised platforms that were worse than the fragmentation they replaced. My claim is about the four responsibilities, not about a particular product shape. They can live in a broker, in a library, in a well-disciplined pattern — but if nothing owns them, nothing is doing them.
Most integrations don't need this. Fair, and important. A read-only internal API serving a dashboard needs none of it. The four concerns earn their keep where money moves, where an audit is possible, or where a third party is involved. The failure I see is not teams skipping this — it is teams never asking which category they are in.
Event-driven architecture already solved it. Partly true, and modern event platforms do handle durability and decoupling well. But a schema registry enforces structure, not meaning, and an event log is evidence of what was published rather than what was agreed. The semantic and non-repudiation problems remain unsolved by default.
The pattern
What strikes me, looking back across EDI, ESB, SOA, iPaaS, microservices and now agentic systems, is how consistently we mistake the cheap part for the hard part. Each generation makes connection easier, declares integration solved, and then rediscovers semantics, delivery guarantees and evidence — usually the expensive way.
Agents are the current iteration, and they raise the stakes rather than changing the problem. An agent making autonomous decisions across three systems that disagree about what a customer is will make those decisions faster than any human ever could, and be entirely confident about all of them.
Everyone has an API. That has never been the question. The question is whether anything between them knows what the data means, guarantees it arrived, and can prove it later.