Replacing 60 point-to-point interfaces with one API layer

The manufacturer ran eleven plants across four countries. Each had been integrated into the group ERP at a different time, by a different team or vendor, using whatever approach suited that project. The result was more than sixty point-to-point interfaces — a mix of flat file drops, database links, middleware jobs, and a few scripts nobody could account for.

Nothing was documented end to end. When a production figure looked wrong, tracing it back through the chain took days, and the answer was often that a scheduled job had failed silently three steps upstream.

Because most interfaces ran on overnight batch, the ERP view of production was always at least a day behind reality. Planning worked from yesterday’s numbers, which showed up as excess buffer stock at every plant and as expedited freight whenever the buffer was wrong.

Connecting a new system was quoted at three to four months, almost all of it spent working out what the existing interfaces did before anything new could be safely added. Two plants had solved this by keeping their own local spreadsheets, which is how a group with one ERP ended up with several versions of the truth.

A single vendor platform had been evaluated to replace everything. It was rejected on cost and on the fact that three of the eleven plants ran equipment old enough that no modern connector existed for it.

The objectives: give every plant one integration pattern, move production data from overnight batch to near real time, make every interface observable and documented, cut the time to connect a new system, and do it without replacing the ERP or the plant systems themselves.

The design principle was that systems should integrate with a contract, not with each other. A governed API and event layer was introduced between the plants and the group systems, and every new connection went through it. Existing interfaces were then migrated onto it plant by plant.

The first work was cataloguing. Every interface was traced, its actual behaviour recorded rather than its documented behaviour, and its data mapped to a canonical model. Eleven of the sixty turned out to be moving data nobody consumed any more and were simply switched off.

A canonical domain model was agreed for the concepts that cross system boundaries — work order, material, batch, machine event, quality result. Plant systems continued to use their own internal representations; translation happens once, at the boundary, instead of being reimplemented in every interface.

Synchronous APIs were used where a caller needs an answer, and events where a system needs to announce that something happened. Shop-floor machine events and production confirmations moved to the event stream, which is what removed the overnight batch dependency.

For the three plants with older equipment, a lightweight edge gateway was deployed on-site. It speaks the legacy protocols locally, buffers when the network link drops — which it does — and publishes normalised events upstream. No plant equipment was modified.

Governance came with it: an interface registry, published schemas with versioning rules, ownership assigned per interface, and automated contract tests that fail a deployment when a producer breaks a consumer. That is what prevents the estate from silently returning to sixty bespoke interfaces.