Scenario-Based SRE Interview Questions and Answers (2027)

52 scenario-based SRE interview questions with answers: SLOs, error budgets, burn-rate alerts, incident roles, postmortems, toil and cascading failures.

Sep 17, 2025 - 16:55
Nov 7, 2026 - 00:05
 0  782
Scenario-Based SRE Interview Questions and Answers (2027)

Scenario-based SRE interview questions test how you protect reliability under pressure: choosing SLIs and SLOs, spending an error budget, alerting on symptoms instead of causes, running an incident with clear roles, writing a blameless postmortem, cutting toil, planning capacity and stopping cascading failures. Interviewers want a calm, ordered answer, not a list of tool names.

This page has 52 numbered questions with direct answers, grouped by experience level and followed by detailed incident walkthroughs. The concepts and numbers follow Google's two free SRE books, Site Reliability Engineering and The Site Reliability Workbook, published at sre.google. If you are new to the role itself, start with our explainer on what site reliability engineers do in DevOps teams.

Key takeaways

  • Know the definitions cold: an SLI is a measurement, an SLO is a target for that measurement, and an SLA is a contract with consequences when the SLO is missed.
  • The error budget is 100% minus the SLO. A 99.9% monthly SLO allows about 43 minutes of full downtime in a 30-day month.
  • Page on symptoms users feel (the four golden signals: latency, traffic, errors, saturation) and burn rate, not on every high CPU reading.
  • In an incident, mitigate first and find the root cause later. Rolling back a bad change is usually the fastest mitigation.
  • Postmortems are blameless and end with owned action items. Google's example policy requires one when a single incident uses more than 20% of the four-week error budget.
  • For senior roles, expect cascading failure questions: retries with backoff and jitter, retry budgets, deadline propagation, load shedding and graceful degradation.

How to answer a scenario question

Use the same five steps for almost every scenario. Interviewers listen for order and judgement more than for a single correct tool.

StepWhat you sayExample phrase
1. ImpactWho is affected and how badly, measured against the SLO"Checkout errors are at 4% against a 0.1% budget, so this is user-facing."
2. CoordinateDeclare an incident if needed and assign roles"I would take incident command and ask someone to own communications."
3. MitigateStop the bleeding with the safest reversible action"A deploy went out 10 minutes before the spike, so roll it back first."
4. DiagnoseFind the cause once users are safe"Then compare traces from before and after the release."
5. PreventPostmortem, action items, alert and test changes"Add a canary stage that checks the error SLI before full rollout."

For a wider question bank that covers Linux, Kubernetes and tooling as well, see our 100+ SRE interview questions and answers.

SRE interview questions for freshers

1. What is SRE, and how is it different from traditional operations?

Site reliability engineering applies software engineering to operations work. SRE teams set measurable reliability targets, automate repetitive tasks, and share responsibility for production with developers. Google's SRE book caps operational work at 50% of each SRE's time so the rest goes to engineering projects that make the service easier to run. Traditional operations teams often scale by adding people as the service grows; SRE tries to scale through automation.

2. What is the difference between an SLI, an SLO and an SLA?

An SLI (service level indicator) is a carefully defined measurement of service behaviour, such as the share of HTTP requests that succeed. An SLO (service level objective) is the target for that SLI, for example 99.9% of requests succeed over 30 days. An SLA (service level agreement) is a contract with users that states the consequences, often service credits, when the SLO is missed. Most teams keep an internal SLO tighter than the external SLA so they have warning before a contract breach.

3. What is an error budget?

The error budget is the amount of unreliability the SLO allows: 100% minus the SLO. With a 99.9% SLO the budget is 0.1%. For a time-based SLO over a 30-day month that is 30 x 24 x 60 x 0.001 = 43.2 minutes of full downtime. For a request-based SLO it is 0.1% of valid requests, so a service handling 10 million requests a month can fail 10,000 of them. The budget turns reliability into a shared number that product and SRE teams can spend on releases and experiments.

4. Why is 100% availability the wrong target?

The SRE book says 100% is probably never the right reliability target. Users cannot tell the difference between 99.999% and 100% because their own phones, Wi-Fi and ISPs fail more often than that. Each extra nine costs much more engineering effort and slows releases. Picking a target users actually need leaves an error budget that the team can spend on shipping features.

5. What are the four golden signals?

Latency, traffic, errors and saturation, from the "Monitoring Distributed Systems" chapter of the SRE book. Latency is the time to serve a request, measured separately for successful and failed requests. Traffic is demand, such as requests per second. Errors is the rate of failed requests, including wrong content and policy failures, not only HTTP 500s. Saturation is how full the service is, measured on its most constrained resource.

6. What does "alert on symptoms, not causes" mean?

Page a human when users are affected (a symptom, such as rising errors or slow responses), not when a possible cause appears (such as high CPU on one node). The SRE book frames monitoring as answering "what is broken" and "why". Symptom alerts answer the first question and should page; cause metrics belong on dashboards and in tickets to help with the second. This keeps pages rare and actionable.

7. What is toil?

Toil is operational work that is manual, repetitive, automatable, tactical, has no lasting value, and grows linearly with the service. Restarting a stuck job by hand every morning is toil. Writing the automation that restarts it is engineering. Google's SRE organization aims to keep toil below 50% of each SRE's time.

8. What is a blameless postmortem?

A written review of an incident that focuses on contributing causes in systems and processes, not on who made a mistake. It assumes everyone acted with good intentions based on the information they had. Blame makes people hide problems; a blameless culture gets honest timelines and better fixes. A postmortem records impact, timeline, root cause and triggers, what went well, what went badly, and action items with owners.

9. Why do SREs use percentiles instead of averages for latency?

Averages hide the slow tail. If 95 requests take 50 ms and 5 take 3 seconds, the average looks acceptable while 1 in 20 users waits seconds. The SRE book recommends treating metrics as distributions: the 50th percentile shows the typical request and the 99th shows plausible worst cases. Latency SLOs are usually written as "99% of requests complete in under 300 ms".

10. What is the difference between black-box and white-box monitoring?

Black-box monitoring tests the system from outside, as a user would, for example a synthetic probe that loads the login page. It shows problems that are happening now. White-box monitoring uses internal data such as metrics, logs and traces exposed by the application. It can reveal causes and early warning signs, such as a queue that keeps growing. Good setups use both: black-box for paging on user impact, white-box for diagnosis.

11. What is the difference between a runbook and a playbook?

Teams use the words loosely, but a runbook usually holds step-by-step instructions for one known task or alert, such as "failover the primary database". A playbook is broader guidance for a class of situations, such as how to run a security incident. Every paging alert should link to a runbook entry that says what the alert means, how to check impact and which mitigations are safe. Our post on automating incident response with runbooks covers turning these steps into scripts.

12. What do MTTD and MTTR measure?

MTTD (mean time to detect) is the average time from the start of a problem to someone knowing about it. MTTR is usually mean time to restore (or recover) service. DORA's current software delivery metrics call the related measure "failed deployment recovery time". Averages over a small number of incidents can mislead, so many teams also review each incident's timeline instead of relying on one number.

13. Scenario: a dashboard shows one node at 95% CPU, but latency and errors are normal. Do you page?

No. Users are not affected, so this is a cause signal, not a symptom. Open a ticket or let a lower-priority alert track it during working hours. Check whether the service has headroom if traffic grows and whether the load is uneven across nodes. If high CPU has preceded outages before, add it to a dashboard or as a ticket alert, but the page should stay tied to the latency and error SLIs.

14. Scenario: you are paged at 3 a.m. for a disk at 80% on a non-critical batch host. What do you change afterwards?

Handle the immediate risk, then fix the alert. The SRE book says every page should be actionable and need human judgement. A static 80% threshold on a non-critical host fails that test. Options: send it as a ticket instead of a page, alert on predicted time to full (for example, Prometheus predict_linear on the free-space metric) instead of a fixed percentage, and automate the cleanup if it is always the same log directory. Record it in the on-call handoff so the team sees the pattern.

SRE interview questions for 2 to 5 years of experience

15. How do you choose SLIs for a user-facing HTTP API?

Start from what users care about: did the request work, and was it fast enough. Write each SLI as a ratio of good events to valid events. Availability SLI: requests that did not return a 5xx, divided by all valid requests (exclude 4xx caused by clients). Latency SLI: requests served under a threshold, such as 300 ms, divided by all valid requests. Measure as close to the user as you can, at the load balancer or with synthetic probes, rather than inside one backend.

16. Scenario: the product manager asks for a 99.99% SLO because current performance is 99.97%. How do you respond?

Do not set the target from current performance. The SRE book warns this can lock you into heroic effort to defend a number users may not need. Ask what users and the business actually require, what the dependencies offer (a single-region database at 99.95% caps what you can promise), and what it costs. 99.99% allows about 4.3 minutes of downtime in 30 days, which usually rules out manual incident response. Start with a looser SLO you can meet and tighten it later; the book's advice is that perfection can wait.

17. What is burn rate, and how do you calculate it?

Burn rate is how fast the service is using its error budget compared with the rate that would use exactly the whole budget by the end of the SLO window. A burn rate of 1 uses the full budget in 30 days. A burn rate of 14.4 uses it in about 2 days. The workbook gives the relationship as: budget consumed = burn rate x (alert window / SLO period). For a 1-hour window over 30 days (720 hours), a burn rate of 14.4 means 14.4 x 1/720 = 2% of the budget gone in that hour.

18. How do you alert on SLOs without getting paged for every small blip?

Use multiwindow, multi-burn-rate alerts, the approach recommended in the workbook chapter "Alerting on SLOs". Each alert checks a long window for significance and a short window so the alert resets quickly once the problem stops. The workbook's starting values for a 99.9% SLO are:

SeverityLong windowShort windowBurn rateBudget consumed
Page1 hour5 minutes14.42%
Page6 hours30 minutes65%
Ticket3 days6 hours110%

In Prometheus, with recording rules that compute the error ratio over each window, the first page condition looks like this (0.001 is the 0.1% budget):

groups:
  - name: slo-alerts
    rules:
      - alert: ErrorBudgetBurnFast
        expr: |
          (
            job:slo_errors_per_request:ratio_rate1h{job="myjob"} > (14.4 * 0.001)
          and
            job:slo_errors_per_request:ratio_rate5m{job="myjob"} > (14.4 * 0.001)
          )
        labels:
          severity: page
        annotations:
          summary: "myjob is burning its 30-day error budget at 14.4x or more"

The 6x condition is added with or in the same way, and the 1x condition goes to a ticket queue.

19. Scenario: the team used its whole monthly error budget by day 12, and a big feature launch is planned for day 15. What happens?

Follow the error budget policy the team agreed before the problem started. In Google's example policy, a service that has exceeded its budget over the previous four weeks freezes changes and releases except P0 issues and security fixes until it is back within SLO. The launch moves, or ships behind a feature flag kept off, and the team spends the time on the causes that used the budget. If product and SRE disagree on the calculation, the example policy escalates to the CTO. Without a written policy this becomes an argument, which is why you agree it in advance.

20. Scenario: p99 latency for a critical service jumps from 200 ms to 2 seconds five minutes after a deploy. What do you do?

Roll back first. A change that closely precedes a symptom is the most likely trigger, and rollback is fast and reversible. While the rollback runs, confirm impact against the latency SLO and post a short status update. After latency recovers, compare traces and profiles from the old and new versions to find the slow path, such as a new database query without an index. Prevention: a canary stage that compares the latency SLI of the new version with the old before full rollout.

21. Scenario: on-call engineers receive 200 alerts a week and ignore most of them. How do you fix it?

Measure, then delete or demote. Export a month of alert history and tag each alert as actionable or not, and as user-facing or not. Remove alerts nobody acts on, move cause-based alerts (CPU, memory, single pod restarts) to dashboards or tickets, and group duplicates in Alertmanager or the paging tool. Replace them with a small number of SLO burn-rate alerts. Every remaining page needs a runbook link. The SRE book's on-call chapter sets a ceiling of two incidents per 12-hour shift so engineers have time to follow up properly.

22. When should you declare an incident?

The SRE book gives three tests: a second team is needed to fix the problem, the outage is visible to customers, or the issue is still unsolved after about an hour of focused analysis. If any is true, declare. Declaring early is cheap; if the problem turns out small, close the incident. Declaring late means people work in parallel without coordination.

23. What roles does an incident team need?

The SRE book's "Managing Incidents" chapter names four. The incident commander holds the overall picture, assigns work and makes decisions. The operations lead (ops lead) and their team are the only people changing production. The communications lead sends regular updates to stakeholders. The planning role handles longer tasks such as filing bugs, arranging handoffs and tracking changes made during the incident. The team keeps a live incident state document that anyone can read for the current status.

24. Scenario: 40 minutes into an incident, nobody knows the root cause. Users are still affected. What do you do?

Switch from diagnosing to mitigating with generic actions that do not need the root cause. Options include rolling back every change made in the last few hours (code, config, flags, infrastructure), draining traffic away from an unhealthy region or zone, adding capacity, turning off a non-essential feature, or serving degraded results. As incident commander, set a time box for each mitigation, ask a second team for help if the problem crosses a boundary, and keep updates going. Root cause analysis continues after users recover.

25. What triggers a postmortem, and what should it contain?

The SRE book lists common triggers: user-visible downtime or degradation beyond a threshold, data loss of any kind, on-call intervention such as a rollback or traffic reroute, resolution time above a threshold, and a monitoring failure (usually meaning a human found the problem first). The document covers summary and impact, a timestamped timeline, root cause and trigger, detection, what went well and badly, where the team got lucky, and action items each with an owner, priority and bug link.

26. Scenario: one outage consumed 30% of the monthly error budget. What does the policy require?

Under Google's example error budget policy, any single incident that consumes more than 20% of the budget over four weeks must have a postmortem, and that postmortem must contain at least one P0 action item to address the root cause. The policy also says that if one class of outage consumes more than 20% of the budget over a quarter, it gets a P0 item in the next quarter's planning.

27. Scenario: the team renews TLS certificates by hand every quarter, and one expired last month. How do you treat this?

This is toil and a reliability risk. Measure the time spent, then automate issuance and renewal with an ACME client or your platform's certificate manager, for example cert-manager on Kubernetes or a cloud certificate service. Add a black-box check that alerts when any served certificate is within a set number of days of expiry, so a failed renewal raises a ticket long before users see errors. Write the expired-certificate outage up as a postmortem, because it was user-visible.

28. How does a canary release protect an SLO?

A canary sends a small share of traffic to the new version while most users stay on the old one. You compare the canary's SLIs, such as error ratio and p99 latency, against the baseline before increasing traffic. A bad build then affects a small fraction of requests and uses a small part of the error budget, and rollback only touches the canary. Automate the comparison so the promotion decision does not depend on someone watching a graph.

29. Scenario: after a release, pods restart repeatedly with OOMKilled. What do you check?

Confirm the cause, mitigate, then fix. Run kubectl describe pod to see the last state and the "OOMKilled" reason, and kubectl top pod or your metrics to compare memory use with the container limit. If the new version uses more memory, roll back. Then decide whether the limit is too low for legitimate use or whether the release has a leak, by comparing memory growth over time between versions. Add a canary check on restart count so the next memory regression stops early.

30. Your service calls three dependencies in series, each with 99.9% availability. Can you promise 99.99%?

No, not without changing the design. If every request needs all three and their failures are independent, the best you can expect from them alone is roughly 0.999 x 0.999 x 0.999, about 99.7%. To offer more, remove hard dependencies from the request path: cache responses, make calls asynchronous, add fallbacks, or use redundant instances in different failure domains. This is why SLOs need to reflect the dependency chain, not the target someone would like.

31. Scenario: an engineer has been paged 15 times this week. What is wrong, and what do you change?

The rotation is overloaded. The SRE book recommends no more than 25% of SRE time on call and a maximum of two incidents per 12-hour shift. It also suggests at least eight engineers for a single-site rotation, or six per site for two sites. Review the pages: remove noisy alerts, fix the top recurring causes, and give the paged engineer recovery time. If load stays high, the book's advice is to hand some operational work back to the development team until it falls.

Senior SRE interview questions

32. Scenario: one of three clusters fails, and the other two start failing a few minutes later. What is happening?

A cascading failure. The surviving clusters take the failed cluster's traffic, run out of a resource (CPU, memory, threads, connections), slow down, and fail in turn. The SRE book chapter "Addressing Cascading Failures" lists server overload, resource exhaustion, retries, long deadlines and cold caches as common drivers. Immediate actions: shed load (reject a share of requests early, for example with HTTP 503), reduce or block retries, serve degraded responses, and add capacity. Bring the failed cluster back gradually so it does not crash again under a full load with cold caches.

33. How do retries make an outage worse, and how do you design them safely?

Retries multiply load on a backend that is already overloaded, and retries at several layers multiply each other. The SRE book recommends randomized exponential backoff (jitter), a limit on retries per request, a server-wide retry budget, and not retrying permanent errors or malformed requests. Retry at one layer of the stack, not every layer. A circuit breaker that stops calling a failing dependency for a short time works alongside these rules.

34. Why do deadlines and deadline propagation matter?

Without deadlines, requests wait on slow backends and hold threads and memory long after the client has given up. Set a deadline on every request, propagate the remaining time down the call chain instead of inventing a new deadline at each hop, check the remaining time before expensive work, and cancel downstream calls when the client cancels. This stops a slow dependency from tying up every server above it.

35. What is the difference between load shedding and graceful degradation?

Load shedding drops some requests so the server can serve the rest within its limits, for example by rejecting work when the number of in-flight requests passes a threshold. Graceful degradation keeps serving everyone but with a cheaper response, such as search results from a smaller index or a product page without recommendations. Both should be tested before you need them, because a degradation path that never runs often breaks when it is finally switched on.

36. How do you approach capacity planning for a service?

Forecast organic demand from historical growth, add inorganic demand from launches and marketing events, and convert both into resources using load test results that show how much traffic one instance can handle within the SLO. Plan for redundancy: the SRE book describes provisioning N+2, so the service can lose one instance to planned maintenance and another to an unplanned failure at peak. Recheck the model after major releases, because a new feature can change the cost per request.

37. How do you introduce SLOs in an organization that has none?

Start small. Pick one important user journey, define one or two SLIs from data you already collect, and set a target close to what users currently get as a first draft. Agree an error budget policy with product and engineering leadership before the first breach, then review the SLO after a few weeks. The workbook chapter "Implementing SLOs" walks through this process. Our post on why SRE error budgets matter covers the policy side.

38. Scenario: the SLO dashboard is green, but customers keep complaining. What is wrong?

The SLIs do not measure what users experience. Common gaps: measuring at the backend instead of the edge, so CDN or DNS failures are invisible; counting a 200 response with empty or wrong content as good; averaging across all customers so one large customer's bad experience disappears; or a latency threshold set too loosely. Read the complaints, trace a few failing requests end to end, and redefine the SLI so those requests count as bad.

39. Scenario: after a full restart, the service falls over even though traffic is normal. Why?

Cold caches. With empty caches, every request hits the database or backend, which cannot handle the full load that the cache normally absorbs. The SRE book lists cold caches and slow startup among cascading failure causes. Fixes: ramp traffic to restarted instances slowly, warm caches before taking traffic, restart in batches rather than all at once, and size the backend to survive a cache miss storm or protect it with load shedding.

40. How do you test disaster recovery in a way you can trust?

Run real exercises, not document reviews. Restore backups into a clean environment on a schedule and check the data, fail over a database or region during working hours, and run game days where a team practises a scenario with an incident commander. Measure actual recovery time and data loss against your RTO and RPO targets. Google describes its own annual Disaster Recovery Testing (DiRT) exercises in its SRE material; the principle is that untested recovery plans fail when needed.

41. When is it safe to run chaos experiments in production?

When the service has SLOs, good monitoring, a remaining error budget and a fast way to stop the experiment. Start in staging, form a hypothesis ("losing one zone keeps errors under the SLO"), limit the blast radius to a small share of traffic or one instance, and have the abort action ready. Do not run experiments during an incident or when the budget is nearly spent. Our post on moving chaos testing from staging to production goes deeper.

42. How do you measure whether an SRE team is succeeding?

Look at outcomes and team health together: SLO attainment and error budget use per service, pages per on-call shift, share of time spent on toil versus project work, time to detect and recover from incidents, and completion rate of postmortem action items. Avoid single targets such as "reduce MTTR by X%", because teams can improve a number without improving reliability.

43. Scenario: a configuration change pushed to all regions at once causes a global outage. What do you change?

Treat configuration like code. Validate config in CI (schema checks and dry runs), roll it out progressively by region or percentage with automatic health checks between stages, and make rollback a single, tested command. Keep a change log that on-call engineers can query during an incident. The SRE book lists configuration pushes among common cascading failure triggers, so global, simultaneous changes are a design smell.

Incident scenario walkthroughs

These questions often come in the final round as a live exercise. Talk through impact, mitigation, diagnosis and prevention in that order.

44. Scenario: the API returns intermittent 500 errors and logs show "connection pool exhausted".

Mitigate by reducing load on the pool: roll back if a recent change added queries, restart the worst instances to release leaked connections, or scale out the database read path if it is simply overloaded. Then find whether connections leak (not returned to the pool after errors), whether queries got slower so each connection is held longer, or whether new instances multiplied the total connection count past the database limit. Prevent with pool metrics on a dashboard, query timeouts, and a check on total connections before scaling events.

45. Scenario: memory use on every instance climbs slowly and instances restart every two days.

A memory leak. Short term, schedule rolling restarts during low traffic so restarts are controlled rather than crashes at peak, and confirm it does not hurt the SLO. Then compare memory growth across versions to find which release introduced it, capture heap profiles from a long-running instance, and fix the code. Add an alert on memory growth rate as a ticket, and a canary check on memory after releases.

46. Scenario: users cannot reach the site, and the browser shows a certificate error.

Check the expiry and chain of the served certificate with openssl s_client -connect example.com:443 -servername example.com. If it expired, issue or renew it and redeploy to every load balancer or ingress that serves it. Communicate the impact while you work. Afterwards, the postmortem should ask why renewal failed and why no alert fired days earlier, then add automated renewal and an expiry probe (see question 27).

47. Scenario: several services fail at once with "name resolution" errors.

Many unrelated services failing together points to shared infrastructure, often DNS. Confirm with dig against the internal resolver and a public one. Mitigate by rolling back recent DNS or network changes, scaling or restarting the resolvers (for example CoreDNS in Kubernetes), or failing over to a secondary resolver. Prevent with resolver capacity monitoring, client-side DNS caching where safe, and change control on DNS records.

48. Scenario: one availability zone degrades, and error rates rise for a third of requests.

Drain traffic from the unhealthy zone at the load balancer and confirm the remaining zones have enough headroom. This is where N+2 planning pays off. Do not wait for the cloud provider's status page to confirm. After recovery, check whether health checks detected the zone failure on their own, and if they did not, change them so traffic shifts automatically next time.

49. Scenario: customers reported an outage 30 minutes before any alert fired.

Fix the service first, then treat the monitoring gap as a separate finding. The SRE book lists a monitoring failure as a postmortem trigger. Ask why: the SLI did not cover the failing path, the alert window was too long, the alert went to the wrong team, or the monitoring itself depended on the failed component. Add a black-box probe for the affected journey and alerts that fire when telemetry stops arriving.

50. Scenario: a database migration deleted rows for some customers.

Stop further damage first: pause the migration job and block writes to affected tables if needed. Declare an incident, since data loss of any kind is a postmortem trigger. Restore the missing rows from backups or point-in-time recovery into a separate database, verify them, and merge them back carefully. Prevent with migrations tested against a production-sized copy, reversible migration steps, and regular restore tests so you know backups work.

51. Scenario: a third-party payment API slows down, and your checkout threads pile up.

Protect your own service. Lower the client timeout so threads are not held, open a circuit breaker so calls fail fast during the slowdown, and degrade gracefully, for example by queueing orders for later confirmation if the business allows it. Tell the vendor and check their status page. Long term, isolate the dependency with its own thread or connection pool so one slow vendor cannot exhaust capacity for the whole service.

52. Scenario: a sale event is next week, and marketing expects five times normal traffic. How do you prepare?

Load test at the expected peak plus margin, using production-like data, and fix the first bottleneck you find, then test again. Pre-scale capacity rather than relying only on autoscaling, which may react too slowly. Confirm quotas with your cloud provider, freeze risky changes for the event window, prepare degradation switches (turn off recommendations, for example), and put a staffed incident rota in place with runbooks reviewed in advance.

Quick reference: SRE numbers worth remembering

ItemValueSource
Downtime allowed by 99.9% over 30 daysAbout 43.2 minutesArithmetic: 43,200 minutes x 0.001
Downtime allowed by 99.99% over 30 daysAbout 4.3 minutesArithmetic: 43,200 minutes x 0.0001
Toil ceiling per SREBelow 50% of timeSRE book, "Eliminating Toil"
On-call time ceilingNo more than 25% of timeSRE book, "Being On-Call"
Incidents per 12-hour shiftMaximum 2SRE book, "Being On-Call"
Fast-burn page14.4x over 1 hour and 5 minutesWorkbook, "Alerting on SLOs"
Single incident needing a postmortem with a P0 itemMore than 20% of the four-week budgetWorkbook, "Error Budget Policy"

How to prepare for a scenario-based SRE interview

Read the free chapters on SLOs, monitoring, managing incidents, postmortems and cascading failures at sre.google, then practise saying each scenario answer aloud in the five-step order above. Build a small lab: a sample app, Prometheus and Grafana, an SLO with burn-rate alerts, and a failure you inject yourself. Our guides to observability tools for DevOps monitoring and scenario-based Prometheus interview questions cover the tooling questions that often follow, and the 200+ DevOps interview questions guide covers the general rounds.

If you want guided practice, DevOps Training Institute runs classroom batches in Kharadi, Pune and live online classes across India. The Prometheus and Grafana course covers metrics, alerting and dashboards hands-on, and the DevOps course covers the CI/CD, Kubernetes and release practices that SRE work depends on.

FAQs

What is the most common scenario question in SRE interviews?

Some version of "latency or errors spiked, what do you do?" Answer in order: confirm user impact against the SLO, coordinate (declare an incident if needed), mitigate with a safe reversible action such as rollback, diagnose once users are safe, and prevent recurrence through a postmortem and action items.

Are the Google SRE books free to read?

Yes. Google publishes Site Reliability Engineering and The Site Reliability Workbook free online at sre.google, along with Building Secure and Reliable Systems. Interviewers often quote their terms, such as error budget, toil and the four golden signals.

How do I calculate an error budget in an interview?

Subtract the SLO from 100% and apply it to the window. For a 99.9% SLO over 30 days: 30 x 24 x 60 = 43,200 minutes, and 0.1% of that is 43.2 minutes. For request-based SLOs, multiply the budget by the number of valid requests, for example 0.1% of 10 million is 10,000 failed requests.

What is the difference between SRE and DevOps?

DevOps is a broad set of cultural and technical practices for bringing development and operations together. SRE is one specific way to implement those ideas, with concrete tools such as SLOs, error budgets, toil limits and blameless postmortems. Many companies use the titles interchangeably, so read the job description.

Which tools should I know for SRE interviews?

Interviewers care more about concepts, but expect questions on a metrics system (usually Prometheus), dashboards (Grafana), tracing and instrumentation (OpenTelemetry with Jaeger or Tempo), logs (Loki or Elasticsearch), Kubernetes, one cloud provider, and a paging tool. Be ready to write a basic PromQL query and an alert rule.

What is a good SLO for a new service?

There is no universal number. Base it on what users need and what your dependencies can support, not on current performance. Start with a target you can meet, such as 99.5% or 99.9% for a request-based availability SLI, keep the number of SLOs small, and tighten them once you have data.

Should every alert page someone?

No. Page only for urgent, user-facing problems that need human judgement now. Send everything else to tickets, dashboards or automation. The SRE book's rule is that every page should be actionable.

How do I talk about incidents if I have no production experience?

Use a lab or project you built. Break something on purpose, such as filling a disk or adding latency, and describe how you detected it, what you checked and how you fixed it. Be honest that it was a lab; a clear, ordered process still shows the skills interviewers look for.

Official references

What's Your Reaction?

Like Like 0
Dislike Dislike 0
Love Love 0
Funny Funny 0
Angry Angry 0
Sad Sad 0
Wow Wow 0
Mridul I am a passionate technology enthusiast with a strong focus on DevOps, Cloud Computing, and Cybersecurity. Through my blogs at DevOps Training Institute, I aim to simplify complex concepts and share practical insights for learners and professionals. My goal is to empower readers with knowledge, hands-on tips, and industry best practices to stay ahead in the ever-evolving world of DevOps.