Deep-dive appendices
Backup material for the questions that always come up: protocols through failure modes, plus a glossary.
Protocols in Depth
The deep dive behind 'pick the protocol' — REST, gRPC, and GraphQL compared on three axes: the mental model each imposes, how each handles fetching and round trips, and what actually travels on the wire.
Versioning & Evolution
How to change an API without breaking everyone — the four ways to version REST, what counts as a breaking change in protobuf, GraphQL's evolve-don't-version stance, and the principles common to all three.
WebSockets at Scale
The protocol we left out of the main interaction styles, because it behaves so differently on Kubernetes — why long-lived sockets fight stateless scaling, and the pub/sub backplane plus resume-don't-restart posture that fix it.
Saga State & Compensation
The deep mechanics behind the saga — where the orchestrator keeps state so it survives a crash, how compensation unwinds committed steps in reverse, and how to thread one step's output to the next without coupling the services.
API Error Handling
One error contract — a stable code, a safe message, a trace id, a retryable flag, field details — mapped onto REST, gRPC, Kafka and GraphQL, plus the retry-storm controls that keep a single failure from becoming an outage.
DDD & Hexagonal Architecture
Where service boundaries and API contracts come from — strategic DDD to place the lines, tactical DDD to model inside them, and hexagonal architecture to keep REST, gRPC, GraphQL and Kafka out of the domain.
Balancing Coupling
Coupling has three dimensions — integration strength, distance, and volatility — and it only hurts when all three are high at once, which is why looser is not automatically better and why splitting a system can make coupling worse.
Graceful Shutdown
Shutting a pod down without dropping work — a short protocol between the app and Kubernetes: fail readiness first, cover the deregistration race, drain HTTP and consumers inside the grace budget, and stay idempotent for the inevitable hard kill.
L7 Routing & Traffic Management
Layer-7 routing as a four-layer stack of software — edge, gateway, mesh, and in-app — that decides on every HTTP and gRPC envelope, north/south and east/west, including rule-driven routing pushed inside the service.
.NET 10 Toolkit & Migration Reference
.NET-only reference: the pinned .NET 10 library and platform bill of materials, a Windows-to-Kubernetes migration table, an honest list of ecosystem gaps, and a six-library recipe for a new cloud-native service.
Monolith to Microservices
Decomposing a monolith with the system still running — the modular monolith as a frequent destination, the strangler-fig family (identify, move, redirect), content-based routing for fine-grained cutover, and the decorating collaborator for legacy you can't touch.
Caching Patterns
Six standard caching patterns — cache-aside, read-through, write-through, write-around, write-back, and refresh-ahead — each with its consistency story, its failure mode, and when to reach for it; plus the anti-patterns and a decision guide.
Failure Modes
The synthesis appendix — a taxonomy of how distributed systems actually fail (partition, split-brain, partial, gray, amplification, cascading) and the defensive toolkit mapped to each: timeouts and deadlines, retry with backoff and jitter, circuit breakers, bulkheads, load shedding, quorum, and the mesh.
Feature Flags & Progressive Delivery
Decoupling deploy from release with feature flags: the four flag types, evaluating flags with OpenFeature and flagd, targeting and sticky-bucketed percentage rollouts, kill switches, flags as a control plane over the book's patterns, and the lifecycle discipline that keeps flags from becoming debt.
API Testing with Newman
Turning Postman collections into an automated API test gate with Newman: the anatomy of a collection, writing assertions, running one collection against all six implementations, data-driven tests, schema and contract validation, and wiring it into CI on plain Docker Engine — no new test framework to learn.
.NET on Linux: Runtime, Kestrel, and Containers
.NET-specific primer: what C# compiles to, how the CoreCLR runtime works on Linux, what Kestrel does instead of IIS, and how multi-stage container builds produce minimal production images.
Blazor Server + SignalR
Real-time server-rendered UI with Blazor Server over a SignalR circuit — how the persistent connection works, the Redis backplane for scale-out, and when to choose SignalR over raw WebSockets.
Running Example 05 on minikube
Example 05 on a single-node Kubernetes cluster: minikube with the Docker driver, Strimzi for Kafka, kustomize overlays for six languages, loopback NodePorts instead of tunnels, and the same verify.sh against compose and the cluster.
Acronyms
Every acronym used across the book, expanded and placed in context — grouped by where it shows up: the wire, the data layer, events, the platform, security, observability, and the domain.