What happens if an edge platform's configuration system is built by three teams - one owning the config language, one owning global propagation, one owning the edge runtime - and each team ships on its own schedule with its own API? Predict the architectural consequence.

The prediction

The system will develop three interfaces where the problem has one, and the seams will fall exactly on the team boundaries rather than on the natural boundaries of the domain.

Concretely, expect:

• A config language that expresses things the runtime cannot execute, because the language team shipped ahead of the runtime team.
• A propagation layer with its own versioning that is not the same as the config version, so "which configuration is live at this location" becomes a question requiring three dashboards.
• Rollback semantics that differ per layer: the language supports validation, propagation supports staged rollout, the runtime supports neither — so a bad config can be validated, staged and still break at the edge with no coordinated undo.

That last consequence is the dangerous one, because the whole point of the system is safely changing behaviour at thousands of locations, and the safety property is the one thing no single team owns.

Why Conway's Law predicts this precisely

Communication structure determines interface structure. Three teams communicate through APIs, so the system will have three APIs. If no team owns "a configuration change is safe end to end", no component implements it — not through negligence, but because it is nobody's interface.

The inverse manoeuvre

Conway's Law is usually quoted fatalistically. Used deliberately, it is a design tool: if you want a particular architecture, arrange the teams to produce it.

Here that means one of two moves:

Option A — restructure the team. Form a single team owning the change lifecycle end to end: author, validate, stage, propagate, execute, roll back. The three specialisms become internal concerns.

Option B — make the seam explicit and owned. Keep three teams but define one artefact — a signed, versioned configuration bundle — with a single lifecycle contract that all three implement, and give one team the mandate to define and enforce it.

Option A produces a better architecture; option B is usually what is politically achievable.

The signal to watch for

When a question requires opening three dashboards owned by three teams, the architecture has a missing boundary, and the boundary is missing because the organisation has no seat for it.