Enterprise Distributed Architecture and Cloud-Native Platforms

Preface

Two engineers look at the same incident. The first sees a service that returned 503 for eleven minutes. The second sees a consumer group that rebalanced, a partition that moved, a retry budget that nobody set, and a circuit breaker that stayed closed because its window was too long. The difference is a model that reaches from the wire format up to the deployment topology.

This book builds that model for systems that run across many machines.

What the book covers

Part I covers the substrate. Chapter 1 takes apart transport: HTTP/3 stream multiplexing, kernel bypass, remote procedure call encoding, and the TLS 1.3 handshake. Chapter 2 covers agreement: Raft, the Paxos family, the consistency models that name what a reader can observe, and the protocols for a transaction that spans machines. Chapter 3 covers durable state: storage engine internals, partitioning, multi-leader replication, and concurrency control at scale.

Part II covers the architecture above it. Chapter 4 treats the append-only log as a primitive and builds event sourcing, exactly-once processing, and schema contracts on it. Chapter 5 covers service-to-service communication and the resilience patterns that keep a partial failure partial. Chapter 6 covers the edge: rate limiting, edge runtimes, zero trust authentication, and API aggregation.

Part III covers the runtime. Chapter 7 opens the container and the orchestrator. Chapter 8 covers telemetry, kernel tracing, tail latency, and the error budget arithmetic that decides when a page is justified. Chapter 9 covers the AI infrastructure layer: model serving, multi-accelerator parallelism, retrieval infrastructure, and the durable execution patterns that production agents need.

What the book assumes

The book assumes that you write code, that you operated something in production, and that you read a stack trace at an unreasonable hour. It does not assume a formal background in distributed systems, and it defines every term that it uses.

The book does not teach a framework. It teaches the mechanism under the framework, because the frameworks change every eighteen months and the mechanisms do not. Where a named product appears, it appears as an example of a mechanism rather than as a recommendation.

How to read it

Each chapter holds four sections, and each section is self-contained enough to read on its own. The table of contents lists every section with its page, so the book works as a reference as well as a text.

Read Chapter 2 before Chapter 3, and Chapter 4 before Chapter 5. The rest are close to independent. An engineer who owns a streaming platform can go straight to Chapter 4. An engineer who owns an inference cluster can go straight to Chapter 9, though Section 1.2 and Section 2.3 carry the transport and consistency assumptions that Chapter 9 relies on.

Five block types repeat through the book:

• A note block adds a fact that the main argument does not need.
• A warning block names a failure that costs money, data, or availability.
• A production block gives a rule that holds in a real deployment.
• A key numbers block gives the measurements for the section.
• A summary block ends each chapter with a set of claims.

Its relationship to Volume I

Volume I covers computer science fundamentals: computer architecture, kernel mechanics, data structures under real memory behavior, concurrency, language runtimes, design boundaries, storage engines, and consensus foundations. This volume goes deeper on distribution and on the cloud-native platform.

The two overlap in four places, and the treatment differs each time. Volume I introduces QUIC as a protocol choice, and Section 1.1 here takes apart its stream machinery. Volume I introduces Raft as one consensus algorithm among several, and Section 2.1 here works through its invariants and its membership change protocol. Volume I prices the storage engine families, and Section 3.1 here covers the compaction strategies and the write paths. Volume I introduces model serving, and Chapter 9 here covers the serving architecture in full.

You do not need Volume I to read this book. You need it if you want to know why a cache miss costs 80 nanoseconds and what that implies for the code you write.

On the writing

The book uses a controlled subset of English. Sentences stay under 25 words. The voice stays active. The modal verbs are can, will, and must. There are no contractions and no em-dashes. One word carries one meaning across the whole text.

A controlled language removes the second reading. An engineer who reads a runbook during an incident cannot afford a sentence that parses two ways. The same discipline applies to a book about distributed systems, where the subject already resists a first reading.