Request and response
APIs where the caller needs an answer, a decision or a consistent read within a bounded time.
Integration / Services
API, event-driven and enterprise integration architecture designed for clear ownership, evolution, security and operability.
Integration shapes the enterprise
Integration is architecture, not plumbing.
Poor integration creates coupling, duplicated logic, hidden dependencies and fragile change. Good integration establishes ownership, contracts and failure behaviour at every boundary.
The integration estate
Every interface is a commitment. Where it sits, who owns it and how it fails determines how easily the estate can change.
Choose the interaction deliberately
Each pattern fits different timing, consistency and failure requirements. Using one for everything is how estates become fragile.
APIs where the caller needs an answer, a decision or a consistent read within a bounded time.
Notification of something that has happened, where consumers decide what to do about it.
Directed work with explicit delivery expectations, where the sender needs the work performed.
High-volume, periodic exchange where timing and atomicity requirements suit it better than a live interface.
Long-running, multi-step processes with compensation, visibility and human steps where they belong.
Deliberate copying of data where read patterns or availability justify it, with ownership made explicit.
API and event decisions
| Theme | The decision | What it costs to leave it implicit |
|---|---|---|
| Contracts | What each interface guarantees, in terms consumers can rely on. | Every consumer is coupled to behaviour nobody has documented. |
| Versioning | How interfaces change while consumers migrate independently. | Deployments that must be coordinated across teams indefinitely. |
| Discovery | How the estate is found and understood by the teams that join it. | Duplicate capabilities built because nobody knew one existed. |
| Error semantics | What failures mean, what is retryable and what the caller should do. | Retry storms and silent data loss across interface boundaries. |
| Ownership | Who is accountable for each interface and its consumers. | Interfaces nobody can change and nobody will retire. |
Contracts and ownership are cheapest to establish at the first consumer, and most expensive to retrofit at the hundredth.
Operate the integration estate
Availability of the estate depends on how interfaces behave when their counterparts do not.
Visibility of which interfaces are degraded and what that means for the business journeys above them.
Standing visibility
Traceability across asynchronous boundaries where a single business action spans several systems.
End-to-end tracing
Dead-letter handling, quarantine and replay procedures that are exercised rather than assumed.
Recovery procedures
A defined period of support for each interface version and a credible retirement process.
Lifecycle policy
Change assessed against the consumers it affects, including the ones nobody has spoken to.
Change assessment
Modernise without a big-bang rewrite
Legacy interfaces can be encapsulated before they are replaced.
We create contracts around existing behaviour, migrate consumers incrementally and retire point-to-point integrations only once evidence shows they are unused. The estate changes while continuing to operate.
Engagement enquiries
Describe the systems that must work together, the change that is difficult today and who owns each boundary. That is usually enough to identify the architectural problem.
Useful links
No middleware product is recommended before the interfaces and their ownership are understood.