SRE interview prep

• Admission Control — The SRE Book's approach to handling server overload: CPU-based throttling, per-client quotas, and criticality
• Alerting Philosophy — The SRE Book's alerting principles, multi-window multi-burn-rate, and avoiding alert fatigue.
• Aspirational vs Enforced SLOs — The middle path between "no SLO" and "halt-the-launches SLO" — and when to graduate from one to the other.
• Autoscaling Strategies — The Kubernetes autoscaling toolkit, when each fits, and predictive vs reactive scaling.
• Blameless Postmortems — The Google SRE Book postmortem template, what "blameless" really means, and how to extract action items that s
• Bulkheads — Per-dependency thread pools, the ship-bulkhead analogy, and how Hystrix popularized the pattern.
• Canary Analysis — The SRE Workbook's automated canary analysis methodology: metric selection, baseline comparison, automated rol
• Capacity Planning — The Google SRE Book's capacity planning model: predict demand, allocate resources, validate against reality.
• Cardinality & Observability Cost — Why cardinality blows up Prometheus, the math behind log/trace cost, and how to control them.
• Cascading Failure — The four canonical cascading-failure patterns from the SRE Book and how to prevent each.
• Cascading Failure at 3am — Walk through diagnosing and stopping a cascading failure spreading across services at 3am with incomplete info
• Choosing the Right SLI — The SRE Workbook's SLI taxonomy and how to pick which to measure for which service.
• CI/CD & Progressive Delivery — The deployment-strategy spectrum, when to use each, and SLO-gated automated rollback.
• Circuit Breakers — The three-state machine, why fail-fast beats hanging, and how circuit breakers prevent cascading failures.
• Configuration Management — SRE Workbook approach to configuration as code: validation, staged rollout, blast radius containment, and the
• Cost vs Reliability — Why each additional 9 costs 10×, FinOps for SRE, and the right cost-of-downtime conversation with finance.
• Critical User Journeys — How to find what to actually measure — the multi-step user task whose end-to-end success defines the service.
• Dashboards — Dashboard hierarchy (overview → service → resource), heatmaps for tail latency, and what NOT to put on a dashb
• Data Integrity — SRE Book Chapter 26 — reading what you wrote: checksums, soft deletes, backup validation, and why data loss is
• Database Capacity — The connection-pool ceiling, read replicas, write throughput, and sharding strategies.
• Design for Understandability — Building Secure and Reliable Systems Ch 6 — designing systems whose behavior is predictable, whose failure mod
• Disaster Recovery — Backup-restore vs pilot-light vs warm-standby vs multi-site active-active — cost, RTO, RPO, when to pick each.
• Distributed Consensus — When you actually need consensus, the algorithms (Paxos / Raft / Zab), and the CAP framing.
• Distributed Tracing — How traces work, head vs tail sampling, and why traces are the highest-leverage signal for microservice debugg
• DoS Attack Mitigation — From Building Secure and Reliable Systems Ch 10 — anycast, scrubbing centers, rate limiting tiers, and the arc
• Error Budget Exhausted — Mid-Sprint — Your service hits zero error budget with 2 weeks left in the sprint. Walk through the policy activation, stake
• Error Budgets — How to derive the budget from the SLO, what an error-budget policy looks like, and when to actually halt launc
• Facilitating a Blameless Postmortem — You are facilitating a postmortem for a SEV-1 that caused 2 hours of customer-facing downtime. Walk through ru
• Five Whys — The Toyota technique adapted for SRE: where it works, where it lies, and "contributing factors" as the modern
• Forecasting Models — How to forecast service load: simple growth, seasonal decomposition, Prophet / ARIMA, and when ML is overkill.
• Game Days & Chaos Engineering — Practicing failure deliberately. Google's DiRT, Netflix Chaos Monkey, modern chaos engineering tools.
• GitOps — Git as the source of truth for infrastructure and applications, the pull model, and reconciliation loops.
• Graceful Degradation — The art of returning a partial / cached / fallback response instead of failing.
• High Availability — N+1, N+2, the redundant-component formula, and why a single 99.9% box stays a single 99.9% box.
• Idempotency — What idempotency means precisely, idempotency keys, and the financial-systems pattern.
• Identifying Scaling Bottlenecks — Amdahl's Law, the NALSD method, and how Google does back-of-envelope on a whiteboard.
• Incident Command — The Google IRT structure (modeled on FEMA ICS): three roles, why "IC does not type," and when to escalate.
• Incident Communications — Status page discipline, the 15-minute update cadence, and the structure of executive briefs.
• Incident Metrics — The four canonical incident metrics, what each measures, and which actually matter for SRE.
• Infrastructure as Code — The IaC landscape, declarative vs imperative, and why state management is the hard part.
• Launch Coordination — SRE Book Chapter 27 — production readiness reviews, launch checklists, traffic ramping, and the structured pro
• Live Capacity Planning Scenario — An interviewer asks you to size a new service from scratch. Walk through demand forecasting, headroom calculat
• Load Shedding — How and when to deliberately reject requests so the rest succeed. Priority-based shedding, queue management, t
• Load Testing — Baseline / ramp / soak / spike / stress test methodology, tools (k6, Locust, JMeter), and production traffic r
• Logging Best Practices — Structured JSON over text, log levels, sampling, correlation IDs, and the cost reality.
• Modern Observability Stack — Grafana LGTM (Loki/Grafana/Tempo/Mimir), Datadog, Honeycomb, eBPF — the 2026 landscape.
• Multi-cloud Active-Active — Write-global, write-local, write-partitioned. The three real choices for cross-region writes.
• Multi-Region Latency Spike Diagnosis — Diagnosing latency spikes affecting users in one region but not others in a multi-region deployment.
• NALSD — Non-Abstract Large System Design — The SRE Workbook's structured approach to system design interviews: requirements quantification, component siz
• On-call Structure — How rotations work, the primary/secondary backup model, follow-the-sun for global teams.
• On-call Sustainability — Recognizing burnout signals, the SRE Workbook's sustainable on-call framework, and the metrics that protect en
• Pager Discipline — How to acknowledge, investigate, escalate, and close pages without burning out or losing customer trust.
• Performance Optimization — Where the latency goes, where to put cache, how deadlines propagate, and the SRE Book's rules for not making i
• RED, USE & Four Golden Signals — Three named methodologies for what to measure. Pick by what you're monitoring.
• Release Engineering — Hermetic builds, binary provenance, self-service pipelines, and the SRE Book's four principles that make relea
• Reliability & Security — Google's Building Secure & Reliable Systems framework, why security IS reliability, and the cross-discipline o
• Reliability Math — Every incident and reliability number you may be asked to compute on the spot — timeline metrics, SLI ratios,
• Retry, Jitter & Backoff — The exponential-backoff formula, why jitter is mandatory, and AWS's "full jitter" recommendation.
• Risk vs Feature Velocity — The economic + UX argument for setting reliability targets below 100%, and how to make the tradeoff legible to
• RTO vs RPO — How long until I'm up vs how much data can I lose. The two numbers that drive every DR decision.
• Runbooks — The runbook structure that works under stress, when to update them, and the path to runbook automation.
• Secret Management — Where secrets should live, the GitOps challenge, and modern secret-rotation patterns.
• Security Incident Response — How security incidents differ from reliability incidents. The NIST framework, forensics, legal obligations.
• Self-healing — Kubernetes liveness probes, autoscaling, automated runbooks, and the limits of self-healing.
• Severity Levels — Industry-standard SEV definitions, who responds at each level, and how to avoid sev-creep.
• SLI / SLO / SLA — The three measurements every SRE conversation orbits — verbatim definitions, the differentiator test, and the
• SRE Team Models — How SRE organizes itself. Embedded vs centralized vs platform team models, and when each fits.
• Supply Chain Security — How dependencies became the leading attack vector, and the post-SolarWinds defenses (SBOM, signed artifacts, S
• Testing for Reliability — The SRE testing hierarchy — unit through production — and how each layer targets a different class of reliabil
• The 50% Toil Cap — The six characteristics of toil, the 50% cap as floor-on-engineering, and the four-step legacy lifecycle.
• Three Pillars of Observability — What each pillar is for, where they fail, and the unified-via-OpenTelemetry shift.
• Timeouts & Deadlines — Why every external call needs a timeout, deadline propagation across services, and choosing the right values.
• Toil — The SRE Book's definition of toil, why measuring it is hard, and how the 50% cap actually works.
• What is SRE? — The Treynor definition, the relationship to DevOps, and the eight SRE principles.
• Zero Trust and Defense in Depth — BeyondCorp, the death of the perimeter, and how SREs implement defense in depth.
• Zero-Downtime Database Schema Migrations — Deploying breaking schema changes to production databases with zero downtime using the expand-contract pattern

Start free on Cariara · Coding problems · System design studio