Semantic Coupling

Event-driven architectures are described as loosely coupled, and they move the coupling rather than removing it. Subscribers depend on two things: the event's shape, which tooling can check, and the event's meaning, which nothing checks.

When a producer changes what an event means while its structure stays identical — "order confirmed" now firing at a different point in the lifecycle, a status value reused for a new case, a field's units changed — nothing breaks, no schema check fails, and consumer behaviour quietly diverges.

Why it matters

It is the failure mode with the worst detection profile: silent at the time, discovered later as inconsistent data or an inexplicable business outcome, and traced back only with difficulty because there is no error to correlate.

It also worsens with scale. Each additional consumer adds a party depending on a meaning that was never written down, and the producer has no way to know who would be affected by a change.

Implementation patterns

• A published schema with a compatibility policy, which handles the shape half — additive changes only, unknown fields ignored, unknown enum values defaulted.
• Documented semantics for every event and every field: exactly when it fires, what each status value means, units, timezone, and what it does not mean. The negative statements are the valuable ones.
• A consumer registry. Without knowing who consumes what, a producer cannot assess a change, and the practical consequence is that nothing is ever changed — which is the coupling the architecture was adopted to avoid, in a less visible form.
• A new event rather than a redefined one. If the meaning must change, emit a new event type and deprecate the old one with a notice period. Redefining an existing event is the specific act that causes this failure.
• Contract tests where consumers are internal, expressing what each consumer relies on so a producer's build fails when it breaks one.
• Reconciliation against the producer's own state, which is the only mechanism that detects a divergence nothing else can see.

Industry example

Streaming platforms such as Confluent's and event-routing platforms such as Segment make the shape half easy — schema registries, compatibility modes — and the meaning half remains an organisational discipline. The platforms that stay changeable are the ones with a consumer registry and documented semantics, not the ones with the strictest schema enforcement.

Failure scenarios

• An event's firing point moved, so downstream systems act at the wrong moment.
• A status value reused for a new case that consumers interpret as the old one.
• Units or timezone changed, which is arithmetic that still works and is wrong.
• A field that was always populated becoming optional, which passes every schema check.
• No consumer registry, so a producer cannot change anything safely and therefore does not.

Trade-offs

Documenting semantics and maintaining a consumer registry is real ongoing work with no visible payoff until a change is needed, and it is the first thing dropped under delivery pressure.

The alternative is an architecture that is loosely coupled in the diagram and frozen in practice. The cost is paid either as documentation discipline or as an inability to evolve, and the second is larger and arrives later.

Interview question

"You need to change when your order.confirmed event fires. The shape is unchanged. Tell me everything that could go wrong downstream, and how you would find out who is affected."