Chapter 1 — What Are Microservices?
The defining characteristics of microservices, their advantages, their costs and the situations in which they may or may not be appropriate.

• independent deployability;
• business-domain modelling;
• service ownership of state;
• single-process, modular and distributed monoliths;
• scaling and organisational alignment;
• latency, testing and operational complexity;
• when not to use microservices.

Chapter 2 — How to Model Microservices
How to identify meaningful service boundaries and avoid decompositions that increase coupling.

• information hiding;
• cohesion and coupling;
• domain coupling;
• pass-through, common and content coupling;
• ubiquitous language;
• aggregates;
• bounded contexts;
• Event Storming;
• Domain-Driven Design.

Chapter 3 — Splitting the Monolith
Strategies for decomposing existing systems incrementally rather than replacing them all at once.

• incremental migration;
• choosing what to extract first;
• decomposition by code or data;
• Strangler Fig pattern;
• parallel run;
• feature toggles;
• data integrity and transaction concerns.

Chapter 4 — Microservice Communication Styles
The architectural trade-offs between different ways services exchange information.

• synchronous blocking communication;
• asynchronous non-blocking communication;
• request-response;
• communication through common data;
• event-driven communication;
• latency and failure implications.

Chapter 5 — Implementing Microservice Communication
Concrete technologies and practices used to implement service communication safely.

• REST;
• Remote Procedure Calls;
• GraphQL;
• message brokers;
• serialization formats;
• schema evolution;
• backward compatibility;
• service discovery;
• API gateways;
• service meshes.

Chapter 6 — Workflow
How business operations can span multiple independently owned services.

• ACID transactions;
• distributed transactions;
• Two-Phase Commit;
• Saga;
• compensating actions;
• Saga failure modes.

Chapter 7 — Build
Continuous Integration, build pipelines, repositories and artifact management in independently deployable services.

Chapter 8 — Deployment
Deployment models and the infrastructure needed to run microservices reliably.

• Infrastructure as Code;
• zero-downtime deployment;
• virtual machines;
• containers;
• PaaS and FaaS;
• Kubernetes;
• container orchestration;
• progressive delivery;
• canary releases;
• feature toggles.

Chapter 9 — Testing
Testing strategies for systems composed of independently deployed services.

• unit tests;
• service tests;
• end-to-end tests;
• contract tests;
• consumer-driven contracts;
• production testing;
• robustness and performance testing.

Chapter 10 — From Monitoring to Observability
How to understand system behaviour when requests cross multiple services and machines.

• log aggregation;
• metrics;
• distributed tracing;
• alerting;
• semantic monitoring;
• observability.

Chapter 11 — Security
Security principles and identity management in distributed service architectures.

• least privilege;
• defence in depth;
• Zero Trust;
• data in transit and at rest;
• authentication and authorization;
• service-to-service authentication;
• Single Sign-On;
• JWT;
• centralised and decentralised authorization.

Chapter 12 — Resiliency
Patterns that allow distributed systems to continue providing useful service despite failures.

• timeouts;
• retries;
• bulkheads;
• circuit breakers;
• isolation;
• redundancy;
• idempotency;
• CAP theorem;
• Chaos Engineering;
• graceful degradation.

Chapter 13 — Scaling
Different ways to increase system capacity and distribute load.

• vertical scaling;
• horizontal duplication;
• data partitioning;
• functional decomposition;
• caching;
• autoscaling.

Chapter 15 — Organizational Structures
The relationship between software architecture, ownership and team structure.

• Conway’s Law;
• team autonomy;
• service ownership;
• platform teams;
• communities of practice;
• cross-cutting changes.

Chapter 16 — The Evolutionary Architect
Architecture as an evolving set of boundaries, principles and practices rather than a one-time design exercise.

Chapter 1 — Trade-Offs in Data Systems Architecture
A broad architectural view of modern data systems and the decisions involved in choosing how they are structured.

• cloud versus self-hosting;
• distributed versus single-node systems;
• cloud-native architecture;
• microservices;
• serverless;
• operational versus analytical systems;
• systems of record and derived data.

Chapter 2 — Defining Nonfunctional Requirements
How system qualities influence architectural design.

• performance;
• latency;
• reliability;
• fault tolerance;
• scalability;
• operability;
• maintainability.

Chapter 5 — Encoding and Evolution
How independently evolving applications and services exchange data without becoming tightly coupled.

• schema evolution;
• JSON and binary formats;
• Protocol Buffers;
• Avro;
• REST;
• RPC;
• event-driven architectures;
• durable workflows.

Chapter 6 — Replication
The consequences of maintaining multiple copies of data across machines or regions.

Chapter 7 — Sharding
How data can be partitioned to distribute storage and workload.

Chapter 8 — Transactions
Transaction guarantees and the problems that arise when operations span multiple components.

• ACID;
• isolation;
• serializability;
• distributed transactions;
• Two-Phase Commit.

Chapter 9 — The Trouble with Distributed Systems
Partial failures, unreliable networks, timeouts and the uncertainty inherent in communication between independent machines.

Chapter 10 — Consistency and Consensus
The guarantees required when multiple nodes must agree on shared state.

Chapters 11–13 — Batch and Stream Processing
Architectures built around dataflows, event streams, change propagation and derived state.

• ETL;
• batch processing;
• message brokers;
• event streams;
• Change Data Capture;
• stream processing;
• derived state;
• data integration.