Team autonomy is the ability of a team to do its work mostly independently, without regularly coordinating with, handing work to, or waiting for other teams. It supports fast flow by reducing delays between a change and its delivery. Autonomy is not isolation: teams still collaborate when a change crosses their boundaries. section 1.2.1 section 7.4.4
Organizing teams around streams of work is not enough. The architecture must also be loosely coupled at design time: a team should usually be able to change its part of the application without requiring another team to change theirs. High cohesion helps keep related changes within the same module or component. Together, these properties make changes easier to localize and reduce cross-team coordination. section 1.2.1 section 4.2.2 section 5.2.2
Orders and customer management
An Orders team owns Order Management, which calls the Customer Management API owned by another team. With loose design-time coupling, a change to Customer Management is unlikely to require a change to Order Management. Tight coupling makes cross-team changes, coordination, and waiting more likely. section 4.2.2
A modular monolith can improve autonomy and is a good choice for many applications. As the application and organization grow, however, breaking changes to widely used APIs, libraries, or the runtime can affect many teams. The shared deployment pipeline can also become a bottleneck. section 1.2.2 section 6.0
Figure 1.7 Even though most modules in this monolithic application are loosely design-time coupled, since there is a single code base, some changes can be difficult to make because they impact numerous teams. A change to a utility module might require simultaneous changes to many other modules. Upgrading 3rd party libraries or the language runtime might also require widespread changes. There’s also a risk that the deployment pipeline becomes a bottleneck due to the large codebase and large number of developers.
The diagram shows how shared code and a single pipeline can constrain autonomy even when most monolith modules are loosely coupled. section 1.2.2
Loosely coupled microservices can give teams separate codebases, technology stacks, and deployment pipelines. That makes independent changes and deployments easier, but distributed architecture adds complexity and demands rigorous design. Start with the simplest viable architecture; consider microservices when the application outgrows a monolith, not as an automatic route to autonomy. section 1.3.2 section 1.5













