Learning path
Microservices Architecture learning path: everything to study, topic by topic
Comprehensive assessment covering microservices design, service decomposition, communication patterns, data management, resilience engineering, and production operations. Covers Sam Newman's core principles from Building Microservices through expert-level operational practices.
Short answer
To learn Microservices Architecture, work through 6 modules and 26 topics in the order they build on each other. It starts with Microservices Foundations, then moves on to Service Design and Communication Patterns. Use the map as a checklist, or measure your level and study only what is missing.
What you will study
Topics are grouped by module. Open one to see its objectives and key concepts.
1 · Microservices Foundations5 topics
Monolith vs Microservices Trade-offs
Examines the fundamental trade-offs between monolithic and microservices architectures. Covers when NOT to adopt microservices and the hidden operational costs of distribution.
Objectives
- Explain the core trade-offs between monolithic and microservices architectures with concrete examples
- Identify scenarios where a monolith is the better architectural choice
Key concepts
- monolith advantages
- distributed systems fallacies
- microservices operational overhead
- when NOT to use microservices
- coupling and cohesion at deployment level
- big ball of mud
- migration cost
Decomposition by Business Capability
Covers decomposing a system into services aligned with business capabilities. Explores how team structure and domain ownership drive service boundaries.
Objectives
- Define business capabilities and use them to identify service boundaries
- Explain how capability-based decomposition achieves loose coupling and high cohesion
Key concepts
- business capability
- capability map
- loose coupling by domain
- team-per-service
- Sam Newman decomposition
- service boundary
- domain ownership
Decomposition by Subdomain (DDD-Aligned)
Explores DDD-aligned decomposition using bounded contexts and subdomain classification. Covers the strangler fig pattern for migrating from monoliths.
Objectives
- Apply DDD bounded context mapping to identify microservice boundaries
- Use the strangler fig pattern to safely migrate a monolith to microservices
Key concepts
- bounded context
- core subdomain
- supporting subdomain
- generic subdomain
- strangler fig
- seam finding
- domain language alignment
Conway's Law and Organizational Design
Analyzes how team structure shapes system architecture via Conway's Law. Covers the inverse Conway maneuver and Team Topologies to align org design with microservices.
Objectives
- Explain how Conway's Law influences microservices boundaries in practice
- Apply the inverse Conway maneuver to reorganize teams around desired service structure
Key concepts
- Conway's Law
- inverse Conway maneuver
- team topologies
- stream-aligned team
- platform team
- enabling team
- cognitive load
Microservices Maturity Model
Assesses organizational and technical readiness for microservices adoption. Covers independent deployability, telemetry completeness, and zero-downtime deployment as maturity signals.
Objectives
- Assess an organization's microservices maturity level using key operational signals
- Identify the highest-priority gaps blocking independent deployability
Key concepts
- independent deployability
- operational maturity
- telemetry completeness
- service mesh readiness
- zero-downtime deployment
- automated rollback
- telemetry & observability
2 · Service Design5 topics
Service Granularity and Right-Sizing
Examines how to determine the right size for a microservice. Explores nanoservice anti-patterns and the disintegrators vs integrators framework.
Objectives
- Apply granularity disintegrators and integrators to determine optimal service size
- Identify nanoservice and chatty-service anti-patterns in a proposed architecture
Key concepts
- service granularity
- nanoservice anti-pattern
- chatty services
- service fan-out
- single responsibility at service level
- granularity disintegrators
- granularity integrators
API Contract Design (REST + gRPC)
Covers designing stable API contracts between services using REST and gRPC. Includes consumer-driven contract testing with Pact.
Objectives
- Design a stable API contract using either REST or gRPC with appropriate versioning
- Explain how consumer-driven contract testing catches breaking changes before deployment
Key concepts
- REST API design
- gRPC advantages
- contract-first design
- OpenAPI specification
- consumer-driven contracts
- Pact testing
- interface stability
Service Ownership and Team Alignment
Explores the 'you-build-it-you-run-it' model and how to assign clear ownership. Covers service catalogs, on-call responsibilities, and inner-source practices.
Objectives
- Define clear service ownership boundaries and accountability models for microservices teams
- Design a service catalog that communicates ownership, SLOs, and runbooks to the organization
Key concepts
- you-build-it-you-run-it
- service ownership
- two-pizza team
- CODEOWNERS
- service catalog
- on-call rotation
- inner source
API Versioning and Backward Compatibility
Covers strategies for evolving service APIs without breaking consumers. Explores URL versioning, header versioning, and backward-compatible change patterns.
Objectives
- Distinguish breaking from non-breaking API changes and choose the appropriate versioning strategy
- Design a deprecation policy that gives consumers adequate migration time
Key concepts
- semantic versioning
- URL versioning
- header versioning
- backward compatibility
- breaking vs non-breaking change
- Postel's law
- sunset headers
Service Mesh Architecture
Examines how a service mesh decouples cross-cutting concerns from application code. Covers sidecar proxies, control/data plane separation, and mutual TLS.
Objectives
- Explain the control plane / data plane split and how a sidecar proxy intercepts traffic
- Evaluate when a service mesh adds value vs when it adds unnecessary complexity
Key concepts
- sidecar proxy
- control plane
- data plane
- mutual TLS
- traffic shaping
- service discovery
- observability via mesh
3 · Communication Patterns5 topics
Synchronous Communication (REST, gRPC)
Covers the mechanics and risks of synchronous inter-service communication. Explores latency chains, fan-out amplification, and connection management.
Objectives
- Identify synchronous communication failure modes and their cascading effects
- Choose between REST and gRPC based on latency, streaming, and contract needs
Key concepts
- REST vs gRPC tradeoffs
- synchronous coupling
- latency chain
- fan-out amplification
- timeout propagation
- connection pooling
- load balancing
Asynchronous Messaging and Event-Driven Architecture
Explores asynchronous messaging patterns that decouple services in time. Covers the outbox pattern, idempotent consumers, and event schema evolution.
Objectives
- Implement the outbox pattern to ensure reliable event publishing alongside database writes
- Design idempotent consumers that handle at-least-once delivery without side effects
Key concepts
- message broker
- publish-subscribe
- at-least-once delivery
- idempotent consumer
- outbox pattern
- event schema evolution
- decoupling via events
Saga Pattern (Choreography and Orchestration)
Covers the saga pattern as the primary alternative to distributed transactions. Compares choreography-based and orchestration-based sagas and compensating transactions.
Objectives
- Design a saga for a multi-step business transaction with appropriate compensating transactions
- Choose between choreography and orchestration sagas based on complexity and observability needs
Key concepts
- saga pattern
- choreography-based saga
- orchestration-based saga
- compensating transaction
- saga state machine
- semantic rollback
- distributed transaction alternative
Request-Reply and Correlation IDs
Examines the request-reply pattern implemented over asynchronous messaging. Covers correlation IDs for tracing async conversations and handling timeouts.
Objectives
- Implement the request-reply pattern over a message broker using correlation IDs
- Handle async timeout scenarios without leaking resources or creating zombie replies
Key concepts
- correlation ID
- request-reply over messaging
- reply-to queue
- async request-response
- message tracing
- polling vs callback
- timeout in async
Message Broker Selection
Compares message broker options for microservices — Kafka, RabbitMQ, and SQS. Covers throughput, ordering guarantees, retention, and consumer group semantics.
Objectives
- Compare Kafka, RabbitMQ, and SQS across key dimensions to select the right broker for a use case
- Explain when log-based brokers outperform queue-based brokers and vice versa
Key concepts
- Kafka log-based broker
- RabbitMQ queue-based broker
- SQS managed queue
- consumer group
- message ordering guarantees
- retention policy
- throughput comparison
4 · Data Management4 topics
Database-per-Service Pattern
Explores the database-per-service pattern as the foundation of data isolation in microservices. Covers polyglot persistence and strategies for cross-service data access.
Objectives
- Explain why the shared database anti-pattern undermines independent deployability
- Design cross-service data access strategies that preserve service autonomy
Key concepts
- database-per-service
- shared database anti-pattern
- polyglot persistence
- join alternative strategies
- data ownership
- schema independence
- migration independence
Distributed Transactions and Sagas
Covers the pitfalls of two-phase commit in distributed systems and saga as the practical alternative. Explores idempotency keys and the transactional outbox for reliable messaging.
Objectives
- Explain why two-phase commit is impractical in microservices and how sagas replace it
- Design a transactional outbox to guarantee exactly-once event publishing
Key concepts
- two-phase commit pitfalls
- saga vs 2PC
- eventual consistency
- compensating transaction
- idempotency key
- transactional outbox
- saga orchestrator state
CQRS in Microservices
Explores Command Query Responsibility Segregation as a read-scaling pattern in microservices. Covers event-driven projections and managing eventual consistency between write and read models.
Objectives
- Design a CQRS system with separate write and read stores using event-driven projections
- Handle eventual consistency between the command and query sides without UI degradation
Key concepts
- CQRS pattern
- command side
- query side
- read model
- event-driven projection
- separate write/read databases
- eventual consistency between sides
Data Synchronization and Eventual Consistency
Examines strategies for keeping data consistent across services without distributed locking. Covers conflict resolution, anti-entropy, and read-your-writes consistency guarantees.
Objectives
- Apply conflict resolution strategies appropriate to the consistency requirements of a use case
- Explain how anti-entropy processes restore consistency after partition recovery
Key concepts
- eventual consistency
- conflict resolution strategies
- last-write-wins
- vector clocks
- anti-entropy
- read-your-writes
- causal consistency
5 · Resilience & Reliability4 topics
Circuit Breaker Pattern
Covers the circuit breaker pattern for preventing cascading failures in distributed systems. Explores state transitions, fallback strategies, and the bulkhead combination.
Objectives
- Implement a circuit breaker with appropriate thresholds to prevent cascading failures
- Design a meaningful fallback strategy for each downstream dependency
Key concepts
- circuit breaker states
- failure threshold
- recovery timeout
- fallback strategy
- Resilience4j
- cascading failure prevention
- bulkhead combination
Retry, Timeout, and Bulkhead Patterns
Examines retry strategies with exponential backoff and jitter to avoid thundering herds. Covers timeout budgets and bulkhead isolation with thread-pool and semaphore approaches.
Objectives
- Configure exponential backoff with jitter to prevent retry storms under load
- Design bulkhead partitions to isolate slow dependencies from fast paths
Key concepts
- exponential backoff
- jitter
- retry amplification risk
- timeout budget
- bulkhead isolation
- thread pool isolation
- semaphore isolation
Health Checks and Readiness Probes
Covers liveness, readiness, and startup probes for Kubernetes-deployed microservices. Explores dependency health aggregation and rolling restart safety.
Objectives
- Distinguish liveness, readiness, and startup probes and configure each correctly
- Design a health endpoint that aggregates dependency health without creating false negatives
Key concepts
- liveness probe
- readiness probe
- startup probe
- health endpoint pattern
- dependency health check
- rolling restart
- Kubernetes probe configuration
Chaos Engineering
Introduces chaos engineering as a disciplined approach to building confidence in resilience. Covers steady-state hypothesis, fault injection, blast radius control, and game day exercises.
Objectives
- Design a chaos experiment with a clear steady-state hypothesis and controlled blast radius
- Evaluate the outcome of a chaos game day and translate findings into resilience improvements
Key concepts
- steady-state hypothesis
- fault injection
- latency injection
- blast radius
- game day exercise
- Chaos Monkey
- Chaos Toolkit
6 · Microservices Operations3 topics
Distributed Tracing and Observability
Covers distributed tracing as the third pillar of microservices observability alongside metrics and logs. Explores trace context propagation, span relationships, and OpenTelemetry instrumentation.
Objectives
- Instrument a microservices call chain with OpenTelemetry to produce end-to-end traces
- Use distributed traces to diagnose latency spikes across multiple service hops
Key concepts
- distributed trace
- trace ID
- span
- context propagation
- OpenTelemetry
- Jaeger
- three pillars of observability
Deployment Strategies
Explores zero-downtime deployment patterns for microservices — canary, blue-green, and rolling. Covers traffic shifting, smoke tests, and automated rollback triggers.
Objectives
- Choose between canary, blue-green, and rolling deployment based on risk tolerance and infrastructure
- Design automated rollback criteria using error rate and latency SLOs as triggers
Key concepts
- canary deployment
- blue-green deployment
- rolling update
- feature flag
- traffic shifting
- smoke test
- rollback trigger
Service Discovery and Configuration Management
Covers client-side and server-side service discovery patterns and dynamic configuration. Explores service registries, DNS-based discovery, and secrets management.
Objectives
- Compare client-side and server-side service discovery and select the appropriate pattern
- Design a dynamic configuration system that allows runtime changes without service restarts
Key concepts
- service registry
- client-side discovery
- server-side discovery
- DNS-based discovery
- dynamic configuration
- secrets management
- Consul/etcd
Levels: Junior, Mid, and Senior
Explain it in your own words
Graded by AI · no account · 1 questionNo options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.
Already studying Microservices Architecture?
The assessment measures topic by topic, and your plan skips what you already know.
Open to read. An account is only needed to be measured.
Frequently asked questions
Where should I start studying Microservices Architecture?
Start with Microservices Foundations: Monolith vs Microservices Trade-offs, Decomposition by Business Capability, and Decomposition by Subdomain (DDD-Aligned). The map orders topics by what they depend on, so each one prepares the next.
How long does a full Microservices Architecture assessment take?
A full assessment of this path takes about 60 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.
Do I need an account to use this page?
No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.