System Design Space
Knowledge graphSettings

Updated: March 2, 2026 at 3:15 PM

Fundamentals of Software Architecture (short summary)

mid

Source

Book Review

Chapter based on this article

Read the article

Fundamentals of Software Architecture

Authors: Mark Richards, Neal Ford
Publisher: O'Reilly Media, 2020
Length: 432 pages

Architectural characteristics, styles (Layered, Microservices, Event-Driven) and soft skills of an architect from Mark Richards and Neal Ford.

Fundamentals of Software Architecture - original coverOriginal
Fundamentals of Software Architecture - translated editionTranslated

Book structure

The book is divided into three parts, each of which covers different aspects of the architect's role:

Part I: Basics

Architectural thinking, modularity, architectural characteristics and methods for measuring them.

Part II: Architecture Styles

Layered, Pipeline, Microkernel, Service-Based, Event-Driven, Space-Based, Microservices and others.

Part III: Soft Skills

Decision making, documentation, leadership, negotiation and career development as an architect.

Article

Architectural Characteristics and Trade-offs

A detailed analysis of the characteristics of the architecture and the principles of choosing compromises

Read the article

Part I: Architectural Thinking

Architecture Characteristics (ilities)

Operating
Availability
System availability (99.9%, 99.99%)
Reliability
Reliability and fault tolerance
Performance
Response time and throughput
Scalability
Ability to scale under load
Structural
Modularity
Division into independent modules
Extensibility
Ease of adding new functionality
Maintainability
Easy to maintain and change
Testability
Ability to test components
Cross-functional
Security
Protection against threats and vulnerabilities
Accessibility
Availability for all users
Usability
Ease of use
Agility
Speed of adaptation to changes

Key insight: The architect must select 3-5 key characteristics for the system. Trying to optimize everything leads to “generic architecture” - a mediocre solution with no obvious advantages.

Architecture and characteristics relationship

Design
ExplicitImplicit
Non-design
Defines operational success criteria
Structural
Influences solution structure
Architectural
thinking
Architecture Characteristics

Critical for success: the architect should choose minimum characteristics, not maximum.

Explicit
Implicit

Modularity and connectivity

Modularity metrics
Cohesion
How connected are elements within a module (high = good)
Coupling
Dependency between modules (low = good)
Connascence
Degree of change during modification (static vs dynamic)
Abstractness
Relationship between abstractions and concrete implementations
Distance from Main Sequence

Metric for assessing the quality of a module through the balance of abstraction and stability:

D = |A + I - 1|

A = Abstractness, I = Instability. The closer D is to 0, the better.

Main Sequence and risk zones

Zone of PainZone of UselessnessMain SequenceI: InstabilityA: Abstractness(0,0)(1,0)(0,1)(1,1)
Main Sequence

Ideal diagonal: balance between abstractness and stability. Formula: D = |A + I - 1|

Zone of Pain

Concrete and stable components (A≈0, I≈0). Hard to change because of many dependencies.

Zone of Uselessness

Abstract and unstable components (A≈1, I≈1). Abstractions without implementations.

Connascence Types

Static
Easier to refactor
Name
Dependency on entity name
Type
Dependency on data type
Meaning
Dependency on value semantics
Algorithm
Dependency on algorithm
Position
Dependency on element order
Dynamic
Harder to refactor
Execution
Dependency on execution order
Timing
Dependency on timing
Value
Dependency on specific values
Identity
Dependency on object identity
Easier to refactor
Stronger coupling

Part II: Architectural Styles

Monolithic architectures

Layered Architecture
  • Presentation → Business → Persistence → Database
  • Ease of understanding and development
  • Sinkhole anti-pattern
Pipeline Architecture
  • Pipes and Filters pattern
  • ETL, data processing pipelines
  • Unix philosophy
Microkernel Architecture
  • Core system + plug-in components
  • IDE, browsers, Eclipse
  • Extensibility without changing the kernel

Distributed Architectures

Service-Based Architecture

The “golden mean” between monolith and microservices:

4-12 services
Large domain services, not microservices
Shared DB
Usually a single database for simplicity
User Interface
Can be monolithic or divided
Event-Driven Architecture

Asynchronous communication through events:

Broker Topology
No central coordinator
Mediator Topology
Central event mediator
Space-Based Architecture

For extreme scalability:

Processing Units
Contains logic and in-memory data grid
Virtualized Middleware
Messaging grid, data grid, processing grid
Use Case
Concert ticketing, online auctions
Microservices Architecture

Maximum service independence:

Bounded Context
Each service = one bounded context
Database per Service
Data isolation, eventual consistency
Choreography vs Orchestration
Two approaches to coordination
Comparison of architectural styles
StyleDeployabilityScalabilitySimplicityCost
Layered⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐
Service-Based⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐
Event-Driven⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐
Microservices⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐

Part III: Soft Skills of an Architect

Architecture Decision Records (ADR)

Documentation of architectural decisions:

Title
Brief name of the solution
Status
Proposed, Accepted, Deprecated, Superseded
Context
Why was there a need for a solution?
Decision
What did you decide and why?
Consequences
Pros and cons of the chosen approach

Architecture Fitness Functions

Automatic architecture compliance check:

Cyclic Dependencies
Checking for Circular Dependencies
Layer Violations
Monitoring layer violations (ArchUnit)
Performance
Autotests for response time
Security
SAST/DAST checks in CI/CD

Key insight: An architect is not only a technical specialist, but also a leader, negotiator and communicator. 50% of an architect’s success is the ability to explain and “sell” their solution to stakeholders.

Application to System Design Interview

What to use in an interview

  • Architecture Characteristics: explicitly name the selected characteristics and trade-offs
  • Architectural styles: justify your choice of style (Event-Driven vs Service-Based)
  • Trade-off analysis: show an understanding of the trade-offs
  • ADR approach: structure the explanation as Context → Decision → Consequences

Common mistakes

  • Choosing microservices “by default” without justification
  • Ignoring operational characteristics (functional requirements only)
  • Absence of explicit trade-offs in the solution
  • Over-engineering for simple tasks

Continuation

Building Evolutionary Architectures

Next book in the series: Fitness Functions, Connascence and the Evolution of Architecture

Read review

Verdict

9/10
Practicality
8/10
Depth
9/10
For an interview

Fundamentals of Software Architecture is a must-read for anyone who wants to understand the architect's role in a holistic way. The classification of architectural styles with a clear analysis of trade-offs is especially valuable. For the System Design Interview, the book provides an excellent framework for structuring answers and justifying decisions. Recommended after studying basic books on System Design.

Where to find the book

Enable tracking in Settings

System Design Space

© 2026 Alexander Polomodov