Sometimes the most interesting posts are not the ones we write, but the questions they provoke.

After my recent post “When Everything Shares the Same Centre, Everything Breaks Together”, someone asked a thoughtful question about Dynamic Consistency Boundaries (DCB). The question touched on something important:

If handlers can subscribe to events through tags like [policyId, coverage], how do you preserve service autonomy?

The concern was essentially this:

• Who owns the semantics of those tags?
• What prevents this from becoming just another form of a shared database?
• And if services can observe everything, do service boundaries still exist?

These are fair questions. They deserve a clear answer.

The important point is this: DCB does not imply one single domain, one single system, or one shared model of truth.

In my earlier posts I introduced four foundational building blocks. One of them is translation. Translation exists precisely to protect system autonomy.

In a well-designed landscape, each system still owns its own database, its own internal events, and its own language. Systems do not directly share state. They do not query each other’s data. They do not adopt another system’s model as their own.

Instead, they observe external signals.

When something happens in another system, an event is emitted. A consumer can listen to that signal, but it should not blindly internalize the meaning of that event. Instead, it translates that external signal into its own internal representation.

Imagine a Policy system emitting an event related to coverage.

A Claims system may care about that signal, but it should not model coverage exactly the way Policy does. Claims has its own concerns, its own rules, its own language. So the external event becomes an input signal that the Claims system translates into claims-specific internal events.

Each system records what is meaningful for its world.

Nothing is shared at the database level. Nothing is coupled through direct access to another team’s internals.

This also clarifies the difference to a shared database.

With a shared database, consumers can reach directly into another system’s storage. They can read tables, join across schemas, and build logic that depends on someone else’s internal structure. Ownership boundaries disappear.

With an event-driven approach and translation, consumers cannot reach into another system’s internals. They only react to published facts and decide what to persist themselves.

There is still a contract, of course. Events and tags have meaning defined by the producer. But consumers remain autonomous because they translate those signals into their own language instead of sharing one global model.

So Dynamic Consistency Boundaries are not about giving everyone access to everything. They are about something much simpler.

Systems can observe the world.

But they remain autonomous by translating what they observe into their own model.

That small distinction makes all the difference between a tightly coupled system and a healthy ecosystem of independent services.

Originally published on LinkedIn (2026-03-10): https://www.linkedin.com/pulse/events-shared-signals-models-gabriel-n-schenker-msupe