Emergent Architecture: Build Just Enough, Just in Time

The mental model

Emergent architecture treats design as a continuous process, not an upfront phase. Instead of creating a complete architectural blueprint before writing code, the design evolves sprint by sprint as the system is built. It embraces the core tension of agile development: prioritizing adaptation to change over anticipation of future needs. The architecture is a living thing that grows and is refined alongside the product itself.

How it works

A team begins with the simplest possible design that meets the immediate requirements—the 'last responsible moment' for a decision. As new features or requirements arise, the team implements them and then refactors the existing structure to maintain its integrity and simplicity. This might involve extracting a class, introducing a new service, or changing a data model. This iterative cycle of building and refactoring allows the architecture to support the features that are actually needed, rather than features that were speculatively planned for.

When to use it

This approach is most effective in environments with high uncertainty, such as new product development, startups, or research projects. When you do not know what the final product will look like, or when you expect requirements to change based on user feedback, emergent design allows for maximum flexibility and reduces wasted effort on premature optimization and over-engineering.

When not to use it

Emergent architecture is risky for systems with very stable, well-understood requirements and high costs of failure, like aerospace or medical device software. In these cases, a more anticipatory, 'big design up front' approach is often necessary to ensure safety and performance. It also struggles in large, loosely-coordinated organizations where a lack of a shared, intentional architecture can lead to integration nightmares.

One canonical example

A team building a new e-commerce site starts with a simple monolithic application. After launch, they see high demand for a recommendation feature. To handle the load, they build a separate recommendation service. Later, to improve scalability, they extract the order processing logic into another service. The architecture emerged from a monolith into a service-oriented design based on real, demonstrated business needs, not an initial guess.