Architecture

Integration patterns for connecting business systems

Most integration problems are variations on a few known patterns. Choosing deliberately avoids inventing a worse version.

Key takeaways

  • Point-to-point integration stops scaling sooner than expected.
  • Choose a known pattern rather than inventing one.
  • Timeouts, backoff and circuit breakers belong at every boundary.
  • Define a system of record per entity and reconcile regularly.

Point-to-point works until it does not

Direct connections between two systems are simple and appropriate for a small number of integrations. The difficulty is combinatorial: each new system multiplies the connections, and eventually nobody can describe the estate.

The threshold is usually reached sooner than expected, and the resulting tangle is expensive to unpick.

The main patterns

  • Message queue — asynchronous, buffered, tolerant of a consumer being down.
  • Publish-subscribe — one event, many independent consumers.
  • API gateway — one entry point handling auth, rate limiting and routing.
  • File transfer — unglamorous, still correct for large scheduled batches.
  • Shared database — usually a mistake, because it couples systems at the deepest level.

Design for failure at every boundary

Any integration will be unavailable at some point. Every boundary needs timeouts, bounded retries with backoff, and defined behaviour when the other side is down.

Circuit breakers prevent a slow dependency exhausting your own resources, which is how one system's problem becomes everyone's outage.

Data ownership and reconciliation

Define one system of record per entity. Where data is duplicated for performance, be explicit about which copy is authoritative and how discrepancies are resolved.

Build reconciliation reporting from the start. Discrepancies between systems are inevitable, and finding them through a customer complaint is the expensive route.

Monitoring integrations end to end

Integrations fail silently more often than loudly. A queue consumer stops, a scheduled transfer does not run, a webhook endpoint returns errors nobody sees, and the discovery is a business user asking why data is missing.

Monitor throughput and lag on every integration, alert on absence as well as on error — a feed that normally delivers hourly and delivers nothing is a failure — and reconcile record counts between systems regularly.

Absence monitoring is the part most often missing, and it catches the failure mode that causes the most business disruption.


Frequently asked questions

At a certain number of integrations, centralised tooling for routing, transformation and monitoring pays for itself. Below that it is overhead.

Rarely, and mainly as a transitional step during modernisation. It couples systems so tightly that neither can change its schema independently.

Transform at the boundary rather than spreading knowledge of another system's format through your codebase. One place to change when the other side changes.

Working on this?

A conversation with our team, no charge and no obligation.

Book a conversation