System Type: Enterprise Integration

Patterns, failure modes, and anti-patterns for connecting, modernizing, and orchestrating enterprise systems.

1. Integration Patterns

Enterprise integration is the art of making systems talk to each other when they were never designed to. Every pattern trades coupling for something — throughput, consistency, simplicity, or debuggability. The right choice depends on what you can afford to lose.

The Topology Spectrum

Synchronous vs Asynchronous

Synchronous (request/reply). System A calls System B and waits for a response. The caller's latency includes the callee's latency. The caller's availability depends on the callee's availability.

When it's right:

• The caller genuinely cannot proceed without the response (validate payment before confirming order).
• Latency requirements are well understood and the callee can meet them.
• The dependency graph is shallow (A calls B, not A calls B calls C calls D).

When it creates coupling nightmares:

• Deep call chains. If A→B→C→D, A's p99 latency is the sum of B, C, and D's p99 latencies, and A's availability is the product of their availabilities.
• Retry storms. If B is slow, A retries. B is slow because C is slow. Now A and B are both retrying against C, making C slower. This is a distributed system death spiral.
• Temporal coupling. Both systems must be running simultaneously. Maintenance windows become a coordination problem across every system in the chain.

Asynchronous (fire-and-forget / event-driven). System A publishes a message or event and moves on. System B processes it whenever it can.

When it's right:

• The caller doesn't need an immediate response (order placed → fulfillment can happen later).
• You need to absorb load spikes (queue buffers the burst).
• You want temporal decoupling (System B can be down for maintenance without affecting System A).
• Multiple consumers need to react to the same event.

When it creates coupling nightmares:

• When you need the illusion of synchronous behavior built on async primitives. If the user is staring at a spinner waiting for 6 async hops to complete, you've built a slow synchronous system with worse debuggability.
• When ordering matters and you haven't designed for it. Messages arrive out of order. Events get replayed. Idempotency isn't optional — it's a survival requirement.

…