Spring Cloud

A single Spring Boot service is easy to reason about. Ten of them, calling each other over an unreliable network, are not — this module is exactly what changes, and why an entire ecosystem of tools exists just to manage that change.

Ten services each with their own application.properties means changing one shared value ten separate times. This module is the single source of truth that replaces that.

A service instance's IP address changes every time Kubernetes reschedules it. This module is how one service finds another without ever hardcoding where it lives.

Calling another service shouldn't need the same boilerplate every single time. This module is how OpenFeign turns a service-to-service call into one annotated Java interface.

OpenFeign is declarative and simple; WebClient is lower-level and non-blocking. This module is when the second one is actually the right tool.

Spring Boot Mastery's API Gateway module covered the concept. This module is Spring's own purpose-built implementation of it, and what it adds beyond a plain reverse proxy.

A slow, failing downstream service doesn't just fail its own calls — it can quietly take the caller down with it. This module is the pattern that stops that from spreading.

Circuit Breaker is Resilience4j's headline pattern, but three quieter ones next to it matter just as much in a real production system. This module is those three.

One request that touches five services produces five separate sets of logs, on five separate machines. This module is how to make that feel like ONE trace again.

Spring Boot Mastery's @Transactional works because one database can guarantee atomicity by itself. Once a business operation spans multiple SERVICES, each with its own database, that guarantee quietly disappears — this module is why, precisely.

If 2PC doesn't survive real production microservices, what actually does? This module is the pattern nearly every real distributed system uses instead.

One model for both reading and writing data works fine until reads and writes want completely different shapes, or completely different scale. This module is what happens when you finally split them.

Most systems store the current state and throw away how it got there. This module is what changes when you store the HISTORY instead, and derive current state from it.

Retry (from two modules back) quietly assumed something this module finally makes explicit: that calling an operation twice is safe. This module is what makes that actually true.

Every module in this category hardened or connected one piece. Here's how Config Server, Eureka, Gateway, Resilience4j, tracing, and Sagas assemble into one system that survives real failure.