Every enterprise technology book faces the same risk: it describes a snapshot of tooling that will look dated within eighteen months. This book was written with that risk in mind, and the choice made throughout is to prioritize the reasoning behind enterprise practice over the specific vendor, version, or benchmark that happens to be current at the time of writing. Tools change constantly. The underlying problems — how to move change into production safely, how to keep a distributed system observable, how to grant a machine enough authority to be useful without enough to be dangerous — change far more slowly, if they change at all.
This book grew out of a simple observation, stated plainly in Chapter 1 and revisited in every chapter after it: the enterprise operating models of the pre-2000 era were not primitive versions of what we do today. They were coherent systems, well adapted to their constraints, built around controls — change approval, segregation of duties, capacity planning, disaster recovery testing — that existed for concrete, well-understood reasons. DevOps, cloud engineering, platform engineering, SRE, DevSecOps, and now AI and agentic operations are not replacements for that discipline. They are the same discipline, re-implemented as automation, so that the trade-off between speed and safety — which was real and unavoidable when every control required a human and a form — stops being a trade-off at all. That reframing is the thesis this book returns to, chapter after chapter, technology after technology: automation does not remove control, it relocates it into code, which is what finally allows organizations to be both fast and safe rather than choosing between them.
Who This Book Is For
This is a book for people who are accountable for enterprise technology decisions and their consequences — platform engineers building the golden paths that hundreds of other engineers will depend on; SRE and operations leaders responsible for keeping distributed systems reliable under real load; security and governance professionals who need to reason about AI and agentic systems without either dismissing the risk or being paralyzed by it; and technology executives who need to sponsor multi-year transformation programmes and explain, credibly, what they will produce.
It assumes no single starting point. A reader coming from a mainframe or client-server background will find Chapter 1 a deliberately unromantic account of what that era actually got right and where its assumptions broke down. A reader who has spent a career in cloud-native environments may find the early chapters familiar and will get more from the AI, agentic, and governance material in the second half. The book is built so that each chapter stands on the shoulders of the ones before it — Kubernetes assumes the cloud material in Chapter 3; agentic AI assumes the single-model AI engineering discipline in Chapter 8; multi-agent systems assume everything in the chapter before it — but a reader with existing expertise in a given layer should feel free to start wherever their gap actually is.