Site Reliability Engineering Interview Preparation

Translate a customer-facing restaurant reservation journey into explicit reliability requirements.

Construct a dependency map for a cloud-native Python service running on AWS and Kubernetes.

Perform a failure mode and effects analysis for a distributed service architecture.

Prioritize reliability risks using customer impact, likelihood, detectability, and blast radius.

Assess a service against a production-readiness checklist and document the principal gaps.

Formulate a reliability initiative that links a specific risk to customer impact and a measurable result.

Differentiate service-level indicators, service-level objectives, and service-level agreements in a reliability proposal.

Select user-centric SLIs for availability, latency, correctness, and freshness.

Calculate a request-based availability SLI from valid and successful event counts.

Interpret latency distributions and choose an appropriate percentile-based latency SLI.

Set a defensible SLO target and measurement window from customer and business requirements.

Calculate the remaining error budget for a service over a defined window.

Calculate error-budget burn rate from an incident or telemetry dataset.

Write an error-budget policy that maps budget status to release and reliability decisions.

Select suitable metric types for counters, gauges, rates, and latency distributions.

Configure the Datadog Agent to collect telemetry from a containerized Python service.

Configure Datadog's AWS integration for relevant EC2, load-balancer, and database metrics.

Instrument a Python service with custom business and operational metrics.

Design a tagging strategy that avoids uncontrolled cardinality.

Build a Datadog dashboard around traffic, errors, latency, and saturation.

Diagnose a simulated degradation from metric trends on a Datadog dashboard.

Emit structured application logs with consistent severity and diagnostic fields from a Python service.

Configure centralized log collection, parsing, and search in Datadog.

Propagate a correlation identifier across service boundaries and background tasks.

Instrument a distributed request path with Datadog APM or OpenTelemetry tracing.

Locate a latency bottleneck by analyzing spans, service maps, and flame graphs.

Choose a trace-sampling strategy that balances diagnostic value, traffic volume, and cost.

Trace a browser performance problem from a Datadog RUM event to related backend telemetry.

Evaluate whether an alert is customer-relevant, actionable, timely, and owned.

Create a threshold monitor with an appropriate evaluation window and recovery condition.

Create a multi-window error-budget burn-rate alert for an SLO.

Configure alert routing, severity, escalation, and ownership in Datadog.

Write a concise alert runbook containing validation, diagnosis, mitigation, and escalation steps.

Validate an alert by injecting a controlled failure and measuring detection behavior.

Tune a noisy monitor using alert-history evidence without hiding genuine customer impact.

Prepare an on-call shift using access, handoff, escalation, and service-health checks.

Assign incident severity from customer impact, scope, duration, and urgency.

Establish incident-command roles and a communication channel during a production event.

Triage an unfamiliar production incident using a structured telemetry-first workflow.

Maintain a timestamped incident log that separates observations, hypotheses, decisions, and actions.

Deliver a concise stakeholder update that states impact, response status, and the next update time.

Lead a time-boxed incident simulation from detection through stabilization and handoff.

Reconstruct an evidence-based incident timeline from telemetry and response records.

Describe customer impact using affected journeys, scope, duration, and severity.

Separate an incident trigger from contributing technical and organizational conditions.

Apply systems-oriented causal analysis without assigning individual blame.

Write corrective actions that are specific, owned, prioritized, and verifiably complete.

Facilitate a blameless post-incident review that surfaces disagreement and learning.

Track corrective actions and recurring incident patterns to verify reliability improvement.

Diagnose CPU, memory, disk, and process pressure on a Linux host using system evidence.

Localize a DNS, TLS, connection, or load-balancer failure along a network request path.

Diagnose Kubernetes pod failures using events, logs, health checks, and resource state.

Identify a PostgreSQL performance bottleneck from query plans, locks, connections, and resource metrics.

Profile a Python service to locate a CPU, memory, or I/O bottleneck.

Correlate metrics, logs, and traces to isolate a fault in a distributed request path.

Create a repeatable performance test that detects a customer-relevant regression.

Set connection and request timeouts from latency budgets and dependency behavior.

Implement bounded retries with exponential backoff and jitter for a transient failure.

Make a retried API or background task idempotent.

Choose between circuit breakers and bulkheads for a specific dependency failure mode.

Implement load shedding or graceful degradation for an overloaded service.

Create a capacity model from demand, per-instance throughput, utilization targets, and growth.

Run a load test that identifies the service's saturation point and failure behavior.

Set Kubernetes scaling thresholds and resource allocations from measured capacity evidence.

Quantify recurring operational work using frequency, duration, manual effort, and risk.

Prioritize a toil-reduction opportunity by comparing automation cost with operational benefit.

Automate a repeatable diagnostic or remediation runbook in Python with safety controls.

Design Terraform module boundaries for a reusable and independently changeable AWS service stack.

Add Terraform validation, plan review, state protection, and drift-detection safeguards.

Configure Kubernetes probes, disruption budgets, and resource controls for workload reliability.

Add reliability checks and an explicit rollback criterion to a GitHub Actions deployment pipeline.

Design a canary rollout that limits blast radius and uses telemetry to decide promotion or rollback.

Select and scope a reliability problem for a containerized Python reservation service.

Write a concise technical proposal covering customer impact, constraints, alternatives, risks, and success measures.

Break the reliability proposal into prioritized user stories and independently deliverable tasks.

Add end-to-end metrics, structured logs, and distributed traces to the capstone service.

Implement an SLO, dashboard, burn-rate alert, and linked runbook for a critical user journey.

Run a controlled load or failure experiment and collect evidence about system behavior.

Convert experiment and incident findings into a prioritized reliability roadmap.

Present the initiative's decisions, trade-offs, results, and next steps in an engineering-review format.

Rewrite existing backend and cloud achievements as evidence-based SRE résumé bullets without overstating production-operations experience.

Build STAR narratives for ownership, technical decisions, disagreement, feedback, failure, and cross-team collaboration.

Explain how metrics, logs, traces, SLOs, alerts, and error budgets work together in an interview scenario.

Design a reliable restaurant reservation platform while reasoning about dependencies, failure modes, capacity, and trade-offs.

Lead a verbal incident-response exercise while communicating clearly under changing conditions.

Scope an ambiguous reliability initiative into milestones, user stories, risks, and measurable outcomes.

Solve a Python interview exercise involving telemetry aggregation, log analysis, or operational automation.

Solve a timed data-structures-and-algorithms problem and communicate complexity and trade-offs.

Conduct a full mock SRE interview and turn the evidence into a targeted improvement plan.