Learning Resources

This module is populated from the local chunked books in library/raw/semester-08-system-design-leadership/books and selected canonical web articles. Use this page as a source map, not as an instruction to read everything.

Source Stack

Source	Role	How to use it in this module
Microservice Architecture	Local primary substitute	Use the local chunked book first for decomposition, service boundaries, contracts, and operational tradeoffs
Microservices Patterns (Chris Richardson)	Primary teaching source	Default escalation for patterns catalog and code-level examples; site: microservices.io
Fundamentals of Software Architecture (Richards & Ford)	Selective support	Use for architecture-style framing, modularity, event-driven style, and team practices
System Design Primer	Selective support	Short-form reinforcement for communication, async, discovery, and reliability vocabulary
Building Microservices (Sam Newman, 2nd ed.)	External companion	Useful if you already own it, but the local semester library now covers the main decomposition path with other sources
Team Topologies (Skelton & Pais)	Organizational context	Only for concept 15 and the reorganizational parts of the decomposition memo
Release It! (Michael Nygard)	Resilience vocabulary	Only when cluster 4 primitives are not sticking

Primary-Concept -> Book-Chunk Map

Every primary concept has multiple local chunks linked in its "Read This Only If Stuck" section. This map shows the primary anchors; the concept files themselves cite additional supporting chunks.

#	Concept	Local chunks (primary + supporting)	Why
01	The Microservices Distillation	primer: Application Layer; FoSA: Monolithic vs Distributed; FoSA: Architecture Styles; FoSA: Choosing Appropriate Style; FoSA: Modularity	Canonical short definition + style comparison + selection framework
02	Why Not Microservices (cost model)	FoSA: Monolithic vs Distributed; primer: Application Layer (disadvantages); FoSA: Engineering Practices; FoSA: Operations/DevOps; FoSA: Analyzing Trade-offs; primer: Performance vs Scalability	Cost framing, readiness capabilities, and the scale rebuttal
03	Monolith-First and Strangler-Fig	FoSA: Modularity; FoSA: Measuring Modularity; FoSA: Component-Based Thinking; FoSA: Discovering Components; FoSA: Connascence; primer: Asynchronism	Modular-monolith anchor + seam metrics + coupling vocabulary
04	Bounded Contexts as Service Boundaries	FoSA: Have Business Domain Knowledge; FoSA: Architecture Styles; FoSA: Component-Based Thinking; FoSA: Discovering Components; FoSA: Case Study -- Silicon Sandwiches; FoSA: Connascence	Domain-first framing; S7 M3 carries DDD in depth
05	Decomposition Heuristics	FoSA: Component-Based Thinking; FoSA: Discovering Components; FoSA: Case Study -- Going Going Gone; FoSA: Silicon Sandwiches Partitioning; primer: Application Layer	Discovery-by-capability with worked examples
06	Distributed-Monolith and Entity-Service Anti-Patterns	FoSA: Modularity; FoSA: Measuring Modularity 1+2; FoSA: Connascence; FoSA: Reuse and Coupling; FoSA: Fitness Functions; primer: Application Layer disadvantages	Connascence gives precise coupling vocabulary; fitness functions enforce
07	Database-Per-Service	primer: Database Federation; primer: RDBMS Replication; primer: SQL or NoSQL; primer: Consistency Patterns; primer: CAP Theorem; FoSA: Database Partitioning; FoSA: Preventing Data Loss	Federation is the physical analogue; CAP + consistency frame the trade-off
08	Service Contracts	primer: RPC and REST; primer: Asynchronism; primer: HTTP; primer: TCP/UDP; FoSA: Communication; FoSA: Request-Reply; FoSA: Async Capabilities; FoSA: ADRs	Both contract shapes + ADR discipline for changes
09	Consumer-Driven Contract Testing	FoSA: Testing Checklist; FoSA: Fitness Functions; FoSA: Measuring Characteristics; FoSA: Engineering Practices; primer: RPC/REST; primer: Asynchronism	CDC inside the fitness-function discipline
10	Sync vs Async	primer: RPC/REST; primer: Asynchronism; primer: HTTP; primer: TCP/UDP; primer: Consistency Patterns; FoSA: Event-Driven Style; FoSA: Mediator Topology; FoSA: Async Capabilities; FoSA: Preventing Data Loss; FoSA: Request-Reply; FoSA: Communication	Full two-sided treatment with trade-offs
11	Discovery, Gateways, BFF	primer: Application Layer; primer: Load Balancer; primer: Reverse Proxy; primer: DNS; primer: CDN; primer: Security; FoSA: Operations/DevOps; FoSA: Architecture Styles	Discovery + edge-routing + the concerns the gateway centralizes
12	Resilience Primitives	primer: Availability Patterns; primer: Performance vs Scalability; primer: CAP Theorem; primer: Latency vs Throughput; FoSA: Preventing Data Loss; FoSA: Characteristics Ratings; FoSA: Fitness Functions	Availability primitives + SLO math
13	Distributed Tracing	FoSA: Operations/DevOps; FoSA: Measuring Characteristics; FoSA: Fitness Functions; FoSA: Engineering Practices; primer: Availability Patterns; primer: Latency vs Throughput	Observability practice + how traces feed fitness checks
14	Deployment Independence	FoSA: Engineering Practices; FoSA: Operations/DevOps; FoSA: Fitness Functions; FoSA: Architecture Decisions; FoSA: ADRs; FoSA: Connascence; primer: RDBMS Replication; primer: Consistency Patterns	Practices + fitness-function framing + ADR-per-breaking-change
15	Team Topology	FoSA: Making Teams Effective; FoSA: Team Warning Signs; FoSA: Integrating with Dev Team; FoSA: Armchair Architect; FoSA: Architect as Leader; FoSA: Leading by Example; FoSA: Negotiation; FoSA: Checklists; primer: Application Layer	Operational team practices + leadership framing

Canonical Web Articles (Free, Authoritative)

Use these as the primary teacher when the local books are too terse or too generic. These are the references cited across every serious microservices team.

Cluster 1 -- When and Why

• Martin Fowler & James Lewis, Microservices -- the original definition article.
• Martin Fowler, MicroservicePremium -- the cost model in one page.
• Martin Fowler, MicroservicePrerequisites -- the capabilities required.
• Martin Fowler, MonolithFirst.
• Stefan Tilkov, Don't start with a monolith -- the counter-view.
• Martin Fowler, StranglerFigApplication.
• Martin Fowler, BranchByAbstraction -- the underlying technique.
• Sam Newman, Strangler Fig pattern (samnewman.io).
• Sam Newman, Principles of Microservices -- the 7 principles.
• Chris Richardson, What are microservices? (microservices.io).
• Chris Richardson, Refactoring to microservices.
• AWS Prescriptive Guidance, Strangler fig pattern.
• Microsoft Learn, Strangler Fig pattern.
• Jimmy Bogard, You want modules, not microservices -- counter-argument.
• Sam Newman, Building Microservices 2nd ed. book site.
• ThoughtWorks Radar, Microservices.
• Shopify Engineering, Deconstructing the monolith -- modular-monolith case study.

Cluster 2 -- Finding Service Boundaries

• Martin Fowler, BoundedContext.
• Eric Evans, DDD Reference (PDF).
• Chris Richardson, Decompose by business capability.
• Chris Richardson, Decompose by subdomain.
• Chris Richardson, Anti-pattern: distributed monolith.
• Chris Richardson, Microservice chassis pattern -- positive alternative to shared-DTO anti-pattern.
• Sam Newman, Finding microservice boundaries (talk).
• Sam Newman, When to use (and not use) microservices.
• Alberto Brandolini, EventStorming -- the workshop technique for discovering contexts + capabilities.
• Nick Tune, Strategic DDD diagrams.
• Vaughn Vernon, DDD and Microservices (video).
• Michael Nygard, Design Microservice Architectures the Right Way (talk).
• ThoughtWorks Radar, Event Storming.
• InfoQ, DDD and Microservices with Context Mapper.

Cluster 3 -- Data Ownership and Contracts

• Chris Richardson, Database per service.
• Chris Richardson, Shared database (anti-pattern).
• Chris Richardson, Transactional Outbox.
• Chris Richardson, Messaging pattern.
• Chris Richardson, RPI pattern.
• Martin Fowler, TolerantReader.
• Martin Fowler, PolyglotPersistence.
• Martin Fowler, Consumer-Driven Contracts (Ian Robinson).
• Martin Fowler, ContractTest.
• Martin Fowler, TestPyramid -- context for CDC.
• Martin Fowler, What do you mean by "Event-Driven"?.
• Pact Foundation, docs.pact.io.
• Pactflow, What is contract testing?.
• Spring, Spring Cloud Contract.
• Confluent, Schema evolution and compatibility.
• Confluent, Change data capture with Debezium.
• CloudEvents, cloudevents.io.
• OpenAPI Specification, spec.openapis.org.
• Google, API Design Guide -- Versioning.
• Microsoft, REST API guidelines -- Versioning.
• Microsoft Learn, Database per service.
• Pat Helland, Life beyond Distributed Transactions.
• ThoughtWorks Radar, CDC testing.
• InfoQ, Contract tests in the cloud native era.

Cluster 4 -- Service Communication

• Chris Richardson, API Gateway pattern.
• Chris Richardson, Service discovery patterns.
• Chris Richardson, Saga pattern -- choreography vs orchestration.
• Chris Richardson, Circuit Breaker pattern.
• Sam Newman, Backends for Frontends (BFF).
• Phil Calçado, BFF at SoundCloud.
• Martin Fowler, CircuitBreaker.
• resilience4j, Getting started.
• Netflix Tech Blog, Making the Netflix API More Resilient (Hystrix).
• AWS Builders' Library, Timeouts, retries, and backoff with jitter.
• Google SRE Book, Handling Overload.
• Google SRE Book, Addressing Cascading Failures.
• Google, gRPC concepts.
• AWS, Microservices communication patterns.
• Jeff Dean & Luiz Barroso, The Tail at Scale.
• CNCF, Service Mesh landscape.
• Istio documentation, Traffic management.
• ThoughtWorks Radar, Service mesh (Istio).
• InfoQ, Resilience Engineering: The What and How.

Cluster 5 -- Operating Microservices

• Chris Richardson, Distributed Tracing pattern.
• OpenTelemetry, Concepts: Traces.
• OpenTelemetry, Logs specification.
• W3C, Trace Context.
• CloudEvents, Distributed Tracing extension.
• Google, Dapper paper -- the origin of distributed tracing.
• Google SRE Book, Monitoring Distributed Systems.
• Charity Majors, Observability ≠ Monitoring.
• Honeycomb, Distributed tracing docs.
• Grafana, Tempo documentation.
• Martin Fowler, ParallelChange -- expand-contract.
• Martin Fowler, BlueGreenDeployment.
• Martin Fowler, CanaryRelease.
• Pete Hodgson (martinfowler.com), Feature Toggles.
• Jez Humble, Continuous Delivery (site).
• Google, API Design Guide -- Compatibility.
• AWS, Database migration strategies.
• Martin Fowler, TeamTopologies.
• Martin Fowler, ConwaysLaw.
• Matthew Skelton & Manuel Pais, teamtopologies.com.
• Melvin Conway, How Do Committees Invent? -- original Conway's Law paper.
• Will Larson, Staff Engineer archetypes.
• ThoughtWorks Radar, Inverse Conway Maneuver.
• ThoughtWorks Radar, Trunk-based development.
• InfoQ, Spotify Model survey (Skelton commentary).

Video Lectures (Optional)

One hand-picked video per cluster, only when reading isn't enough.

• Martin Fowler & James Lewis, Microservices (60m) -- the original talk; pair with the article.
• Eric Evans, DDD and Microservices: At Last, Some Boundaries (45m) -- bounded contexts for service boundaries.
• Chris Richardson, Microservices patterns tutorial -- his channel; pick one 45m talk on decomposition.
• Michael Nygard, Architecture Without an End State -- resilience + architectural evolution.
• Matthew Skelton, Team Topologies talks -- any 30m version.

Books (Deep Dive, Optional)

• Sam Newman, Monolith to Microservices -- the whole strangler-fig playbook.
• Chris Richardson, Microservices Patterns -- if you want to go deeper on sagas, CQRS, and testing strategies (next module, S8 M3, leans on this).
• Michael Nygard, Release It! (2nd ed.) -- the reliability canon.
• Matthew Skelton & Manuel Pais, Team Topologies.

Use Rules

• If you are stuck on decomposition, open the microservices.io pattern page for that lens first; then go to Newman's book.
• If you are stuck on contracts, open Pact docs or the Fowler TolerantReader article; both are 10-minute reads.
• If you are stuck on resilience, open the microservices.io circuit-breaker page, then resilience4j docs for concrete semantics.
• If you are stuck on operations, start with OpenTelemetry docs; the local chunks are thinner in this area by design.
• Do not open three books at once. Open one chunk for one concept gap, answer, close.