A web is not a cord. A cord runs from one anchor to another - if either anchor lets go, the whole thing falls. A web crosses, redirects, distributes. Tension at any one point is held by the geometry of the others.
This is what shared ownership of infrastructure actually requires. Not a nice diagram of interconnected boxes. A structure that requires active participation from every node to remain a structure at all. Remove any one node and the geometry has to either redistribute or collapse.
The geometry of shared systems
A web is a network - multiple crossing paths, multiple load-bearing points, no single thread that carries all the tension. Remove any one of the load-bearing nodes and the geometry changes completely. The web does not sag or simplify. It collapses or redistributes - depending on whether the other nodes are actually carrying load or merely holding handles.
This is the difference between a shared system and a system that is used by multiple people.
A system used by multiple people has one owner - one team, one person, one codebase - that everyone else depends on. When the owner is unavailable, the system is unavailable to everyone. The structure is a cord, not a web. It has a single point of failure that is also its center.
A shared system distributes ownership across the nodes. Each team has a portion of the structure they are responsible for holding. When one team is unavailable, their portion of the web goes slack, but the rest does not collapse immediately. The structure degrades gracefully rather than stopping entirely.
What distributed ownership requires
A web only works when every node is actively holding it at the tension the geometry requires. Touching the structure is not the same as bearing its load.
Distributed ownership of infrastructure requires the same active participation. It is not enough to name owners in a document and consider the responsibility assigned. Each owner has to be capable of holding their portion at the tension the whole pattern requires - meaning they have to understand the system well enough to operate, debug, and modify it without help from the other nodes.
This is harder to achieve than it looks. The natural entropy of technical systems is toward centralization. One person learns the most about a system and becomes the de facto owner. Others defer to them. The web quietly becomes a cord again, with a single person holding most of it and everyone else holding handles that are technically attached but not load-bearing.
The person in the center
Teams that build shared infrastructure sometimes have a person in the center of the web - the one who is most deeply embedded in the system, the one the web is most built around. They are not above the structure or below it. They are part of the geometry. This is not inherently wrong. Complex systems often have a center of gravity.
The question is whether the center is load-bearing in a way that makes the whole structure fragile, or whether the edges are strong enough to remain stable if the center changes.
A healthy web allows the center to change without collapse. The geometry redistributes. This only works if the outer nodes have been building genuine capacity throughout - not just holding handles, but actually tensioning the web.
The Web Is Not Built Alone
A healthy web allows the center to change without collapse. The geometry redistributes. The new center finds the existing structure already strong enough to support a different distribution. This only works if the outer nodes have been building genuine capacity throughout - not just holding handles, but actually tensioning the web.
Building toward distributed resilience
Distributed ownership is built in unglamorous places. In the documentation that actually reflects how the system works, runbooks that other teams can follow, post-mortems that distribute knowledge rather than just recording what happened, on-call rotations that give multiple people real experience with the failure modes of the system.
None of this is visible when the web is working. What is visible is the pattern - the whole, held taut by the structure that took effort to build and requires effort to maintain.
The web is not built alone. It is held together by everyone holding their portion.
Related: The Pattern Has a Budget - on how coordination overhead grows when systems scale without shared tracking capacity.