The Mirror.

Cue

The whiteboard, clean light on clean boxes. The architecture is being drawn: modules, interfaces, low coupling, a design that would work if the teams were interchangeable. The org chart is not in the room.

Action

Designing: The Drafter, holding the architect's seat, decomposes the system for the problem and places the seams where the design wants them.

Stage

The Drafter tables Draw the Architecture: specify as though any team could build any module, so the architecture is set clean and the interface is drawn narrow and explicit. Every edge on the board looks equally sound, including the one that will run between two teams who never talk.

Tension

Nothing here is a mistake. The design is genuinely good, and it is good for an org that does not exist: an interchangeable one, where any team could own any module. The seams are placed where the problem wants them, on a board that cannot show where the org already put its walls, so the cleanest edge drawn is the one that will fray first.

Cue

The integration, where the shipped system can finally be held against the org chart. Outage after outage, each on a boundary between two teams. Someone lays the incident map over the reporting lines and the two shapes are the same.

Action

Mirroring: The Maintainer, holding the on-call seat, keeps the seams from failing and sees, from the pager, the pattern no single team sees.

Stage

The Maintainer works Hold the Seam: patch it, restart it, trace each failure to the two teams it lives between, and name that the mirror is real. The architecture never had a chance the org was not shaped for: the system is a copy of the communication structure that built it.

Tension

The pattern is legible, and the seat that sees it cannot change it. To name the mirror is to say the shape came from the org, not the code, which is the hardest finding to act on, because acting means reorganising and the easy move is to call it weak engineering and demand more coordination. So the maintainer holds a structural problem together with operational effort ... and the demand for another sync buys nothing the seam will feel.

Cue

The reorg room, and someone who has stopped moving code and started moving boundaries. The question has changed: not how do we coordinate the teams we have, but what teams would produce the architecture we drew.

Action

Reorganizing: The Reorganizer, holding the reorganizer's seat, redraws team ownership to match the intended architecture, and the seams move with the boundaries.

Stage

The Reorganizer tables Reshape the Org: move the boundaries rather than the code, so the reorg puts the dense communication inside each intended module and turns the mirror to reflect the design. With the org aligned to the architecture, the seams have nowhere to fall, and the clean shape can finally ship.

Tension

The mirror turns, and the settled org that ran so smoothly is gone. The inverse maneuver works, and it costs: reporting lines redrawn, teams broken up, months of churn with no feature to show, all paid now against seams that will simply never form. It trades a comfortable, historical org for one shaped like its own architecture ... or the reorganisation is judged too expensive and disruptive, the boundaries stay, and the system goes on wearing the shape of its builders.

Cue

The integration, where the two well-built halves are supposed to meet. The merge, the staging failure, the end-to-end test that will not pass: the parts are each correct and do not quite fit.

Action

Integrating: The Splicer, holding the integrator's seat, forces the halves together, while The Liaison at the coordinator's seat syncs across the boundary to align the readings.

Stage

The Splicer works Make It Meet and The Liaison works Sync at the Boundary: an adapter written by hand, a meeting held to align the terms. The seam settles onto the boundary, and the handoff proves too thin to close it: the glue holds, the sync narrows the gap, the fault line stays.

Tension

The parts meet, and the meeting is a monument to the boundary. Coordinating harder narrows the gap and never closes it, because the seam is set by who reports to whom, not by who met on Tuesday; the adapter makes it work by writing the org's boundary into the code. Everything is well-built, and the integration bugs live exactly on the line between two teams that no one was assigned to hold.

Cue

The two rooms, where the work must be handed to the teams that exist. The design is split into parts, and the parts are dealt out along the org chart, not the architecture: this team owns what is near it, that team owns the next.

Action

Building: The Lead, holding the team lead's seat, builds the nearest module densely and well; The Neighbor at the sibling's seat builds the next on their own schedule and reading.

Stage

The Lead works Own the Module and The Neighbor works Ship Our Half: two strong parts, each coordinated tightly inside its team. The interface between them crosses the boundary, so the ownership follows the org chart and not the design, and the one contract that spans the wall belongs to no single team.

Tension

Both teams are right, and the split is already the shape. Dealing the work along the org chart is the only practical move, because those are the teams there are; but it means the seams of the system are being placed on the seams of the org before a line of the far interface is written. The design's boundaries and the org's boundaries have quietly diverged, and the software will keep the org's.

Tenor

Reasonable, collaborative, sure the fix is more talking. The integration keeps failing at the boundary, so add a sync, align the interface, get both teams in a room: a communication problem has a communication answer. The voice of an org that trusts its structure and believes any seam can be closed with enough goodwill.

Undertow

Under the goodwill, a seam set by the reporting lines. The teams coordinate and the boundary stays exactly where the org put it, so the meetings narrow the gap and never close it, and the software keeps its shape. No one is sloppy: each team builds its half well, and the half-to-half contract is thin because the talk across the wall is thin, and the wall is the org's, not the code's.

Nerve

The feeling of an org that syncs and syncs and ships, again, a system shaped like itself, the same two teams' boundary failing in a new place every release.

Echo

After the run: a product that is a portrait of the org chart, a backlog of integration bugs all on the same lines, and the one move that would have closed them, reshaping the teams to the design, still unmade, because the org was the thing no one was willing to redraw.

Projection

Rigorous, abstract, right. Draws modules with low coupling and high cohesion, interfaces narrow and explicit, a decomposition chosen for the problem. Reads the system as a diagram, and the diagram is good.

Action

Specifies the architecture as if any team could build any module. Places the seams where the design wants them, not where the org already put its walls. Hands down a shape that is correct for a team that does not exist.

Shadow

The diagram assumes a communication structure the org does not have. The Drafter draws the interface clean and never sees that the two teams who must honour it barely talk, so the cleanest edge on the board is the one that will fray first.

Tell

"The design is sound. The teams just need to follow it." Believes the architecture is the shape that will ship, when the org chart is.

Projection

Focused, accountable, proud of the team's part. Knows their module deeply, ships it clean, coordinates tightly with the people they see every day. Optimises for the scope they own, which is the scope they can see.

Action

Builds the part nearest the team, densely and correctly. Reads the interface across the boundary the way their own team would, and assumes the other team reads it the same. Delivers a strong half of a contract with a weak far side.

Shadow

The strength stops at the boundary, and so does the shared understanding. The Lead's care is real and local: everything inside the team's edge is solid, and the one assumption that spans the edge to another team is the one no one owned.

Tell

"Our side works. Check with the other team." Draws the line of responsibility exactly where the seam will open.

Projection

Diplomatic, tireless, well-meaning. Runs the cross-team sync, keeps the shared doc, translates one team's context into the other's. Believes the seam is a communication problem, and communication is what they do.

Action

Carries messages across the boundary the org made expensive to cross. Schedules the meeting, aligns the language, files the shared decision. Narrows the gap between two readings without ever closing it.

Shadow

The channel is thinner than the problem, and no amount of goodwill widens it. The Liaison substitutes coordination for co-ownership, and the substitution always underdelivers: the meeting happens, the alignment holds until the next change, and the seam is still a seam.

Tell

"Let's get both teams in a room." The right instinct, applied to a boundary that a room cannot dissolve.

Projection

Weary, sharp, holding a map of where it breaks. Carries the pager, knows every seam by heart, can name which two teams a given outage lives between before the logs load. Sees the pattern no single team sees, because the pattern is what pages them.

Action

Holds the seam together with patches, runbooks, and retries. Debugs the failures that fall between owners and route to whoever is on call. Keeps the whole running on the strength of knowing exactly where the org's lines are.

Shadow

Knowing the pattern is not the power to change it. The Maintainer can see the system is a copy of the org chart, outage by outage, and can do nothing about the org: they hold a structural problem together with operational effort, forever.

Tell

"It's always the boundary between those two teams." Names the mirror precisely, from the one seat that cannot reshape it.

Projection

Competent, busy, reasonable. Owns the next module, has their own roadmap, their own standup, their own reading of the shared interface. Nothing against the other team; just rarely in the same room.

Action

Ships their half correctly, to their own understanding of the contract. Versions their side when it suits their schedule, not the caller's. Meets the boundary from the far side, with a different set of assumptions held just as honestly.

Shadow

Two correct halves, built to two readings, do not make one working whole. The Neighbor is no less careful than the Lead and no better connected across the line, so the interface carries two truths that meet, and fail, only at integration.

Tell

"That's not how we understood the interface." Both teams are right, which is exactly why the seam is not either team's bug.

Projection

Willing to pay the cost the others avoid. Reads the seams, reads the org chart beside them, and sees they are the same shape. Reaches for the boundaries, not the code, because the boundaries are where the design actually lives.

Action

Redraws team ownership to match the intended architecture. Puts the dense communication inside each module and the thin communication on the edges the design meant to be thin. Moves the org until the mirror reflects the drawing.

Shadow

The remedy is disruption with no feature to show for it. The Reorganizer buys the clean design with reporting lines redrawn, teams broken up, and months of churn, paid now against a payoff that is only ever the seams that never form.

Tell

"We're not changing the code. We're changing who owns it." Turns the mirror by moving the thing it reflects, and wears the cost of doing so.

Projection

Pragmatic, patient, a little grim. Lives where the modules are supposed to join, wiring the adapters, writing the glue, reconciling the two readings by hand. Owns the meeting-point that neither team's module actually contains.

Action

Builds the shim that makes one team's output fit the other team's input. Absorbs the mismatch into a layer of translation nobody designed. Makes it meet, at the cost of a seam of glue that is now its own thing to maintain.

Shadow

The glue is where the org's boundary is written into the code. The Splicer's work is real and skilled, and it is also the physical proof of the mirror: a whole layer that exists only because two teams could not share one interface, load-bearing and belonging to no module.

Tell

"I'll write an adapter." Solves the seam by building a monument to it.

Shown

The merge, the staging environment, the failing end-to-end test. Where two well-built halves are supposed to meet: the branch that won't combine, the field one team versioned and the other didn't, the outage that pages at 2 a.m.

Holds

The seam, and the whole system held against the org chart at last. The one place the mirroring shows as defects, exactly on the boundaries between teams.

Offers

The only honest view of which shape the system actually took. Here, and nowhere on the whiteboard, the design can be seen as the thing it became rather than the thing it was drawn to be.

Withheld

A way to move the seam from here. The integration reveals the fault line and cannot relocate it, because the seam follows the boundary, and the boundary lives in the org, not the code.

Shown

An org chart on the wall, and someone moving the boxes. Reporting lines redrawn, teams merged and split, ownership reassigned: the rare room where the shape itself is on the table.

Holds

The one lever that moves the seams, and the cost of pulling it. The authority to reshape the communication structure so the system it produces is the one that was drawn.

Offers

A mirror that reflects the architecture. Here the boundaries can be aligned to the design, so the seams have nowhere to fall and the clean shape can finally ship.

Withheld

A free move. The reorg room gives the design its shape and takes, in return, the settled org: months of churn, redrawn careers, and no feature to show for the seams that now never form.

Shown

A team around a board, aligning in five minutes. Shared context, shared shorthand, a hundred small decisions made without a meeting because everyone already knows.

Holds

The dense internal communication that makes a module cohesive. The high-bandwidth agreement a team has with itself, the thing an interface within one team's ownership can lean on.

Offers

Cheap, constant alignment inside the boundary. Here a module can be built coherent, because the people building it are in the same conversation all day.

Withheld

Anyone from the other side of the boundary. The standup aligns the team and no one beyond it, so the strength it builds stops exactly at the wall, and the cross-team assumption is never in the room.

Shown

Two teams on a call, a shared agenda, an interface doc on screen. The scheduled crossing of the boundary: updates given, terms defined, decisions recorded for later.

Holds

The handoff, and the belief that a meeting can do what a shared owner does. The thin, expensive channel that the interface across the boundary leans on.

Offers

Alignment, for now. Here two teams can bring their readings close enough to keep moving, until the next change pulls them apart.

Withheld

The bandwidth of one team. The sync carries a fraction of what a shared room carries, at several times the cost, so it narrows the gap and never closes it, and the seam survives the meeting.

Shown

Two teams, two rooms, two backlogs, a wall between. Dense talk inside each, a scheduled meeting between: the communication structure as furniture.

Holds

The org chart, lived rather than drawn. The real graph of who talks to whom, and the boundary where the talking thins to a trickle.

Offers

Clear ownership and clean scopes. Here each team can move fast within its walls, coordinated tightly with the people it can see.

Withheld

A shared room for the interface between them. The two rooms give each team its own context and withhold the common one, so the contract that spans the wall is the contract no single room holds.

Shown

Boxes and arrows, clean and low-coupling. The design as it should be: modules that hide their internals, interfaces narrow and explicit, seams placed where the problem wants them.

Holds

The architecture, and the assumption that any team could build any box. The one shape the play keeps promising, drawn as though the org chart were not in the room.

Offers

A correct decomposition of the problem. Here a system can be designed for low coupling and high cohesion, answerable to the problem and to nothing else.

Withheld

The communication structure that will actually build it. The whiteboard shows the design and hides the org, so the one edge that runs between two teams who never talk looks exactly as clean as all the others.

Place

At the whiteboard, where the boxes and arrows are clean and the coupling is low. The target shape: modules that hide their internals, interfaces that are narrow and explicit, a decomposition chosen for the problem and not for the people, information hidden behind boundaries drawn where the design wants them.

Load bearing

Without it there is no intended shape for the org to fail to produce, and no gap between design and delivery. With it there is a clean target the communication structure will be measured against, and quietly defeat: the Architecture is drawn as if any team could build any module, which is the one assumption the org chart will not honour. It is load bearing because it is the shape the play keeps promising and the org keeps failing to ship.

Apparent

Good design, plainly. It looks like exactly what should be built: low coupling, high cohesion, boundaries in the right places, a diagram anyone would approve. And it is good design, for a team shaped like the diagram, which is the team that does not exist.

Yearbook

Drawn by the drafter through designing, and split, in a moment, along lines it did not choose. It is the promise the play opens on: the Architecture sets the interface where the design wants it, and the org chart sets it somewhere else, and only the mirror names why the second wins.

Place

At the two rooms, on the wall between them, and in every place a message has to cross to be heard. The edge where a quick word becomes a scheduled sync, where shared context stops and translation starts. Inside it, a team agrees without trying; across it, agreement is work.

Load bearing

Without it every part of the system would be coordinated as cheaply as a team coordinates with itself. With it there are places where coordination is expensive and rare, and the design must cross exactly those places to hold together. The Boundary is load bearing because it is where the mirroring bites: a module split across a boundary is a module whose halves rarely talk, and the software remembers every conversation that did not happen.

Apparent

An ordinary reporting line. It looks like structure doing its job, teams with clear ownership and clean scopes, the sensible division of a large effort. And it is sensible, right up to the moment the architecture asks two teams on opposite sides of it to share one interface.

Yearbook

Drawn by the org chart, and crossed, thinly, by the liaison through coordinating. It is where the trouble lives: the Boundary is the line the seam settles onto, and the reason the handoff is the weakest contract in the system.

Place

At the sync, the scheduled cross-team meeting where context is translated rather than shared. The status update, the interface review, the Slack thread that spans two teams: the substitute for sitting in one room, carrying a fraction of the bandwidth a single team has with itself, at several times the cost.

Load bearing

Without it the two halves of a split interface would never talk at all and the seam would gape. With it they talk a little, expensively, and the seam narrows without closing: the Handoff is the coordination that crosses the boundary, and it is always thinner than the coordination inside a team, so the contract it maintains is always the weakest one in the system. It is load bearing because it is what the org offers in place of a shared owner, and why that offer is never quite enough.

Apparent

Good collaboration. It looks like teams working well together: regular syncs, clear updates, cross-functional alignment, all the ceremonies of coordination. And it is real effort, honestly made, which is what makes its insufficiency so hard to see: the meeting happened, the seam still failed.

Yearbook

Carried by the liaison through coordinating, against the thinness of the boundary. It is the effort that cannot win: the Handoff is what the interface leans on across a boundary, and its limits are why coordinating harder never moves the seam.

Place

At the whiteboard as a clean line, and at the integration as whatever the two teams actually agreed. The place where one module meets another: a signature, a schema, a protocol. On the design it is a single tidy edge; in delivery it is as sharp as the conversation that defined it.

Load bearing

Without it modules cannot compose at all, and the architecture is just boxes. With it composition depends on agreement, and agreement is cheap inside a team and dear across a boundary, so an interface within one team's ownership is crisp and an interface split between two is vague exactly where it matters. The Interface is load bearing because it is where the design's cleanliness meets the org's communication, and loses.

Apparent

A well-specified contract. It looks settled: the types line up, the endpoint is documented, the diagram shows one clean arrow. And within a team it is settled; across a boundary the same arrow hides two different readings that will not meet until the seam.

Yearbook

Specified by the drafter, and honoured unevenly through building on each side. It is the design's hope and the org's tell: an Interface owned by one team holds, one split by the boundary frays, and the fraying is what the splicer is left to force together.

Place

At the integration, where the shipped system can finally be held against the org chart and seen to match. Not one seam but the pattern of all of them: the fact, stated by Conway and measured since, that a design's structure copies the communication structure of the organisation that produced it, so the product is a portrait of the org.

Load bearing

Without it the play is a run of unrelated integration bugs and one awkward reorg. With it there is a named law the production stands on: the shape of the system mirrors the shape of the org, so the architecture you can ship is the one your communication structure is built for, and the seams sit on the team lines because that is where the talking stops. The Mirror is load bearing because it holds both the law and its one remedy, that to change the reflection you must change the thing reflected, the org, not the diagram.

Apparent

A coincidence. A run of bad integrations that better engineers would have avoided. It looks like a quality problem, or a coordination problem, anything but a structural law, because no single seam announces the pattern and the org chart is not where anyone looks for the cause. That dismissal is the last disguise, because the same law that makes the toy case inevitable is the one that put every seam on a boundary.

Yearbook

Assembled from the architecture meeting the org chart, and answered by the reorg. It is the law the play runs on: the Mirror is what the seam proves, what coordinating cannot escape, and what reorganizing is the only shown way to turn, a design shipped by the shape of its builders unless the builders are reshaped.

Place

At the two rooms, made real in seating, reporting lines, and standing invitations. Not the diagram on the wall but the live graph of communication: the people who share a manager, a channel, a lunch, and the people who file a ticket to reach each other. Dense inside a team, thin between teams.

Load bearing

Without it a design could be built by whoever, wherever, and the shape would answer only to the drawing. With it the system inherits a structure nobody drew for it: work flows easily where communication is dense and jams where it is thin, so the software's real boundaries form on the org's real boundaries. The Org Chart is load bearing because it, not the Architecture, is what the system will end up a copy of.

Apparent

Just how the company is arranged. It looks like org design, an HR concern, a matter of managers and headcount with nothing to say about software. That is the disguise, because the arrangement of who can talk to whom is the arrangement the product will be built in, and the chart is a system diagram no one reads as one.

Yearbook

Inhabited by the lead and the neighbor, through building inside their teams. It is the shape the system copies: the Org Chart draws the boundary the software will inherit, and its imprint on the delivered system is exactly what the mirror reflects.

Place

At the reorg room, where team boundaries are redrawn instead of code. The inverse move: take the architecture you want, and build the org to match it, so the dense communication falls inside each intended module and the thin communication falls on the edges the design meant to be thin. Reshape who talks to whom until the shape you get is the shape you drew.

Load bearing

Without it the seams are fixed wherever the org already put them, and the design is stuck. With it the seams can move, because they follow the boundaries, and the boundaries are now the ones the architecture chose: the inverse Conway maneuver, aligning communication structure to intended structure so the mirror finally reflects the drawing. The Reorg is load bearing because it is the only move in the play that changes the shape rather than fighting it.

Apparent

Disruption. Churn. Moving people around instead of shipping. It looks like the expensive, morale-costing thing every org avoids: reporting lines redrawn, teams broken up, ownership reassigned, all with no feature to show for it. That reading is why it is the last resort, because reshaping the org is real cost paid now against a payoff that is only ever the absence of seams.

Yearbook

Made by the reorganizer through reorganizing, against the settled weight of the org chart. It is the remedy the play holds: the Reorg moves the boundary so the seam has nowhere to fall, and it is the one thing that makes the mirror reflect the architecture instead of the org.

Place

At the integration, in the merge, the staging failure, the 2 a.m. page. Where two well-built halves are supposed to meet and almost do: the mismatched assumption, the field one team versions and the other doesn't, the retry the caller never expected. The bug that is nobody's code and everybody's problem.

Load bearing

Without it the mirroring would be a diagram curiosity, not a cost anyone pays. With it the org's shape shows up as defects, measurably, exactly on the boundaries between teams: the mirroring hypothesis made concrete, where loosely coupled teams produce loosely coupled parts and the couplings that remain fail at the org lines. The Seam is load bearing because it is where the law is felt, the place the system reveals which shape it actually took.

Apparent

An integration bug. Bad luck at the edges. It looks like ordinary friction, a defect to be triaged and owned by whoever is nearest, nothing structural. That reading is the trap, because the seam is not scattered at random: it lands on the boundary every time, and calling it luck is how the org's fingerprint goes unread.

Yearbook

Forced together by the splicer through integrating, and held, after, by the maintainer. It is where the play's cost lands: the Seam settles onto the boundary, proves the mirror true, and stays until the reorg moves the boundary out from under it.

Has

The authority to specify the architecture, and a clean sheet to draw it on. A view of the problem, and the freedom to decompose it as the problem, not the org, suggests.

Orders

Draw the low-coupling, high-cohesion design the problem deserves. Place the seams where the architecture wants them, and trust the teams to honour the interfaces. Specify as though any team could build any module.

Loses

The communication structure, which the seat treats as someone else's diagram. An architect who plans on the whiteboard cannot see which of their clean edges runs between two teams that never talk.

Drives

Toward the design that is correct for an interchangeable org, and away from the one the real org can ship. Toward interfaces drawn where the problem wants them, onto boundaries the org placed elsewhere.

Has

A standing invitation to both teams, and a mandate to align them. The tools of coordination: the sync, the shared doc, the translation between two contexts.

Orders

Run the cross-team meeting and keep the interface aligned. Carry each team's context to the other, and file the shared decision. Treat the seam as a communication problem, and communicate.

Loses

The bandwidth a single shared owner would have had for free. A seat that can only pass messages across the boundary cannot make two teams into one, so the alignment it wins is always thinner than the problem.

Drives

Toward a narrowed but unclosed gap, and away from the co-ownership that would have closed it. Toward more meetings against a seam that meetings cannot move.

Has

Responsibility for the meeting-point, and the glue to build it. The one vantage that sees both readings of the interface at once, because both land on its desk.

Orders

Make the halves meet: write the adapter, reconcile the assumptions, ship the join. Absorb the mismatch into a layer of translation, and keep the system composing. Own the seam, since no module does.

Loses

Any way to remove the seam it is asked to bridge. A seat that can only build glue turns the boundary into code rather than dissolving it, and the glue becomes load-bearing and its own to maintain.

Drives

Toward a working system held together at a seam of translation, and away from the shared interface that would need no glue. Toward a layer that is the org's boundary written into the code.

Has

The pager, the runbooks, and a map of where the system breaks. The one view of every seam at once, because every seam eventually routes here.

Orders

Keep it running: patch the seam, restart the service, file the incident. Debug the failures that fall between owners and belong to no team. Hold the whole together on the strength of knowing where the org's lines are.

Loses

The power to change the shape it can see so clearly. A seat that answers for the failures cannot redraw the boundaries that cause them, so it carries a structural problem with operational effort.

Drives

Toward a system kept alive across its seams, and away from any authority to remove them. Toward naming the mirror, outage by outage, from the seat least able to turn it.

Has

The authority the others lack: to move reporting lines, not just code. A view of the seams and the org chart together, and the standing to redraw the second.

Orders

Reshape the teams to match the intended architecture. Put the dense communication inside each module and the thin communication on the edges the design meant to be thin. Change the thing the mirror reflects, so the reflection changes.

Loses

The settled org every team's habits were built around. A seat that redraws boundaries spends real morale and months of churn, with no feature to show, against a payoff that is only the seams that never form.

Drives

Toward an org shaped like the architecture, and away from a design that fights the chart forever. Toward the mirror reflecting the drawing, at the price of the reorganisation the org was too settled to make.

Has

The next module, a separate backlog, and a standup the other team is not in. Full competence over its own scope, and a reading of the shared interface held just as honestly as the other side's.

Orders

Ship the neighbouring part correctly, to your own understanding of the contract. Set your own schedule and version on it, not on the caller's. Meet the boundary from your side, with your assumptions.

Loses

The other team's reading of the same interface. A seat that owns the far half and rarely shares a room cannot reconcile two truths that only touch at integration.

Drives

Toward a correct neighbouring module built to a divergent contract, and away from the shared understanding a single owner would have had. Toward two right halves that fail to compose, on a boundary neither seat was asked to hold.

Has

Deep ownership of one module, and a team it talks to every day. The bandwidth to coordinate tightly inside its edge, and a mandate scoped to that edge.

Orders

Build the team's part well, clean, and on time. Coordinate closely with the people you see, and hold the interface as your team reads it. Deliver the scope you own, which is the scope you can see.

Loses

The far side of every shared interface. A seat rewarded for its own module's health cannot own an assumption that lives between it and another team.

Drives

Toward a strong local module and a dense internal contract, and away from the boundary its care never reaches. Toward a half of the system built to one honest reading, meeting another half built to a different one.

Initiated by

A design split into parts and handed to the teams that exist. Once ownership is assigned, each team builds its piece to its own reading.

Direction

From assigned module to shipped half. It moves toward a clean part, coordinated tightly within the team and loosely with the team across the boundary.

Lever

Dense internal communication meeting a thin cross-team one. The force is each team's local care; the resistance is that the shared interface is agreed cheaply within a team and expensively, if at all, between two.

Echo

Two correct halves built to two readings. It hands forward well-made parts whose only weak contract is the one that spans a boundary, waiting to meet at integration.

Initiated by

Two teams who must agree on an interface they do not share. When a contract spans a boundary, someone starts scheduling the crossing.

Direction

From divergent readings toward a temporary alignment. It moves the two sides closer without ever making them one.

Lever

Goodwill and meetings meeting the bandwidth of a single shared owner. The force is honest effort to align; the resistance is that a channel across a boundary carries a fraction of what a shared room does.

Echo

A gap narrowed and not closed. It hands forward an alignment that holds until the next change, and a seam the coordination could never move.

Initiated by

A problem in need of a shape. The moment a system must be decomposed, the work of drawing modules and interfaces begins.

Direction

From problem to clean architecture. It moves toward low coupling, high cohesion, and seams placed where the design wants them.

Lever

Design competence meeting an absent org chart. The force is real architectural skill; the resistance is that the communication structure that will build it is never on the board.

Echo

A correct design for an interchangeable org. It hands the shape forward as though any team could build any module, and the org that will build it is shaped otherwise.

Initiated by

Two halves arriving that were built to two readings. When the modules must compose, the assumptions that never met are made to.

Direction

From divergent parts toward a working whole, by hand. It moves toward a shipped system, through a layer of glue that reconciles what the interface did not.

Lever

An adapter meeting a mismatch. The force is the integrator's skill at making things fit; the resistance is that the fit is a translation, not an agreement, and it becomes load-bearing.

Echo

A composed system with a seam of glue at every boundary. It hands forward a working whole and, written into it, the org's boundaries as code no module owns.

Initiated by

A design built through a communication structure it did not account for. The moment work flows easily inside teams and jams between them, the shape begins to copy the org.

Direction

From org chart to system structure. It moves the software's real boundaries onto the org's real boundaries, seam by seam.

Lever

Cheap communication inside a team meeting dear communication across one. The force is the org's own shape; the resistance is a design that assumed a different one.

Echo

A system that is a portrait of its org. It hands forward a shipped product whose seams sit on the team lines, and a pattern only the on-call seat sees whole.

Initiated by

Someone reading the seams against the org chart and seeing they are one shape. When the boundaries, not the code, are named as the cause, the work of moving them can begin.

Direction

From an org shaped by history toward an org shaped by the architecture. It moves the boundaries so the dense communication falls inside each intended module.

Lever

Authority over reporting lines meeting the settled weight of the org. The force is the will to change the shape itself; the resistance is the churn, the morale, and the absence of any feature to show.

Echo

A mirror that reflects the design. It hands forward an org whose communication structure produces the architecture, bought with a reorganisation paid now against seams that never form.

Direction

Specify the clean design the problem deserves: low coupling, high cohesion, narrow explicit interfaces. Draw the seams where the architecture wants them, and assume the teams will honour them.

Orders

(The Drafter decomposes the system as if any team could build any module, and hands the shape down.)

Implementation

(The Whiteboard; the designing process; a decomposition chosen for the problem, blind to the communication structure that will build it.)

Targets

• [ ] the system is decomposed for low coupling and high cohesion
• [ ] interfaces are drawn narrow and explicit
• [ ] the seams are placed where the design wants them
• [ ] the shape is specified as though teams were interchangeable

Direction

Keep it running: patch the seam, restart the service, file the incident. Debug the failures that fall between owners, and hold the whole together on the strength of knowing where the org's lines are.

Orders

(The Maintainer carries the pager, names which two teams each outage lives between, and keeps the seams from failing at 2 a.m.)

Implementation

(The Integration; the mirroring process; operational effort spent holding together a structural problem the seat cannot redraw.)

Targets

• [ ] the seam failures are patched and kept running
• [ ] each outage is traced to the boundary it lives on
• [ ] the pattern of seams-on-boundaries is seen whole
• [ ] the shape that causes them stays beyond the seat's reach

Direction

Force the two well-built halves together: write the adapter, reconcile the assumptions, ship the join. Own the meeting-point that neither module contains, and keep the system composing.

Orders

(The Splicer builds the shim that makes one team's output fit the other's input, absorbing the mismatch into a layer nobody designed.)

Implementation

(The Integration; the integrating process; a layer of translation that is the org's boundary written into the code, load-bearing and unowned by any module.)

Targets

• [ ] the two readings of the interface are reconciled by hand
• [ ] an adapter is built to make the halves fit
• [ ] the system composes and ships
• [ ] the glue becomes its own thing to maintain

Direction

Build the team's part well and on time, coordinating tightly with the people you see every day. Hold the interface as your team reads it, and deliver the scope you own.

Orders

(The Lead ships a clean module, densely coordinated inside the team, and reads the shared contract the way the team would.)

Implementation

(The Standup; the building process; dense internal communication, and one assumption spanning the boundary that no one on the team owns.)

Targets

• [ ] the team's module is built clean and on time
• [ ] internal coordination is dense and daily
• [ ] the shared interface is held to the team's reading
• [ ] the far side of that interface is left to the other team

Direction

Move the boundaries, not the code. Reshape the teams to match the intended architecture, so the dense communication falls inside each module and the thin communication on the edges the design meant to be thin.

Orders

(The Reorganizer redraws team ownership to the architecture, and the seams move with the boundaries.)

Implementation

(The Reorg Room; the reorganizing process; the inverse Conway maneuver, paid in churn now against seams that never form later.)

Targets

• [ ] the seams are read against the org chart and found to match
• [ ] team ownership is redrawn to the intended architecture
• [ ] dense communication is placed inside each module
• [ ] the mirror is turned to reflect the design, at the cost of the reorg

Direction

Ship the neighbouring module correctly, to your own understanding of the contract, on your own roadmap. Meet the boundary from your side, with your assumptions.

Orders

(The Neighbor builds the far half well and versions it when it suits their schedule, not the caller's.)

Implementation

(The Two Rooms; the building process; a separate backlog and a divergent reading of the same interface, held just as honestly.)

Targets

• [ ] the neighbouring module is built correctly
• [ ] it is delivered on the team's own schedule
• [ ] the interface is honoured to the team's own reading
• [ ] the two readings meet only at integration

Direction

Treat the seam as a communication problem and communicate: run the cross-team sync, align the interface, translate each team's context to the other. Narrow the gap by meeting more.

Orders

(The Liaison carries messages across the boundary, files the shared decision, and keeps the two readings as close as a meeting can.)

Implementation

(The Sync; the coordinating process; a thin, expensive channel standing in for a shared owner it can never quite replace.)

Targets

• [ ] the cross-team sync is scheduled and held
• [ ] each team's context is translated to the other
• [ ] the shared interface is aligned for now
• [ ] the gap is narrowed, and not closed