Microservices

Course · 27 chapters · 12 parts · Picture-first guide to microservice patterns

Microservices, one picture at a time

27 chapters that build on Microservices Patterns by Chris Richardson, now enriched with ideas from Building Microservices, Bootstrapping Microservices, Practical Event-Driven Microservices Architecture and Decomposing the Database. Every idea starts as a diagram, with only a few plain words around it. Follow the story of FTGO, a food-delivery company escaping its monolith.

Learning path

The chapters follow the groups of the microservice pattern language: decomposition, communication, transactional messaging, data management, external APIs, testing, cross-cutting concerns, deployment and refactoring. Each pattern has one home chapter.

Part 1 Foundations

Monolith or microservices, and what you trade

  1. 01 Escaping monolithic hell Monolith types, when to move, gains, costs and the pattern map

Part 2 Decomposition

Finding service boundaries and modelling the domain

  1. 02 Decomposition strategies Coupling, cohesion, business capabilities, DDD subdomains and event storming
  2. 03 Designing business logic Aggregates, domain events, bounded contexts and clean service internals

Part 3 Communication style

Remote procedure invocation, messaging and brokers

  1. 04 Interprocess communication and synchronous APIs Remote procedure invocation: REST, gRPC, API contracts and service discovery
  2. 05 Asynchronous messaging and brokers Messaging, brokers, message types and topologies

Part 4 Transactional messaging and domain events

Outbox, log tailing, idempotent consumers and event design

  1. 06 Transactional messaging and idempotent consumers Transactional outbox, transaction log tailing, polling publisher, ordering
  2. 07 Domain events: design and schema evolution Event size, headers and envelopes, compatibility and versioning

Part 5 Data management

Database per service, sagas, event sourcing, API composition and CQRS

  1. 08 Database per service and the shared database Private data, the shared-database anti-pattern, views and reporting databases
  2. 09 Managing transactions with sagas Sagas, compensation, orchestration vs choreography, eventual consistency
  3. 10 Event sourcing Event streams, snapshots, the broker as event store, replay and compaction
  4. 11 Queries: API composition and CQRS API composition, CQRS views and caching reads

Part 6 External API and UI

API gateway, backends for frontends and UI composition

  1. 12 API gateway and backends for frontends Gateway, BFF, service mesh at the perimeter and GraphQL
  2. 13 UI patterns: micro frontends and live updates Frontend ownership, UI composition, read models and pushing events

Part 7 Testing

Unit, service component, contract and end-to-end tests

  1. 14 Testing strategy and unit tests Test pyramid, doubles, service tests with stubs and flaky tests
  2. 15 Integration, contract and end-to-end tests Service component tests, consumer-driven contracts, E2E and testing in production

Part 8 Cross-cutting concerns

Security, externalized configuration, chassis, observability and reliability

  1. 16 Security, configuration and the chassis Access tokens, defense in depth, externalized configuration, microservice chassis
  2. 17 Observability Health checks, log aggregation, distributed tracing, metrics and SLOs
  3. 18 Resilience and stability patterns Timeouts, retries, circuit breakers, bulkheads, CAP and chaos

Part 9 Deployment and scaling

Deployment patterns, serverless, pipelines and scaling

  1. 19 Deployment patterns and Kubernetes Service per VM or container, Kubernetes, IaC and progressive delivery
  2. 20 Serverless deployment Function as a Service, its limits, and choosing PaaS, FaaS or containers
  3. 21 Continuous integration and delivery pipelines CI, branching, pipelines, artifacts and repository layout
  4. 22 Scaling microservices Scaling axes, sharding, database scaling, caching and autoscaling

Part 10 Refactoring to microservices

Strangler application and decomposing the database

  1. 23 Refactoring: the strangler application Goals, strangler fig, integration glue and anti-corruption layers
  2. 24 Decomposing the database Data ownership, synchronizing data, splitting tables and the decision guide

Part 11 Organization

Teams and evolutionary architecture

  1. 25 Teams and evolutionary architecture Conway's law, team types, ownership and the architect's role

Part 12 Hands-on: FlixTube

Build and run a real microservices app end to end

  1. 26 Building your first microservices Node, Docker, Compose, storage and messaging, hands on
  2. 27 FlixTube and running in production The full app, logging, debugging, reliability and scaling