---
title: "Cross-team dependencies: teams blocking each other | QMates"
source: https://qmates.tech/en/services/engineering-transformation/engineering-team-design/teams-blocking-each-other
description: "Every team waits for the others, so everything ships together. Cross-team dependencies and their causes, in the code and in the organisation."
updated: 2026-11-21
---

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.

## 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.

    Feeds into

    -   

    [

    Handled by

    Engineering Team Design](https://qmates.tech/en/services/engineering-transformation/engineering-team-design)

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.

    Feeds into

    -   

    [

    Handled by

    Legacy Code Refactoring](https://qmates.tech/en/services/engineering-transformation/legacy-code-refactoring)

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.

    Feeds into

    -   
    -   

    [

    Handled by

    Domain-Driven Design and EventStorming](https://qmates.tech/en/services/engineering-transformation/domain-driven-design-event-storming)

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.

    [

    Handled by

    DevOps, Continuous Delivery and Platform Engineering](https://qmates.tech/en/services/engineering-transformation/devops-continuous-delivery)

- [The service that tackles it](https://qmates.tech/en/services/engineering-transformation/engineering-team-design)
- [Not sure which cause weighs most?](https://qmates.tech/en/services/engineering-transformation/software-delivery-assessment)

## 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.
