Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Software Architecture Patterns

Software Architecture Patterns

Choose a software architecture that fits your constraints, before its tradeoffs harden into code.
by Mark Richards 2015 47 pages
3.65
498 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

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.

Analysis

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.

Analysis

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.

Analysis

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.

Analysis

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.

Analysis

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.

Analysis

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.

Analysis

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.

Analysis

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.

Summary in 30 Seconds
Architecture patterns shift complexity rather than eliminate it: layers strengthen separation, while asynchronous components support independent work at the cost of transaction simplicity. Keep services large enough to avoid burdensome coordination, and use plug-ins to isolate optional features from a stable core. Replicated in-memory data can relieve database bottlenecks under extreme, variable demand, but adds operational cost. Team skills, infrastructure, budget, and communication structure all constrain which design will work.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.65 out of 5
Average of 498 ratings from Goodreads and Amazon.

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.

Your rating:
4.21
164 ratings
Want to read the full book?

Glossary

Big ball of mud

Unstructured, tightly coupled system

An 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 change

A 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 work

A 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 processing

An 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 coordination

An 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 chaining

An 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-ins

An 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 components

A 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 processing

An 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 control

The 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 structure

The 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.

About the Author

Mark Richards is an author known for his work on software architecture. His book "Software Architecture Patterns" is a concise guide to common architectural patterns in software development. Richards provides clear explanations and comparisons of different patterns, making complex concepts accessible to readers. His writing style is praised for its brevity and clarity, making it suitable for both beginners and experienced developers seeking a quick refresher. While some readers note limitations in the book's depth, Richards' approach is generally well-received for offering a solid foundation in software architecture principles.

Download PDF

To save this Software Architecture Patterns summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.37 MB     Pages: 15

Download EPUB

To read this Software Architecture Patterns summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.49 MB     Pages: 19
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...