Why \

By Aaron Gammon · Founder, Inferrex · June 2026

This is the philosophical inversion underneath my pillar piece on comprehension over connection, pulled out and looked at on its own, because I think it's the part people find genuinely counter-intuitive. The whole industry's instinct is toward standardisation — get everyone speaking the same schema. I think that instinct, applied to integration, is precisely backwards, and I want to make the case for why.

Where this touches what Inferrex does, I keep to outcomes. Live figures at inferrex.com/claims.

The standard answer to "how do we make all these systems work together" is: pick a canonical schema and make everyone conform to it. Define the One True customer record, the One True invoice, and require every system to map into it. Standardise the difference away.

It feels right because tidiness feels right. One schema to rule them all is comprehensible, governable, clean. You can draw it on a whiteboard and feel in control. And in a small, stable, closed world — a handful of systems you fully own, that never change — it even works for a while.

The trouble is that this instinct is borrowed from a place it doesn't belong. Inside a single system you build from scratch, you should impose a schema; consistency is a virtue when you control everything. But integration is the opposite situation by definition: you're joining systems you didn't build, that you don't control, built by people who made different choices for good reasons. Importing the "everyone conform" instinct into that world is the original sin of integration.

Conformity breaks at the first contact with a system that won't, or can't, conform — and there is always such a system.

It's the legacy platform nobody can change because it's load-bearing and the people who understood it have left. It's the third-party SaaS whose schema you have no power over whatsoever. It's the partner's system, the acquired company's stack, the regulator-mandated format, the vendor who renamed a field last Tuesday. Every one of these is a system that will not bend to your canonical schema, and each one turns "make everyone conform" from a tidy principle into a list of exceptions, special cases, and brittle adapters bolted on to force conformity that the system itself resists.

And here's the deeper failure: even when you do force everyone into one schema, you've created a single rigid point that everything depends on, so the moment any one system changes, the conformity breaks and the breakage propagates. You didn't eliminate difference. You papered over it, and made the paper load-bearing. Conformity doesn't remove the heterogeneity of the real world; it just pretends the heterogeneity isn't there until reality reasserts itself, usually at the worst moment.

So here's the move, and it is genuinely an inversion of the standard instinct: don't make anyone conform. Adapt to the difference instead.

Nobody chose to be different to be difficult. A fishing village develops thirty words for waves and a mountain people a dozen for snow because each adapted perfectly to its own reality — and every software vendor that shaped "customer" to fit its own model did exactly the same thing. The difference isn't a defect to be corrected. It's the natural, correct result of each system adapting to its own context. Treating it as a defect — as something to be standardised away — is fighting the nature of the situation.

The model that survives is the one that accepts difference as permanent and builds around it: a layer that understands what each system means in its own terms, and reconciles those meanings without demanding that any system rename, restructure, or migrate anything. Everyone keeps speaking their own dialect. The layer above understands all the dialects and lets them communicate. No conformity required, because comprehension makes conformity unnecessary.

Adapting to difference instead of abolishing it sounds lovely, but it was, until recently, impossible — which is why the industry defaulted to conformity. You can't adapt to a thousand different schemas by hand; the only tractable option, with human effort, was to force everyone onto one and absorb the exceptions as pain. Conformity wasn't chosen because it was right. It was chosen because adaptation didn't scale.

What changed is that a system can now comprehend a schema — read it, understand what each field means in its own context, and reconcile it to shared meaning automatically. Once understanding is cheap, the calculus flips. You no longer need everyone to speak the same language, because the layer can understand every language. Difference stops being expensive. And the moment difference stops being expensive, conformity stops being worth its cost — all it was ever buying you was tractability, and comprehension buys you that without the brittleness. This is the same engine I describe in the lingua-franca piece: a shared understanding above the dialects, not a single dialect imposed on everyone.

Step back and it's almost a law. Reality is heterogeneous. Systems differ, will keep differing, and the rate of new difference — new vendors, new versions, new formats — only increases. Any integration model that requires the world to become uniform is fighting a tide that never goes out. It can win locally and briefly, in a small closed system, but at scale and over time it loses, because the exceptions accumulate faster than you can absorb them and the rigid centre cracks under the first real change.

A model that adapts to difference has no such fight. It doesn't need the world to hold still or become uniform; new difference is just more for the comprehension layer to understand, which it does as a matter of course. It gets stronger as it meets more variety, where the conformity model gets more brittle. One model is at war with the nature of reality. The other is aligned with it. Over a long enough horizon, the aligned one always wins — not because it's cleverer, but because it stopped fighting the tide.

I called this an inversion because that's how it lands against the standardise-everything instinct most people bring to integration. But I'd argue it's actually the un-inversion — it's putting things back the right way up. The conformity model was the unnatural one all along: a workaround for the fact that, historically, understanding difference was too expensive to do at scale. We mistook the workaround for the principle.

Let everyone be different. Build the layer that understands the difference. That's not a compromise with reality — it's the only model that was ever actually aligned with it.