Cross-team dependencies

Our teams wait for each other before they can release

Cross-team dependencies show up in the stand-up, where you find out who is waiting for whom, and their roots go further back, in teams divided by technology and in code where everyone changes modules that also belong to others. Organisation and code shape each other. Teams divide the way the code allows, and the code grows following the division of the teams, until a release only goes out when everyone goes together.

Book a call

Does this sound familiar?

  • An ordinary feature needs the work of several teams, and each waits for the others before releasing.
  • The stand-up mostly tells you who is waiting for whom.
  • Two teams touch the same files in the same week and find out at merge time.
  • One team’s release slips because another hasn’t finished its part.
  • We have already reorganised the teams, and the waiting came back after a few months.

What ties the teams to each other?

A team releases alone when it owns the whole part of the system that changes. The domain map is the point everything else depends on. Without it, teams and modules divide along different lines, and the joint release is the consequence you see at the end.

  1. Team boundaries don’t match the software’s boundaries

    Melvin Conway observed in 1968 that a system ends up mirroring the communication structure of the organisation that builds it. If teams are divided by technology or by project and the code follows other lines, every feature crosses several groups and each has to wait for the others.

  2. Several teams on the same modules

    In a monolith with no internal boundaries, every team ends up changing code that also belongs to others. Coordination becomes unavoidable, and with it come conflicts, regressions caused by other teams’ changes and reviews waiting for whoever knows the other part.

  3. There is no map of the domain

    To give each team an independent area you need to know where the real boundaries of the domain run, the ones that separate parts of the product that change for different reasons. Without this map, teams and modules are divided by org chart or by technology, and that is where dependencies are born.

  4. Releases only go out all together

    If the pipeline and the release process treat the system as a single block, even a team that has finished must wait for the others. For each part to go out on its own you need separate pipelines, reliable tests and explicit contracts between the parts.

What changes when every team releases on its own

Each team owns an area of the product, from code to production, and puts out its changes when they are ready. The few dependencies that remain go through explicit contracts, and meetings between teams are used again only for decisions that involve several groups.

Engineering leads keep cross-team meetings for the choices that involve more than one group, and a feature is planned on the calendar of the team that owns it.

Where does a feature that crosses several teams wait?

One feature that has crossed several teams is enough to see whether the first step is redesigning the teams, with our Engineering Team Design service, or whether the knot lies earlier, in the code.

We use your data to respond to your request. Read our Privacy Policy.