Key Takeaways
Choose architecture by business pressure, not by developer habit
Patterns create predictable tradeoffs. Software architecture patterns define how an application is divided, how its parts communicate, and what qualities the design tends to support. Richards contrasts five patterns, each suited to different pressures: layered systems favor familiar development and testing; event-driven systems and microservices support independent scaling; microkernel systems isolate optional features; space-based systems target extreme or variable user loads. These are tendencies, not guarantees. A specific implementation can perform differently from the pattern's usual profile.
Decide before the code hardens. Starting without an explicit design often produces a big ball of mud: modules exist, but their roles and dependencies are unclear. The resulting system is hard to change, and basic questions about deployment, performance, and scaling are difficult to answer. Since changing an established architecture is expensive, the first decision is not which pattern is fashionable, but which business and operational constraints matter most.
The useful shift is from treating architecture as a diagram to treating it as a set of commitments. Each boundary makes some changes easier and others harder, so the design should be judged against the system's likely sources of pressure. This resembles risk management: a team cannot optimize every quality at once, and pretending otherwise hides the real tradeoff. Pattern ratings are a helpful starting map, but they describe tendencies rather than outcomes. A disciplined choice therefore pairs a pattern with explicit assumptions about workload, deployment, and team capability.
Keep layers closed unless pass-through traffic outweighs isolation value
Layers protect change. In a layered architecture, presentation, business logic, persistence, and database concerns are separated. A closed layer requires a request to pass through the layer below it rather than skip directly to a deeper one. This creates layers of isolation: replacing a user-interface framework, for example, need not force changes to business logic if their contract remains stable.
Watch for empty handoffs. If most requests merely pass through layers without meaningful work, the design may be an architecture sinkhole. Richards offers an 80/20 rule of thumb: roughly 20 percent simple pass-through requests may be normal, but a reversed balance suggests reconsidering some boundaries. Opening selected layers can reduce unnecessary hops, but it weakens isolation and makes dependencies harder to govern. The choice is not simply speed versus slowness. It is fewer steps now versus broader change later.
The tension here is between local efficiency and system-wide legibility. A layer that adds no meaningful transformation can feel like bureaucracy, yet bypassing it may create a hidden dependency that only becomes visible during change. The 80/20 figure works best as a prompt to investigate, not as an architectural law. Request counts alone do not show whether a pass-through layer provides security, monitoring, or a stable interface. The stronger question is whether each boundary has a clear responsibility worth preserving.
Put a mediator over workflows, not over every event
Events separate producers and work. Event-driven architecture uses independent components that receive and process events asynchronously. Its mediator topology suits a workflow with several coordinated steps. In an insurance relocation example, an address change can trigger customer-record updates, a new quote, and claim updates. The mediator knows the required sequence and can identify steps that may run in parallel, while separate event processors perform the actual business tasks.
Chains need less central control. In the broker topology, there is no central mediator. A processor handles an event, publishes another event describing its result, and another processor may pick it up. This suits simpler flows where each step can hand off work independently. A mediator offers a visible place to coordinate a complex process; a broker avoids making that central coordinator responsible for every decision.
These topologies place workflow knowledge in different locations. A mediator makes the process easier to inspect as a whole, while a broker distributes that knowledge among the processors. The right choice depends partly on how important it is to understand and alter the sequence of work. Central coordination can become a bottleneck in decision-making even when the messaging is asynchronous. Conversely, a distributed chain can make the overall path harder to reconstruct. The design should make workflow ownership explicit rather than assuming that decentralization automatically means simplicity.
Treat asynchronous independence as a trade for transaction simplicity
Distributed work loses one easy transaction boundary. Event processors operate independently, so a single business process may span several components without behaving like one atomic database transaction. If a task must succeed or fail as an indivisible unit, splitting it among processors may be a poor fit. The architect must decide which steps can safely run independently and set processor boundaries accordingly.
Contracts become infrastructure. Each event needs an agreed format and data contract, and those contracts need a versioning policy. Systems must also handle unavailable processors, unresponsive services, and broker failures. Testing is harder than testing a single function because messages move asynchronously and require suitable tools to generate and observe events. The pattern can improve scalability and agility, but its operational and development complexity is a real part of the design, not a detail to add at the end.
This tradeoff is a reminder that decoupling does not eliminate dependencies; it changes their form. A direct call creates a visible dependency in code, while an event contract creates a dependency in shared expectations about data and behavior. That can make teams more independent, but only when compatibility is governed deliberately. A useful design test is to trace failure, not just the successful sequence: which parts can be retried, which can be delayed, and which must never be duplicated? Those questions reveal whether the chosen boundaries match the business process.
Build a stable core, then isolate volatile features as plug-ins
The microkernel separates essentials from variation. This architecture has a core system containing the minimum general functionality and independent plug-in modules that add specialized behavior. Eclipse illustrates the idea: a basic installation provides a foundation, while plug-ins add capabilities. The same structure can separate state-specific insurance claim rules from the common process, allowing one state's rules to change without rewriting the whole claims system.
Make the extension contract deliberate. A plug-in registry can record a module's name, data contract, and connection details. Plug-ins may connect through direct bindings, messaging, or web services, but should have few dependencies on one another. If a third-party plug-in uses a different contract, an adapter can translate it into the core's standard format. Contract versioning and plug-in boundaries require careful design, even when adding or replacing features becomes easier.
This pattern is strongest when a product has a durable center and a meaningful perimeter of variation. It makes change visible as an extension rather than an accumulating pile of exceptions inside the core. The distinction also clarifies ownership: core behavior can be governed centrally, while specialized capabilities evolve separately. But a plug-in boundary is not automatically a clean boundary. If modules depend heavily on one another, the architecture merely relocates complexity into the registry and contracts. The design succeeds when variation is genuinely separable.
Make microservices business-sized, or orchestration recreates SOA complexity
A service component is a deployable business capability. In microservices architecture, application parts are independently deployed and accessed remotely. A component might provide a narrow function or own a larger business area, such as placing a trade. The difficult design choice is its granularity. Components that are too broad limit independent deployment and scaling. Components that are too narrow force the user interface or another service to coordinate many calls, rebuilding the orchestration complexity that this approach seeks to avoid.
Keep independence practical. The book describes REST interfaces for fine-grained APIs or business applications, and lightweight centralized messaging when asynchronous transport and queuing are useful. A shared database can sometimes provide needed information without one service calling another. Small amounts of repeated utility logic may also be preferable to tight service dependencies. But if a request requires a distributed transaction across services, the pattern's complexity rises sharply.
The key unit is not the smallest possible service; it is a boundary that can change and deploy with limited coordination. That makes business ownership more important than counting classes or endpoints. The apparent freedom to deploy independently can disappear if every user request must synchronously assemble a dozen services. Shared databases and repeated code are pragmatic compromises, not universal rules. They buy independence in one dimension while introducing coupling or duplication in another. The design should state which cost it is choosing to carry.
Replace database bottlenecks with replicated memory only when load demands it
Space-based architecture moves active data into memory. Traditional web applications often bottleneck first at the database as concurrent demand grows. This pattern reduces reliance on a central database by keeping application data in replicated in-memory data grids across processing units. Virtualized middleware routes requests, coordinates data replication, supports distributed processing, and can start or stop processing units as load changes. A bidding site is a fitting example: requests update and retrieve current bids across active units.
Scale comes with constraints. A central store is often still used to initialize memory and persist updates asynchronously. The pattern can support very high and variable loads, but it is complex and expensive, difficult to test at extreme volumes, and poorly suited to some traditional applications with large operational datasets. It is a targeted response to a serious scaling constraint, not a default upgrade for any web application.
This design treats data placement as an architectural decision rather than assuming the database must sit at the center of every request. That can remove a major constraint, but replicated memory introduces its own consistency and operational questions. The pattern's appeal is clearest when the application can keep its most active data in a manageable working set and the cost of a central bottleneck is substantial. Before adopting it, teams should define which data must be current everywhere and what happens when replication or persistence is delayed.
Let team structure and operating capacity constrain the pattern
A pattern must fit its environment. Richards's comparisons are a decision aid, not a universal ranking. Layered architecture is familiar and relatively easy to develop and test, but its monolithic implementations can make deployment and scaling difficult. Event-driven systems and microservices support independent work and scaling, yet require stronger handling of distributed behavior. Microkernel systems suit extensible products, while space-based systems target unusually high or variable load at significant implementation cost.
Check the conditions around the code. Infrastructure, developer experience, budget, deadlines, application size, and deployment practices all influence whether a pattern is workable. The book also points to Conway's law: an organization's communication structure tends to shape the software structures it produces. A technically elegant design can therefore fail if the team cannot operate its boundaries or coordinate the contracts it creates.
Architecture is partly a mirror of organizational capacity. Independent deployable units help only when teams can own them, release them, and diagnose their failures. Likewise, a centralized design may be sensible when the organization needs shared governance more than local autonomy. This does not mean software should blindly copy the org chart. It means proposed boundaries should be checked against actual communication and operational habits. The best pattern is not the one with the most attractive scorecard, but the one whose costs the organization can reliably manage.
Analysis
The book's practical argument is that architecture is a choice about where complexity will live. Layered systems put it in the rules governing calls between horizontal responsibilities. Event-driven systems move it into message flows, event contracts, and failure handling. Microkernels place it at the boundary between a stable core and extensions. Microservices distribute it across deployable components and their contracts. Space-based systems concentrate it in memory replication and middleware. None removes complexity; each makes some forms of change easier while making other forms more costly.
This perspective helps explain why the patterns should not be read as a maturity ladder. A distributed design is not automatically more advanced, and a familiar layered system is not automatically obsolete. The appropriate design depends on the dominant constraint: frequent isolated releases, a workflow with coordinated asynchronous steps, extensible product features, or a database bottleneck under heavy variable load. The book's qualitative ratings are valuable because they force these questions into view, but they should not be mistaken for benchmarks. Actual performance, testability, and deployment difficulty depend on implementation and operating context.
A useful extension is to treat each proposed boundary as a hypothesis. If a component is meant to deploy independently, verify that changes really can do so without coordinating contracts elsewhere. If a layer is meant to isolate change, check whether other layers reach around it. If a plug-in is meant to contain variation, test whether the core still needs special cases for it. This shifts architecture review from defending a named pattern to checking whether its promised tradeoffs are real.
The book is concise and deliberately comparative rather than prescriptive. Its strongest lesson is not to select a fashionable diagram, but to make the costs visible before a system hardens around them. Architecture becomes useful when it helps teams answer concrete questions about change, deployment, scale, and responsibility.
Review Summary
Software Architecture Patterns receives mostly positive reviews, with an average rating of 3.64/5. Readers appreciate its concise overview of common architecture patterns, clear explanations, and useful comparisons. The book's brevity is seen as both a strength and weakness, providing a quick introduction but lacking depth. Many find it valuable for beginners and as a refresher for experienced developers. Some criticize outdated examples and controversial pattern analyses. Overall, it's recommended as a starting point for understanding software architecture concepts.
People Also Read
Glossary
Big ball of mud
Unstructured, tightly coupled systemAn application whose modules have no clearly defined roles, responsibilities, or relationships. It may have packages and components, but without an explicit architecture their dependencies become difficult to understand. The result is typically brittle and expensive to change, and its deployment, performance, and scaling characteristics are hard to assess.
Layers of isolation
Boundaries that contain changeA property of layered architecture in which changes to one layer generally affect only that layer, or a closely associated one. Isolation depends on components communicating through stable contracts and respecting layer boundaries. For example, a presentation framework can be replaced without changing business logic if the interface between those layers remains consistent.
Architecture sinkhole
Layers with little useful workA condition in layered architecture where requests pass through several layers with little or no processing in most of them. Some pass-through requests are expected, but if they dominate, the layers may add overhead without providing enough separation or business logic to justify it. Opening selected layers can reduce hops, though it weakens isolation.
Event-driven architecture
Asynchronous event processingAn architecture built from decoupled components that receive and process events asynchronously. Event processors perform focused business tasks, while messages carry work between them. The pattern has two common topologies: a mediator coordinates multi-step workflows, while a broker supports chains in which processors publish events for other processors.
Mediator topology
Central workflow coordinationAn event-driven arrangement in which an event mediator receives an initial event and coordinates the processing steps it requires. The mediator sends processing events through channels to independent event processors, which carry out the business logic. It is useful when a workflow has multiple steps, sequencing requirements, or tasks that may run in parallel.
Broker topology
Decentralized event chainingAn event-driven arrangement without a central mediator. Event processors receive events, perform a task, and may publish new events that other processors handle. The flow is distributed across those processors, making the topology useful for relatively simple chains that do not need centralized orchestration.
Microkernel architecture pattern
Core plus independent plug-insAn architecture that separates minimal core functionality from plug-in modules containing specialized features or processing. A registry and contracts can help the core discover and communicate with plug-ins. The pattern supports feature isolation and extensibility, but requires careful management of plug-in dependencies, connection methods, and contract versions.
Microservices architecture pattern
Independently deployed service componentsA distributed architecture that divides an application into service components deployed as separate units and accessed through remote interfaces. Components can be developed, tested, scaled, and released independently when their boundaries are well chosen. Excessively small components can require orchestration and inter-service transactions, adding complexity that undermines their independence.
Space-based architecture pattern
Replicated in-memory processingAn architecture intended to reduce scalability constraints by keeping application data in replicated in-memory grids across processing units rather than depending on a central database for every request. Middleware manages requests, replication, distributed processing, and unit deployment. It can support high or variable loads, but is complex and costly to implement.
Virtualized middleware
Processing and replication controlThe coordination layer in space-based architecture. It manages request routing, sessions, data synchronization, distributed processing, and the deployment of processing units. Its common components include messaging, data, and processing grids, plus a deployment manager that can add or remove processing units as load changes.
Conway's law
Organization shapes system structureThe relationship, noted in the book, between an organization's communication structure and the software structures it produces. Teams organized around presentation, business logic, or databases may create systems divided along those same lines. The idea highlights why architecture choices should account for how people coordinate and divide responsibility.
Download PDF
Download EPUB
.epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.