Back to all articles
The Shared PlatformPart 02
Partner integrationsAPIsAcquisitionsContract testing

The Shared Platform, Part 2: Keeping Partner Integrations Stable After an Acquisition

Janahan Thavendran4 min read

TL;DR

  • After an acquisition, partners depend on behaviour, including limits nobody documented, such as one order at a time or a batch job that always ran in their quiet hours.
  • Keep the old endpoints alive behind a facade, and write contract tests for fields, error codes, event order, concurrency and timing.
  • Run deprecation as a 12 to 24 month programme with a sandbox and a reason that matters to partners, and give both merged teams one shared partner measure.
In this article

The Shared Platform, Part 2 of 7 · What partners depend on when the company behind the API changes.

The platform I worked on connected to more than 50 partners through one middleware layer. Banks, wallets and local apps pulled merchant catalogs from it and sent orders back through it. The OCBC Bank app and Google Pay in Singapore were two of them. Each partner had built against our API, tested it, and moved on to other work.

Then the platform was acquired by a much larger group.

From the inside, an acquisition is a long list of things to merge: two API gateways, two auth models, two ways of doing almost everything. From a partner's side, there is one question. Will my integration still work on Monday?

Partners integrate with behaviour, not your org chart

Partners don't care which company owns the backend. They care that the endpoint they call returns what it returned yesterday, at the speed it returned it, with the same errors.

Some of that behaviour is written down. Much of it isn't. Some of our partners couldn't accept concurrent orders, so we sent their orders through queues. That limit appeared in no API spec. But if a merged backend started sending those partners orders in parallel, their side would break, and they would rightly call it our outage.

Timing is part of the contract too. Picture the merged infrastructure moving from Singapore to a European region. A batch job that syncs merchant catalogs to partners has always run at 2 a.m. Singapore time, when nothing else is happening. After the move, nobody touches the job, but its clock is now European. 2 a.m. in Frankfurt is 9 a.m. in Singapore, just as partners start taking the day's first orders. Their systems get flooded with catalog updates at the worst possible moment, and orders start timing out.

No endpoint changed, and no field was renamed. Every API test would still pass.

So the first job after an acquisition is to write down the contract you actually have, not the one in the docs.

Put a facade in front of the merge

Don't ask partners to move to a new API on day one. Keep the old endpoints alive, behaving exactly as they did, and route them internally to whatever the merged backend becomes. This is the strangler fig pattern: the facade stays still while the system behind it is replaced piece by piece.

The facade buys you time to do the merge properly. Without it, every internal decision becomes a partner-facing change, and every partner-facing change becomes a negotiation.

Test the contract, not just the code

Treat each partner API as a contract. Automated contract tests should fail the build when a backend change alters anything a partner relies on: a field name, a type, an error code, the order of events.

The tests that matter most cover the behaviour nobody documented. If a partner can only handle one order at a time, test that. If a partner still reads a field you think is unused, test that too. If a batch job has always landed in a partner's quiet hours, pin it to their timezone and check it after every infrastructure move. These are the breakages that reach production, because nobody thought to check them.

Make deprecation a programme, not an email

You will want to retire the old APIs eventually. Give partners 12 to 24 months, a sandbox where they can test the new API against realistic data, clear migration docs, and a reason to move that matters to them, not just to you. That means a capability they've been asking for, not "we're consolidating our stack."

Then track migration partner by partner. The last few partners usually take longer than all the others combined, and they are often the ones with the most volume.

Give both teams the same scoreboard

After an acquisition, the two engineering teams usually have different goals. One is measured on finishing the migration, the other on not breaking anything. Give them one shared measure: partner integrations still working, and partners still transacting. A merge that finishes on time while partners quietly stop sending orders hasn't succeeded.

What partners are trusting

Partners didn't sign up with the company that acquired you. They signed up with the API they built against.

An acquisition can change everything about your company in a day. What partners depend on should change only when each of them is ready to move.