Integration, interoperability, and coupling decisions

25 min read 6 outcomes 1 interactive tool 4 standards cited

Integration design is an enterprise-architecture concern, not just an implementation detail, because the way applications connect determines how the enterprise behaves when systems fail. The decision criteria from C220 Part 3 distinguish architectural reasoning from ad hoc plumbing.

By the end of this module you will be able to:

  • Explain why integration design is an enterprise-architecture concern rather than just an implementation concern
  • Use interoperability, coupling, latency, and failure-handling language precisely when discussing application interactions
  • Describe the TOGAF interoperability framework from C220 Part 3 and its four levels
  • Explain coupling decisions and the trade-offs between tight and loose coupling in enterprise contexts
  • Describe what a good integration decision record should capture
  • Apply integration trade-off thinking to London planning, telemetry, publication, and governance flows
Roadmap and systems image suggesting application interactions being designed with enterprise consequences in mind

Real-world case · 2023

The pipeline worked until it mattered most.

A gas distribution company built a real-time telemetry pipeline in 2023 that fed pressure readings from field sensors into a central analytics platform. The pipeline worked well in normal conditions. During a supply interruption event, the analytics platform went offline for maintenance.

Because the pipeline used synchronous point-to-point calls, the field-sensor data had nowhere to go. The readings were lost for a ninety-minute window that happened to coincide with the period the incident-investigation team most needed to understand.

The technical team had chosen the simplest integration pattern available. Nobody had asked what happens to the data if the receiving system is unavailable. Nobody had considered the failure-mode consequence at enterprise level. The integration worked until it mattered most.

If a telemetry pipeline loses ninety minutes of sensor readings during a supply interruption because nobody asked what happens when the receiving system goes offline, is that a technical failure or an architecture failure?

That story illustrates why integration is an architecture problem, not just a plumbing problem. The pattern chosen for a connection shapes how failures propagate, how quickly information moves, how tightly systems depend on one another, and how difficult future change becomes.

34.1 Why integration belongs in architecture

Applications can exchange information in many ways, but not all of those ways create the same enterprise consequences. Integration style shapes how tightly systems depend on one another, how failures spread, how quickly information becomes visible, and how difficult future change becomes.

C220 Part 3 (ADM Techniques) positions integration as an architecture concern because the cumulative effect of individual integration decisions shapes the enterprise's overall changeability, resilience, and cost of ownership. A single badly chosen integration pattern may be harmless. Seventy-two badly chosen patterns create a fragile web that makes every change programme expensive.

Interoperability defines the ability of two or more systems or components to exchange information and to use the information that has been exchanged. The TOGAF Standard identifies four levels of interoperability that architecture should address.

TOGAF Standard, 10th Edition - C220 Part 3, Interoperability

Interoperability is broader than format compatibility. It includes semantic alignment, process coordination, and the ability of participating systems to act on the exchanged information in a consistent way.

34.2 The four levels of interoperability from C220 Part 3

TOGAF defines four levels of interoperability that the architecture should consider for each integration. Each level addresses a different aspect of the exchange.

  1. Operational interoperability. Can the systems physically connect and exchange data? This is the most basic level, covering network connectivity, protocol compatibility, and transport mechanisms. Most modern systems meet this level, but it is not sufficient on its own.
  2. Semantic interoperability. Do both systems understand the exchanged information in the same way? This level addresses shared data definitions, units, formats, and business meaning. Semantic interoperability is where most enterprise integration problems actually lie. Two systems can exchange data successfully at the operational level while interpreting it differently at the semantic level.
  3. Syntactic interoperability. Are the data structures and formats compatible? This level covers message formats, schema alignment, and encoding rules. CIM alignment (Module 30) supports syntactic interoperability for power-systems data.
  4. Organisational interoperability. Do the participating organisations or teams share enough governance, process, and policy alignment to act consistently on the exchanged information? This is the highest level and often the hardest to achieve. It requires not just technical alignment but also agreement on governance, timing, and accountability.

The architecture should specify which level of interoperability each integration requires and justify why. Not every integration needs organisational interoperability. Some need only operational connectivity. The decision should be explicit and recorded.

Loading interactive component...

34.3 Coupling decisions and their trade-offs

Coupling describes how tightly two systems depend on each other's structures, timings, or failure modes. The coupling decision is an architecture choice with enterprise consequences.

Tight coupling means a change or failure in one system directly affects the other. Synchronous point-to-point calls are the most common form. Tight coupling is simpler to implement but creates dependency: if the receiver is unavailable, the sender is blocked. The telemetry pipeline in the opening story used tight coupling and lost data when the receiver went down.

Loose couplingmeans the systems can operate independently of each other's timing and availability. Asynchronous messaging, event-driven patterns, and buffered exchanges are common forms. Loose coupling absorbs more change and failure but may introduce latency, complexity, and ordering challenges.

The right coupling choice depends on the enterprise context, not on technical preference. Four factors should inform the decision:

  • Failure consequence. What happens if the connection fails? If data loss is acceptable, tight coupling may be fine. If data loss has safety or regulatory consequences, loose coupling with buffering is usually necessary.
  • Change frequency. How often will the participating systems change? If one system changes frequently, loose coupling reduces the impact on the other.
  • Latency requirement. How quickly must information move? Some flows need sub-second delivery. Others are perfectly served by nightly batches.
  • Governance accountability. Who owns the interface and who is responsible when the exchange fails or produces inconsistent results?

Integration coupling on two axes: synchrony and contract strength

The grid encodes the two integration decisions on the X and Y axes. Each quadrant names the combination and shows what it gains and what it sacrifices.

Tight synchronous coupling is fast but fragile; loose asynchronous coupling is resilient but adds delivery semantics. The decision is what the use case can tolerate, not what the team prefers to build.

Integration coupling on two axes: synchrony and contract strength A two-by-two matrix of integration coupling on two blue axis rails: a vertical Synchrony rail, asynchronous to synchronous, and a horizontal Contract strength rail, loose to strong, along the bottom. Each quadrant names one combination, marked green for what it gains and amber for what it sacrifices. Synchronous plus loose is REST polling: simple, but with latency. Synchronous plus strong, marked in red, is RPC or gRPC: fast with a clear contract, but the tightest coupling. Asynchronous plus loose is an event bus with no schema: decoupled, but unsafe. Asynchronous plus strong adds a schema registry: resilient and safe, but delivery semantics to manage. The choice belongs to the use case. Synchrony: async to sync Contract strength: loose to strong Synchronous, loose REST polling Simple to build and reason about Latency and wasted calls Synchronous, strong RPC, gRPC Fast, with a clear contract Tightest coupling on the board Asynchronous, loose Event bus, no schema Fully decoupled producers No safety on the payload Asynchronous, strong Event bus and registry Resilient and schema-safe Delivery semantics to manage What the combination gainsWhat it sacrifices Sync and strong is the tightest coupling.RPC is fast and clear, but it binds caller to callee. Choose it only when the use case truly cannottolerate delay.
Roadmap and systems image suggesting application interactions designed with enterprise consequences in mind
Integration design affects enterprise changeability, trust, and resilience. The best connection is the one that best fits the enterprise context, not merely the one easiest to build today.

34.4 What a good integration decision record should contain

An integration decision record that supports governance and future review should capture five elements.

  1. The business or operational purpose of the connection. Why does this integration exist? Which decision or process depends on it?
  2. The interoperability level required. Which of the four C220 Part 3 levels does this integration need, and why?
  3. The information authority and semantic assumptions that travel across it. Which system is authoritative for the information being exchanged? What authority rules from Module 28 apply?
  4. The chosen integration pattern and the main alternatives considered. The record should show deliberate evaluation, not just the first pattern that worked. The coupling choice (tight or loose) should be stated with rationale.
  5. The consequences for latency, failure handling, coupling, and governance. What happens if the connection fails? Who is accountable? How does this integration contribute to or mitigate the enterprise's overall dependency risk?

An integration decision record that explains the mechanism but not the enterprise consequence is still incomplete. The point of the record is to make the trade-offs visible enough to govern.

Common misconception

Integration is a purely technical implementation concern that does not need architecture attention.

Treating integration as purely technical means the enterprise only discovers the architectural consequences when a failure, a change programme, or a publication challenge exposes the hidden coupling and dependency risks.

An integration option moves through five states, each adding one decision

Proposed, evaluated, prototyped, approved, chosen: an integration option is a state machine. Each transition records one architecture decision, so every option stays visible at its current state.

The entry state raises the option; the terminal state commits it as the path to build. A jumped state shows up later as integration debt, because the decision it would have recorded is simply missing.

An integration option moves through five states, each adding one decision Five state panels in a left-to-right row under the heading Integration option lifecycle, joined by blue transition arrows. State 1 Proposed, emphasised in red, raises the option. An arrow labelled scored leads to State 2 Evaluated, scored on sync, contract and semantics. An arrow labelled spiked leads to State 3 Prototyped, confirming feasibility. An arrow labelled reviewed leads to State 4 Approved, accepted by the board as a candidate. An arrow labelled selected leads to State 5 Chosen, emphasised in red, committed as the path to build. Each panel names its owner and adds a decision. A red note warns that a jumped state becomes integration debt as the missing decision surfaces as rework. Integration option lifecycle 1ProposedOption raisedfor reviewOwnerArchitectAdds 1 decision 2EvaluatedScored on sync,contract, semanticsOwnerArchitectAdds 1 decision 3PrototypedSpike confirmsfeasibilityOwnerEngineeringAdds 1 decision 4ApprovedAccepted asa candidateOwnerArch boardAdds 1 decision 5ChosenCommitted as thepath to buildOwnerArchitectAdds 1 decision scored spiked reviewed selected A jumped state becomes integration debt.Skip a transition and the decision it would have recorded is missing, so the gap surfaces later as rework on the live integration.

London Grid Distribution

The London case needs planning, operations, telemetry, publication, and governance flows to interact without letting one application boundary dominate the whole enterprise story. Each flow has different interoperability and coupling needs.

  • Telemetry flows need loose coupling with buffering because data loss during operational events has safety and regulatory consequences. The interoperability level is at least semantic (both sides must agree on what the readings mean).
  • Planning-to-publication flows need semantic and organisational interoperability because the published output must be interpretable by external consumers. CIM alignment supports syntactic interoperability at this boundary.
  • Governance reporting flows can tolerate batch latency but need strong semantic consistency to prevent different reports from contradicting each other.
  • Authority, latency, and coupling should all be visible in the London integration map within the Phase C pack.
  • A technically possible interface can still be an architecturally weak choice if it creates unacceptable failure propagation, coupling, or governance gaps.
Check your understanding

A telemetry pipeline uses synchronous point-to-point calls between field sensors and an analytics platform. During a maintenance window, the analytics platform goes offline and ninety minutes of sensor readings are lost. What integration criterion was most likely neglected?

C220 Part 3 defines four levels of interoperability. Two systems can exchange data files successfully but interpret the same field differently. Which interoperability level is failing?

An enterprise has seventy-two point-to-point integrations, each designed independently. A change programme needs to replace one core system. The impact assessment reveals that thirty-one integrations must be modified. Why is the assessment so expensive?

Key takeaways

  • Integration design affects enterprise changeability, trust, and resilience. It is an architecture concern, not just a plumbing concern.
  • C220 Part 3 defines four interoperability levels: operational, semantic, syntactic, and organisational. Each integration should specify which level it requires.
  • Coupling decisions (tight vs. loose) carry enterprise consequences for failure propagation, change cost, and governance accountability.
  • Interoperability and coupling should be discussed explicitly, not implied.
  • A good integration record explains purpose, interoperability level, authority, pattern choice, and enterprise consequences.
  • Different London flows need different interoperability levels and coupling choices. A uniform approach across all flows is unlikely to be the right answer.

Standards and sources cited in this module

  1. The TOGAF Standard, 10th Edition (C220)

    Part 3, Interoperability

    Core standard for the four interoperability levels and integration architecture techniques.

  2. The TOGAF Standard, 10th Edition (C220)

    Part 2, ADM Techniques

    Provides integration and trade-off techniques that inform coupling and failure-handling decisions.

  3. G190, Information Mapping

    Full guide

    Provides the information-domain context that integration decisions must respect.

  4. G248, Selecting Building Blocks

    Full guide

    Connects integration decisions to the ABB and SBB discipline for application architecture.

You now understand integration as an enterprise-architecture concern with four interoperability levels and explicit coupling trade-offs. The next question is: how do all the Phase C concepts come together in the London LTDS and CIM information architecture walkthrough? That is Module 35.

Module 34 of 64 · Information Systems Architecture