The web in the image is not decorative.
Three people stand in a dark concrete room. The two on the outside are holding handles. The structure between them - a rigid geometric lattice of cyan light - is stretched taut. The person in the center is inside it. If anyone lets go, the structure collapses. Not onto one person. Everywhere at once.
This is what shared ownership of infrastructure actually looks like. Not a nice diagram of interconnected boxes. A structure that requires active participation from every node to remain a structure at all.
The geometry of shared systems
The web between the three women is not a cord running from one to another. It is a network - multiple crossing paths, multiple load-bearing points, no single thread that carries all the tension. Remove any one of the three people and the geometry changes completely. The web does not sag or simplify. It collapses.
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
The web works because the three people in the image are not just touching it. They are actively holding it at the tension the geometry requires.
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
In the image, the person in the center is not separate from the web. She is inside it. The structure surrounds her. She is not above it or below it - she is part of the geometry.
Teams that build shared infrastructure sometimes have a person in this position: the one who is most deeply embedded in the system, the one the web is most built around. 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
The new center finds the existing structure already strong enough to support a different distribution.
Building toward distributed resilience
The concrete room in the image is not glamorous. The light source is the web itself. The space is unfinished, industrial, not designed for performance. This looks like where a system gets built, not where it gets shown.
Distributed ownership is built in spaces like this - in the unglamorous work of 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, the cyan light tracing 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.