Microservices
Microservices are less a technology than a decision about organisational coupling. Once a codebase and a team both grow past a certain size — usually around thirty engineers, sometimes earlier — the cost of coordinating changes inside a single deployable exceeds the cost of running many smaller ones. That is when microservices earn their keep. Below that threshold they are almost always a mistake: extra latency, extra failure modes, extra operational surface, and no team-scaling benefit to pay for it. This track treats microservices as an architectural choice with real trade-offs, not a default.
What this track covers
Service decomposition heuristics, the API gateway pattern, service discovery with Eureka, circuit breakers and bulkheads with Resilience4j, distributed tracing, asynchronous integration with Kafka, the transactional-outbox pattern, saga orchestration vs choreography, and the operational disciplines (contract testing, canary releases, dependency graphs) that keep a fleet of services from becoming a distributed monolith.
Who this is for
Engineers who have shipped at least one production monolith and are being asked to split it, and platform engineers designing the shared runtime (gateway, service mesh, telemetry) that many product teams will build on top of.
Prerequisites
- Comfortable building and deploying a single service (Spring Boot, FastAPI or equivalent)
- Familiarity with HTTP, JSON APIs and at least one message broker concept
- Basic Docker — building an image, running a container, exposing a port
- An understanding of why a database transaction is not free
Recommended learning order
// beginner
Read the Spring Boot microservices architecture guide to build a mental model of the moving parts. Add service discovery with Eureka and an API gateway with Spring Cloud Gateway. At this stage you should be able to describe why a request from a browser reaches the right service and how that service finds its peers.
// intermediate
Add resilience with the circuit breaker guide, wire services together asynchronously using Kafka, and study the transactional-outbox pattern so your service-to-service writes stay consistent. Introduce distributed tracing and a shared error contract.
// advanced
Move into the operational and organisational layer: service ownership, contract testing, dependency graphs, capacity planning per service, and the strangler-fig pattern for peeling functionality off a legacy monolith. This is also where the architecture patterns from the Software Architecture track — CQRS, event sourcing — become relevant tools.
Common mistakes to avoid
- Splitting by technical layer (one 'API service', one 'DB service') instead of by business capability — you end up with a distributed monolith with worse latency
- Sharing a single database between services and calling it 'microservices' — you have a monolith with extra network hops
- Skipping the circuit breaker and letting one slow downstream service exhaust every caller's thread pool
- Doing synchronous request/response everywhere and being surprised by cascading failure when one node is slow
- Adopting Kubernetes and a service mesh before you have three services to run on them
Career relevance
Microservices experience is heavily weighted in senior and staff-level backend interviews. Companies rarely need a junior to design a service boundary, but they always need someone who has watched a poorly-drawn boundary cost the team six months. Roles that ask for 'distributed systems experience' are almost always asking for this.
Featured tutorials in this track
Designing Event-Driven Microservices with Kafka and Spring Boot
A complete production guide to event-driven microservices with Kafka and Spring Boot — producers, consumers, topics, partitions, consumer groups, retry strategies, schema evolution and operational best practices.
Event-Driven Architecture with Spring Boot and Kafka — Building Reactive Distributed Systems
Design and implement event-driven systems with Spring Boot and Kafka — producers, consumers, schemas, idempotency, dead-letter queues and production-grade patterns.
Implementing Distributed Locking with Java Spring Boot and Redis for Data Integrity
A production guide to distributed locking with Spring Boot and Redis (Redisson) — preventing race conditions, ensuring idempotency, and handling failure gracefully in high-concurrency systems.
Design and Implement a Multi-Region Load Balancing Strategy with Netflix Ribbon and Eureka
Build a multi-region, highly available Spring Cloud system with Eureka service discovery and Netflix Ribbon client-side load balancing — including region-aware routing, failover and Docker Compose setup.
Spring Boot Microservices Architecture Explained Step by Step
A complete, beginner-friendly walkthrough of microservices architecture using Spring Boot — services, gateway, discovery, config and observability.
How to Build a Spring Cloud Config Server
Step-by-step guide to building a centralized configuration server with Spring Cloud Config, Git-backed properties and dynamic refresh.
Circuit Breaker in Spring Boot with Resilience4j — Protect Your System from Overload
Stop cascading failures in microservices. Add a Resilience4j circuit breaker to any Spring Boot call in under 10 minutes.
Spring Cloud Gateway — Routing, Filters and Auth in One Place
Build a production API gateway with Spring Cloud Gateway: routing, JWT auth, rate limiting and request logging.
+ 1 more tutorials in this track — browse the full archive.