Signals
Integration Breakdown

Opaque dependencies reduce traceability and undermine end-to-end control frameworks.

Loss of visibility into how systems connect. Dependencies become opaque. Changes to one system produce unexpected effects in another because the connections are undocumented and unmonitored.

How it starts

Two systems are connected through a direct database query because the API was not ready. A file-based integration is built as a temporary measure and never replaced. A middleware layer accumulates transformation logic that was supposed to live in the consuming application. A vendor feed is consumed by three downstream systems, each of which applies its own parsing and normalization rules. The integration map grows organically, and no single person or document describes it completely.

What it looks like

Symptoms that indicate integration breakdown is active.

  • No one can produce a complete map of data flows from source to consumption.
  • Changes to upstream systems require impact analysis that takes days and still misses something.
  • Different consuming systems hold contradictory versions of the same source data.
  • Vendor transitions are prohibitively difficult because the integration surface area is unknown.
  • Incident investigation frequently reveals connections that the responding team did not know existed.

Why it matters

Opaque integrations are the primary vector for silent data corruption. Incorrect data propagates through unknown paths and arrives at decision-making systems without any control point having flagged it. Integration breakdown also creates severe vendor lock-in, the cost of switching a data source is not the vendor contract but the unknown web of downstream consumers that depend on the vendor's specific format, timing, and delivery mechanism.

How we address it

We map the actual integration topology, not the intended architecture, but what is running. From that map, we introduce explicit dependency declarations: every consumer declares what it needs, every producer declares what it provides, and the contracts between them are versioned and monitored. Integration points become observable surfaces rather than hidden wiring. This does not require replacing existing systems, it requires making their connections visible and controlled.

Where we've seen this

Integration breakdown was a defining characteristic of both the BatteryOS and ETRM infrastructure engagements. In both cases, the actual integration topology had diverged significantly from documented architecture, and no one could produce a complete map of data flows. Our Pipeline Integrity and Market Data mandates address this directly.