Retiring point-to-point integrations without a big-bang cutover

Point-to-point integration estates are rarely designed. They accumulate one reasonable project decision at a time, until every launch has to thread through links nobody fully understands. You can get out of that position without betting the institution on a single cutover weekend.

Why the big bang keeps failing

The appeal of a clean replacement is obvious: a new platform, one migration program, one cutover date. In a bank or a government entity it rarely holds up against real operating constraints.

Settlement windows, month-end, salary days and regulatory deadlines leave very few safe weekends. Undocumented behavior in old interfaces surfaces only when real traffic reaches the new platform. And a single cutover concentrates all of that risk into one night, with the whole institution watching.

The alternative is less dramatic and far more reliable: retire the estate in waves, with each wave proven against real traffic before the old path is switched off.

Start with an inventory you can trust

Rationalization starts with knowing what exists, and the documentation is almost always out of date. Build the inventory from what the estate actually does rather than from what the architecture diagrams say it does. Gateway and ESB configurations, MQ queue and channel definitions, file transfer jobs and schedulers, firewall rules, certificate stores and, above all, traffic logs tell you more than any document.

For each interface, capture at least:

  • source and target systems, and the business capability it serves;
  • transport and format: MQ, file, SOAP, REST, database link or proprietary;
  • volume, frequency and peak behavior;
  • business owner and technical owner, if they exist;
  • security: credentials, certificates and data classification;
  • incident history and the date of the last change;
  • whether anyone can explain what it does without reading the code.

Expect surprises. Most estates contain interfaces nobody calls anymore, several versions of the same "get customer" or "check balance" service, and at least one critical flow that depends on one person's memory.

Map dependencies and score the risk

Turn the inventory into a dependency map. Some systems will turn out to be hubs that dozens of interfaces pass through. Those are both your biggest risk and your biggest opportunity.

Then score each interface on the dimensions that matter to the business as well as to the architects:

  • Criticality: payments, regulatory reporting, customer-facing services.
  • Fragility: unsupported technology, incident history, single-person knowledge.
  • Change pressure: how often product teams need to change or extend it.
  • Duplication: how many other interfaces do the same job.

The result is a heat map that shows where the estate is costing you speed and where it is exposing you to risk. Those are often, but not always, the same places.

Decide what to rationalize, and what to leave alone

Every interface gets a disposition. Four are usually enough:

  • Retire: unused or redundant. Confirm it with traffic data, switch it off and keep the evidence.
  • Consolidate: several interfaces doing the same job, replaced by one shared service.
  • Rebuild as a reusable capability: high-change, high-reuse flows that become governed APIs or events.
  • Tolerate: stable, low-change links to systems that are themselves due for retirement. Leave them alone and spend the effort elsewhere.

Not everything should move. A program that tries to modernize every interface will run out of budget and patience long before it reaches the ones that matter.

Replace links with governed, reusable APIs and events

Point-to-point links should give way to a small set of capability-based services, such as customer, account, payment status and notifications, each owned by a team and designed for more than one consumer.

  • Design contract-first, with a published versioning and deprecation policy.
  • Use APIs for requests and events for state changes, so consumers subscribe once instead of polling several systems.
  • Enforce security, quotas and logging at the gateway rather than separately in each consumer.
  • Publish every service in a catalog, so teams find what exists before they build something new.

Reuse is what changes the economics. The first consumer of a governed customer API costs roughly what a point-to-point link would. The tenth should cost a fraction of that.

The strangler pattern, in practice

The strangler fig approach, described by Martin Fowler, replaces a legacy system gradually: new capability grows around the old one and takes over its behavior piece by piece, until the old system can be removed. In an integration estate it looks like this:

  1. Put a facade, usually the API gateway or integration layer, in front of the legacy interface, so consumers call a stable contract rather than the old system directly.
  2. Build the new implementation behind the facade.
  3. Prove it against reality: replay recorded production traffic, or run old and new in parallel and compare the outputs.
  4. Move consumers across one at a time, with a routing switch that can send traffic back quickly if something looks wrong.
  5. Decommission the old path, including its credentials, firewall rules and scheduled jobs.

The last step is the one programs skip. An interface that has been "migrated" but not switched off still carries cost and risk. Measure progress by interfaces retired rather than interfaces migrated.

A design authority that can say no

Without governance, a rationalized estate starts growing new point-to-point links within months. A design authority prevents that, provided it is small, senior and has the authority to say no.

Its job is simple to state. Every new integration request is checked against the catalog first. Standards for security, naming, versioning and observability are published and enforced. Exceptions are allowed, but each one has an owner and an expiry date. Every quarter it reports a few numbers: reuse rate, new exceptions granted, interfaces retired.

Done well, governance makes delivery faster. The second consumer of a governed service ships in days, because the hard decisions were made once.

Sequence the waves by value and risk

  • Start with high-reuse capabilities that unblock products already on the roadmap, so the business sees the benefit early.
  • Do not start with your most critical payment flow. Build the team's confidence and tooling on important but recoverable services first.
  • Ride the changes you have to make anyway. A core banking migration, a channel rebuild or a regulatory mandate such as open banking is the cheapest moment to move the interfaces it touches.
  • Plan around the calendar. Month-end, salary days, seasonal peaks and regulatory reporting dates are not migration windows.
  • Retire as you go. Each wave should end with old links switched off, not with two estates running side by side.

What a board-ready roadmap contains

A board does not need the interface list. It needs enough to make a funding decision and to hold the program to account:

  • Current-state facts: how many interfaces, how many duplicated, how many on unsupported technology, and where the risk concentrates
  • The target state on one page, described in business capabilities
  • Dispositions with numbers: what will be retired, consolidated, rebuilt and tolerated
  • Sequenced waves with dependencies, effort and cost ranges
  • Benefits with measures the business recognizes: time-to-market, incident volume, run cost
  • Key risks and how each is mitigated, including rollback
  • The governance model, and the specific decision the board is being asked to make

What it looks like when it works

At a leading Saudi bank, fragmented integrations meant every product launch rebuilt the same connectivity, slowly. The bank replaced them with reusable integration capabilities, governed APIs and shared services under a design authority. More than 100 point-to-point integrations were retired, and integration time-to-market fell by 70%.

This is the approach behind our modernization and migration and integration delivery services. An advisory estate assessment produces the inventory and the board-ready roadmap described above.

If your integration estate is slowing launches or concentrating risk, book an executive briefing. We will review what you know about your estate and give you a written view on where to start and what a first wave could retire.