liveBook · Manning

Autonomy

As explained in Microservices Patterns, Second Edition

Team autonomy is a team property in which the team can perform its work with minimal dependence on coordination, hand-offs, or waiting on other teams.

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.
design time coupling monolith

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

How Microservices Patterns, Second Edition covers it

How deep it goes
Defines autonomy, explains its architectural conditions, and compares how monoliths and microservices support it as organizations grow.
Examples
Illustrates autonomy with order and customer management teams and a monolith facing widespread API, library, or runtime changes.
What you can do after
Evaluate architecture choices for their effects on team coordination and independent delivery.
How it connects
Connects autonomy to stream-aligned teams, loose design-time coupling, cohesion, modifiability, and deployment pipelines.

Also explained in

Compare how 14 books explain autonomy →

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Microservices Patterns, Second Edition. The section links point to the parts of the book it draws on.