Component architecture organizes an application into components and defines their structural relationships. For a large application developed by many teams, multiple components can limit the scope of changes and let teams evolve, test, and deploy parts of the system independently. section 5.3.4 section 5.7
The benefits depend on the boundaries. Private technology-stack elements can be upgraded within one component, while shared elements such as a message broker require coordination. Even an upgrade affecting every component can be scheduled as smaller, incremental changes. The trade-off is repeated work: a library used by every component must be upgraded separately in each one. section 5.3.4
Figure 5.12 A multi-component architecture significantly improves an application’s evolvability. Upgrading the private elements of a component’s technology stack affects just that component and its team or teams. Typically, only upgrades of shared technology stack elements require many teams to collaborate.
Compare the scope of upgrades to private and shared technology-stack elements. section 5.3.4
Component boundaries influence several delivery capabilities:
- Testing: independently testable components can reduce the resources needed for local development. Incremental builds and loose build-time coupling also limit which projects must be retested. section 5.4.4 section 5.4.5
- Deployment: smaller components may start faster, and separate deployment pipelines can run in parallel rather than competing for one pipeline. section 5.5.2
- Observability: component-level telemetry can help make a large system observable, but instrumentation and infrastructure are still needed to collect and analyze it. section 5.6.2
Keep clients away from changing implementations
An order-management project can depend on a stable customer-management API project instead of the customer-management implementation project. A change to the implementation then need not trigger retesting of the order-management implementation. section 5.4.4
A microservice architecture is one multi-component option: services can evolve one at a time and be tested in isolation. Those gains require discipline to keep service dependencies loosely coupled. For local work, splitting an application helps only if developers can run the component they are changing without also running many others. Weigh that benefit against the cost of maintaining and upgrading multiple components; a small application may be practical to run and test as a whole. section 7.4.1 section 5.4.5 section 5.3.4
