Site Reliability Engineering: From Foundations to Internet-Scale Systems — Notes

SRE

If this were a book, this page is the table of contents. This isn’t a copy of Google’s Site Reliability Engineering book — it teaches SRE in the order real expertise actually develops: from operating a single service to running thousands of services globally. Unwritten chapters are listed as stub rows, not empty files.

The sequence also mirrors how MAANG SRE interview loops actually progress: infrastructure fundamentals (Linux, networking, distributed systems) → cloud-native platforms (Kubernetes, IaC, GitOps) → reliability engineering (SLIs, SLOs, error budgets, resiliency) → observability (OpenTelemetry, Prometheus, Grafana, logs, tracing) → operations (incident response, on-call, postmortems) → performance and scalability → platform engineering and large-scale architecture → leadership and interview preparation. For Staff/Principal-level prep, this builds technical depth first, then expands into organizational design and architectural judgment — the areas L6/L7 loops actually evaluate.

Parts

00 — Foundations of Site Reliability Engineering

What SRE actually is, how it diverged from DevOps and Platform Engineering, and the ownership and lifecycle mechanics — production readiness, shared ownership, cost/reliability/velocity trade-offs — that everything later in this book assumes.

1 — What is Site Reliability Engineering? — (stub)
2 — History of SRE (Google and Beyond) — (stub)
3 — DevOps vs SRE vs Platform Engineering — (stub)
4 — Reliability as an Engineering Discipline — (stub)
5 — Service Lifecycle — (stub)
6 — Production Readiness Reviews — (stub)
7 — Reliability Engineering Mindset — (stub)
8 — Shared Ownership Model — (stub)
9 — Cost, Reliability and Velocity Trade-offs — (stub)

01 — Linux, Networking and Operating Systems

The operating-system and network-stack fundamentals underneath every production incident — Linux internals, TCP/IP, DNS, HTTP, TLS, and the edge layer (load balancers, proxies, CDNs) a service actually runs on.

1 — Linux Internals Every SRE Must Know — (stub)
2 — Processes, Threads and Scheduling — (stub)
3 — Memory Management — (stub)
4 — Filesystems and Storage — (stub)
5 — TCP/IP Deep Dive — (stub)
6 — DNS — (stub)
7 — HTTP/1.1 — (stub)
8 — HTTP/2 — (stub)
9 — HTTP/3 — (stub)
10 — gRPC — (stub)
11 — TLS and Certificates — (stub)
12 — Load Balancers — (stub)
13 — Reverse Proxies — (stub)
14 — CDNs — (stub)
15 — Linux Troubleshooting — (stub)

02 — Distributed Systems for SRE

The theory an SRE must apply, not design, under incident pressure — CAP, consensus, distributed transactions, and the coordination primitives (locks, leader election, service discovery) that fail in specific, learnable ways.

1 — CAP Theorem — (stub)
2 — Consensus Algorithms — (stub)
3 — Raft — (stub)
4 — Paxos — (stub)
5 — Distributed Transactions — (stub)
6 — Eventual Consistency — (stub)
7 — Leader Election — (stub)
8 — Distributed Locks — (stub)
9 — Time Synchronization — (stub)
10 — Distributed Caching — (stub)
11 — Service Discovery — (stub)
12 — API Gateways — (stub)
13 — Message Brokers — (stub)
14 — Event-Driven Architectures — (stub)

03 — Cloud and Infrastructure

The cloud-native infrastructure layer — VMs, containers, Kubernetes, multi-region topology, and the IaC/GitOps discipline that keeps that infrastructure reproducible instead of hand-tuned.

1 — Virtual Machines — (stub)
2 — Containers — (stub)
3 — Kubernetes Fundamentals — (stub)
4 — Kubernetes Scheduling — (stub)
5 — Networking in Kubernetes — (stub)
6 — Storage in Kubernetes — (stub)
7 — High Availability Clusters — (stub)
8 — Autoscaling — (stub)
9 — Multi-Cluster Architectures — (stub)
10 — Multi-Region Deployments — (stub)
11 — Infrastructure as Code — (stub)
12 — Immutable Infrastructure — (stub)
13 — GitOps — (stub)
14 — Configuration Management — (stub)

04 — Reliability Engineering

The reliability-target mechanics — SLIs, SLOs, error budgets — and the resiliency patterns (circuit breakers, backpressure, bulkheads, idempotency) that make a system actually hit those targets under real failure.

1 — Reliability Principles — (stub)
2 — Service Level Indicators (SLIs) — (stub)
3 — Service Level Objectives (SLOs) — (stub)
4 — Error Budgets — (stub)
5 — Availability Engineering — (stub)
6 — Latency Engineering — (stub)
7 — Capacity Planning — (stub)
8 — Scalability Engineering — (stub)
9 — Reliability Modeling — (stub)
10 — Failure Domains — (stub)
11 — Redundancy Patterns — (stub)
12 — Graceful Degradation — (stub)
13 — Backpressure — (stub)
14 — Queue Management — (stub)
15 — Load Shedding — (stub)
16 — Circuit Breakers — (stub)
17 — Retry Strategies — (stub)
18 — Timeouts — (stub)
19 — Bulkheads — (stub)
20 — Idempotency — (stub)

05 — Observability Engineering

Metrics, logs, and traces as the three signals that turn ‘is this healthy’ from a guess into an answerable question, and the Prometheus/Grafana/Loki/Tempo stack most teams answer it with.

1 — Observability Foundations — (stub)
2 — Telemetry Signals — (stub)
3 — Metrics — (stub)
4 — Logs — (stub)
5 — Distributed Tracing — (stub)
6 — OpenTelemetry — (stub)
7 — Context Propagation — (stub)
8 — Instrumentation Strategies — (stub)
9 — Prometheus — (stub)
10 — Grafana — (stub)
11 — Loki — (stub)
12 — Tempo — (stub)
13 — Alerting Philosophy — (stub)
14 — Alert Fatigue — (stub)
15 — Dashboard Design — (stub)
16 — High-Cardinality Metrics — (stub)
17 — Sampling Strategies — (stub)
18 — Cost Optimization — (stub)

06 — Incident Management

The response structure — command system, on-call design, escalation — and the review discipline — RCA, Five Whys, blameless postmortems — that turns an incident into a system that fails the same way at most once.

1 — Incident Response Lifecycle — (stub)
2 — Severity Classification — (stub)
3 — Incident Command System — (stub)
4 — On-call Engineering — (stub)
5 — Escalation Policies — (stub)
6 — Runbooks — (stub)
7 — Playbooks — (stub)
8 — Root Cause Analysis — (stub)
9 — Five Whys — (stub)
10 — Blameless Postmortems — (stub)
11 — Communication During Incidents — (stub)
12 — Chaos Engineering — (stub)
13 — Game Days — (stub)

07 — Performance Engineering

Profiling, load/stress/soak testing, and the systematic method for finding and removing a system’s actual bottleneck instead of the one that’s easiest to see.

1 — Performance Fundamentals — (stub)
2 — CPU Profiling — (stub)
3 — Memory Profiling — (stub)
4 — Disk Performance — (stub)
5 — Network Performance — (stub)
6 — Benchmarking — (stub)
7 — Load Testing — (stub)
8 — Stress Testing — (stub)
9 — Spike Testing — (stub)
10 — Soak Testing — (stub)
11 — Capacity Testing — (stub)
12 — Performance Bottlenecks — (stub)
13 — Performance Optimization — (stub)

08 — CI/CD and Release Engineering

Shipping changes safely at speed — progressive delivery, canaries, feature flags, and the rollback discipline that makes ‘ship fast’ and ‘stay reliable’ the same goal instead of a trade-off.

09 — Security for SRE

Where security and reliability overlap for an SRE — identity, secrets, zero trust, and the incident-response and DR practices that both disciplines depend on.

1 — Identity and Access Management — (stub)
2 — Secrets Management — (stub)
3 — Zero Trust — (stub)
4 — Network Security — (stub)
5 — Kubernetes Security — (stub)
6 — Runtime Security — (stub)
7 — Incident Response for Security — (stub)
8 — Compliance — (stub)
9 — Disaster Recovery — (stub)
10 — Business Continuity — (stub)

10 — Data Systems

The reliability characteristics of the data layer specifically — replication, sharding, backup and recovery — as a discipline distinct from, but foundational to, service-level SLOs.

1 — Relational Databases — (stub)
2 — NoSQL Systems — (stub)
3 — Distributed Databases — (stub)
4 — Replication — (stub)
5 — Sharding — (stub)
6 — Backup Strategies — (stub)
7 — Recovery Strategies — (stub)
8 — Data Reliability — (stub)

11 — Platform Engineering

Reliability economics once you’re not running one service but the platform every other team’s services run on — self-service, golden paths, multi-tenancy, and platform-level SLOs.

1 — Platform Engineering Fundamentals — (stub)
2 — Internal Developer Platforms — (stub)
3 — Self-Service Infrastructure — (stub)
4 — Golden Paths — (stub)
5 — Kubernetes Platforms — (stub)
6 — Developer Experience — (stub)
7 — Multi-Tenant Platforms — (stub)
8 — Platform Reliability — (stub)

12 — Large Scale Architecture

What changes architecturally at planet scale — global traffic management, multi-region and multi-cloud topology, and the cost-vs-reliability math that gets harder, not easier, at that scale.

1 — Designing Planet-Scale Systems — (stub)
2 — Global Traffic Management — (stub)
3 — Edge Computing — (stub)
4 — Multi-Cloud Reliability — (stub)
5 — Active-Active Systems — (stub)
6 — Active-Passive Systems — (stub)
7 — Disaster Recovery Patterns — (stub)
8 — Cost vs Reliability — (stub)
9 — Sustainability Engineering — (stub)

13 — Leadership and Organizational SRE

Structuring an SRE practice, earning its adoption beyond the team that started it, and the influence-without-authority skills that define the Staff/Principal level of the role.

1 — Building an SRE Organization — (stub)
2 — Defining Reliability Strategy — (stub)
3 — Reliability Reviews — (stub)
4 — Executive Reliability Metrics — (stub)
5 — Engineering Culture — (stub)
6 — Hiring SREs — (stub)
7 — Mentoring Engineers — (stub)
8 — Technical Leadership — (stub)
9 — Organizational Scaling — (stub)

14 — MAANG SRE Interview Preparation

Loop-by-loop preparation for the SRE interview formats at Google, Meta, Amazon, Microsoft, Apple, and Netflix — Linux/networking/Kubernetes depth, live troubleshooting, reliability system design, and the Staff/Principal bar specifically.

1 — Linux Interview Questions — (stub)
2 — Networking Interview Questions — (stub)
3 — Kubernetes Interview Questions — (stub)
4 — Cloud Architecture Interview Questions — (stub)
5 — Distributed Systems Interview Questions — (stub)
6 — Observability Interview Questions — (stub)
7 — Incident Response Scenarios — (stub)
8 — Performance Debugging Interviews — (stub)
9 — Reliability Design Interviews — (stub)
10 — System Design for SRE — (stub)
11 — Troubleshooting Interviews — (stub)
12 — Behavioral Interviews for SRE — (stub)
13 — Staff/Principal SRE Interviews — (stub)
14 — End-to-End Production Case Studies — (stub)

Appendices

Appendix A — Linux Command Cheat Sheet
Appendix B — Networking Cheat Sheet
Appendix C — Kubernetes Cheat Sheet
Appendix D — PromQL Cheat Sheet
Appendix E — OpenTelemetry Cheat Sheet
Appendix F — Incident Response Templates
Appendix G — Postmortem Templates
Appendix H — Capacity Planning Worksheets
Appendix I — SRE Design Patterns
Appendix J — Reliability Anti-Patterns

Metadata


Author	Amit Singh
Scope	sre