Incident Response and Management Questions
The end-to-end operational lifecycle of a production incident: detection, triage, mitigation, resolution, and handoff. Covers response coordination, ownership of an active incident, and the mechanics of restoring service quickly. This is the generalist backbone topic that most operational roles are drilled on.
You are paged for a sudden spike in errors on a critical production service. Walk through what you do in the first 15 to 30 minutes: what you check first, how you decide whether to page anyone else, and what you would and would not do in that opening window.
Sample Answer
Direct answer
In the first 15 to 30 minutes: acknowledge the page immediately so others know someone is on it, check your two or three primary signal sources (error-rate dashboard, recent deploys, recent config changes) to get a rough sense of scope and cause, apply an obviously safe temporary mitigation if one exists, post a first status update even if it just says 'investigating,' and decide whether you need more people. What you don't do: silently investigate alone for the whole window, or start deep root-causing before you know how big the problem is.
Structured elaboration
- Acknowledge and orient (minute 0-2). Confirm the page is real, not a flapping alert, and check the primary dashboard to see current error rate, latency, and traffic. This tells you if you're dealing with a full outage or a partial degradation.
- Check for an obvious cause (minute 2-8). Look at what changed recently: deploys, config pushes, feature flag flips, infrastructure changes. Most production incidents correlate with a recent change, and this is the highest-value early check.
- Decide on scope and escalation (minute 5-10). Based on what you've seen, decide if this affects one service or many, one region or all, and whether you need to page anyone else. Getting help early is cheap; struggling alone for 25 minutes before asking is expensive.
- Apply a safe temporary action if available (minute 10-20). If a recent deploy correlates with the problem, rolling it back is usually the safest first move, since it's typically reversible. If there's no obvious cause, avoid guessing with an irreversible action.
- Post a first status update (by minute 15-ish). Even 'we're aware, investigating, will update in 15 minutes' is far better than silence, both for stakeholders and for your own discipline of staying on a cadence.
- What not to do: don't start a deep root-cause investigation before you understand the blast radius; don't make an irreversible change (a manual database edit, a permanent config change) under time pressure without a second person's input; don't go quiet.
Worked example
Page fires at 14:02 for elevated error rate on the checkout service. 14:02-14:03: engineer acknowledges, opens the dashboard, sees error rate at 8% (up from a normal 0.1%), affecting checkout only, not the whole site. 14:03-14:06: checks recent deploys, finds one shipped at 13:55, seven minutes before the alert. 14:06-14:08: decides this is likely deploy-related, pages a second engineer to help verify while they prepare a rollback, and opens an incident ticket marked SEV2 (partial, revenue-affecting feature). 14:08-14:11: rolls back the deploy. 14:11-14:14: watches error rate drop back to 0.1% and holds there. 14:15: posts 'checkout errors have returned to normal following a rollback of a recent deploy; monitoring to confirm and will follow up with a summary.'
Trade-offs and pitfalls
Spending the first 15 minutes purely gathering information without acting risks letting an easily-mitigated problem run longer than necessary; acting immediately without any scoping risks mitigating the wrong thing entirely, or worse, taking an action whose blast radius you don't understand. The 'lone hero' pattern, where a responder tries to fully resolve the incident single-handedly before looping anyone in, is a recurring failure mode: it delays getting a second set of eyes on a decision made under pressure, and it delays stakeholder communication that people are actively waiting on.
Tell me about a specific production incident you triaged hands-on. Walk through the actual monitoring signals, tools, and commands you used to narrow down the problem, the immediate fix you applied, and what you changed afterward to prevent a repeat.
Sample Answer
Direct answer
This question is looking for hands-on technical fluency under pressure, not just process: the specific signals you checked, the specific tools and commands you actually ran, and how those concrete steps led to the fix, told as a real, technically credible narrative rather than a high-level summary.
Structured elaboration
What separates a strong answer here from a more general first-responder story is the technical texture:
- Monitoring and observability signals. Name the actual dashboards, metrics, or logs you looked at first and why those were the right starting point given the symptom.
- Tools and commands. Be specific about what you actually ran (checking pod status and recent events in a container orchestrator, tailing logs for a specific service, checking resource utilization on a host) and what each step told you, not just that you 'checked the logs.'
- The diagnostic chain. Walk through how one check led to the next: what you ruled out, what pointed you toward the real cause, and where you might have gone down a wrong path before correcting.
- Immediate remediation. What specific action restored service, and why that was the right call given what you'd found (a restart, a rollback, a manual failover, a config change), including any manual verification you did to confirm it actually worked rather than just assuming.
- Long-term change. A concrete artifact that came out of it: a new alert, a runbook entry, an automated check, something that reduces reliance on someone remembering the right diagnostic steps next time.
Worked example
An illustrative skeleton: 'I got paged for a service that had stopped responding to health checks. I checked our container orchestrator's dashboard and saw several pods in a crash-loop state, so I described one of the pods to see recent events and found repeated out-of-memory kills. I tailed the pod's logs right before each restart and saw a specific request pattern that correlated with memory spikes, which pointed at a recent code change rather than an infrastructure problem. I rolled back that deploy, watched the pods stabilize and stop crash-looping over the next several minutes, and manually verified a few real requests were succeeding before considering it resolved. Afterward, I added a memory-usage alert tied to that service specifically, since the existing alerting hadn't caught the gradual climb before the crash loop started.'
Trade-offs and pitfalls
The main weakness in answers here is staying at too high a level ('I looked into the logs and found the issue') without the concrete tool-level detail that actually demonstrates hands-on competence; an interviewer asking this specific version of the question is usually trying to distinguish someone who directs others during an incident from someone who can personally do the diagnostic work. A second pitfall is describing a diagnostic path that sounds suspiciously clean and linear; a credible answer often includes at least one wrong turn or ruled-out hypothesis, since that's how real diagnosis actually goes, and its total absence can read as rehearsed rather than genuine.
Walk through the lifecycle of a production incident end to end, from before anything goes wrong through the post-incident review. For each phase (preparation, detection, triage, containment, mitigation, recovery, and post-incident review), name the key activity, one artifact you would expect to see (a dashboard, a ticket, a timeline), and who is typically involved. Use a concrete example action at one phase to ground your answer.
Sample Answer
Direct answer
A production incident moves through seven phases: preparation, detection, triage, containment, mitigation, recovery, and post-incident review. Preparation happens before anything breaks (runbooks written, on-call staffed, alerts wired up); detection is the moment you learn something is wrong; triage scopes and prioritizes it; containment stops it from getting worse; mitigation reduces the pain customers feel; recovery restores full normal service; and the post-incident review turns the experience into a lasting fix. Each phase has a different owner, a different artifact, and a different question it answers.
Structured elaboration
- Preparation. Activity: writing and testing runbooks, defining on-call rotations, wiring alerts to real signals. Artifact: the runbook itself and the on-call schedule. Owner: the team that runs the service, done continuously, not reactively.
- Detection. Activity: an alert fires or a human notices something is off. Artifact: the alert or the first ticket. Owner: whoever is paged, or whoever notices first.
- Triage. Activity: scoping how bad it is and who needs to know. Artifact: an incident ticket with severity, scope, and a first status note. Owner: the first responder, sometimes handed to an incident commander for anything large.
- Containment. Activity: stopping the blast radius from growing (isolating a host, throttling a bad client, disabling a feature flag). Artifact: a decision log entry noting what was done and why. Owner: whoever is closest to the failing component.
- Mitigation. Activity: making the customer-visible symptom smaller even before the root cause is fixed (failing over, serving cached data, degrading gracefully). Artifact: an updated status note describing customer impact before and after. Owner: the responder or incident commander.
- Recovery. Activity: restoring full functionality and confirming it holds, not just that one metric blipped green. Artifact: a recovery validation checklist and the all-clear message. Owner: the responder, with sign-off from anyone whose data or workflow was affected.
- Post-incident review. Activity: reconstructing the timeline, finding the root cause, and turning it into owned action items. Artifact: the postmortem document. Owner: usually the incident lead, with input from everyone involved.
Worked example
An API starts returning 5xx errors to 15% of traffic. Preparation already exists: there's a runbook for 'elevated 5xx rate' and an on-call SRE. Detection: a synthetic check pages the on-call engineer. Triage: the engineer opens a ticket, sees the error rate and which endpoints are affected, and judges this a SEV2. Containment: they notice the errors correlate with a recent deploy and freeze further deploys to that service so nothing else changes mid-investigation. Mitigation: they roll back the deploy, which drops the error rate from 15% to under 1% within two minutes. Recovery: they watch the error rate and latency stay at baseline for 20 minutes before declaring the incident resolved, since a single good data point after a rollback isn't proof the fix held. Post-incident review: a review two days later finds the deploy introduced a null-pointer bug in an edge case, and the action items are a missing test case plus a canary step that would have caught it before full rollout.
Trade-offs and pitfalls
The most common mistake is skipping straight from detection to mitigation without a real triage step, which means responders end up mitigating the wrong thing or missing that three separate alerts are actually one incident. The second common mistake is calling recovery too early: one healthy-looking dashboard refresh is not the same as a service that has held steady long enough to trust. A third, subtler pitfall is treating containment and mitigation as the same step; containment is about preventing the problem from spreading (a freeze, an isolation), while mitigation is about reducing what customers currently feel (a rollback, a failover) - conflating them means teams sometimes stop at containment and believe the incident is handled when customers are still seeing errors.
Describe a moment where you had to choose between a quick workaround to restore service and a longer-term architectural fix. What factors did you weigh (risk, cost, customer impact, how much runway you had), and what did you actually decide?
Sample Answer
Direct answer
A strong answer names the specific factors weighed (how much risk the workaround carries, what it costs to maintain, how much customer impact continuing to be broken causes, and how much runway there actually was before a proper fix could ship) and is honest about what was actually decided, including if the workaround turned out to be the wrong call in hindsight.
Structured elaboration
- Risk. Does the quick workaround introduce new risk of its own (a hacky patch that could fail in an unexpected way) versus being a safe, well-understood stopgap?
- Cost. What does it cost to build and maintain the workaround, especially if 'temporary' fixes have a track record of becoming permanent at your organization?
- Customer impact of waiting. How bad is the status quo for customers while the long-term fix is being built, and does that urgency justify accepting the workaround's downsides?
- Runway. How much time is realistically available before the long-term fix ships, and is the workaround actually needed to bridge that gap or is the long-term fix closer than it first appears?
- A genuinely good answer names a real trade-off that was made, including a downside that was accepted, rather than presenting the decision as costless; a decision with no acknowledged downside usually means the story is being told too cleanly.
Worked example
An illustrative skeleton: 'We had a service that was intermittently timing out under load, and the real fix (redesigning how it handled a slow downstream dependency) was going to take a couple of weeks of actual engineering work. In the meantime, I put in a quick workaround: an aggressive timeout with a fallback response, which meant some requests got a slightly degraded but fast response instead of a slow failure. I weighed the risk (the fallback response was less precise, which had a real, measurable cost for a subset of users) against the customer impact of continuing to time out entirely, and decided the workaround was worth it given a two-week runway, but I made sure the fallback usage was itself monitored so we'd know exactly how often it was being hit and wouldn't lose track of it once the real fix shipped.'
Trade-offs and pitfalls
The main weakness is presenting the decision as obviously correct with no real cost, when a genuine trade-off almost always has an accepted downside worth naming honestly. A second pitfall is describing a 'temporary' fix that quietly became permanent without acknowledging that as a real outcome worth reflecting on; a candidate who's aware of that risk and actively guarded against it (through monitoring, a tracked follow-up, an explicit deadline) demonstrates more judgment than one who simply moved on. This decision-making pattern, weighing risk, cost, customer impact, and available runway, applies whether you're making the call directly as the engineer or explaining the same trade-off to someone else who has to decide, like a customer evaluating their own quick-fix-versus-rebuild choice.
You receive three alerts at once: a public API returning errors to a fifth of users, a payment service with a small but high-value failure rate, and a non-critical nightly batch job failing. Decide which you respond to first and in what order, and justify the ranking using impact, scope, and business criticality. Describe your first concrete action on the top-priority item.
Sample Answer
Direct answer
Of the three, I'd respond to the payment failures first, then the public API errors, then the batch job. The payment failures affect a small percentage but include high-value customers and touch money directly, which makes the per-incident cost disproportionately high even at low volume. The API errors affect a much larger share of users (a fifth), which makes them close behind despite lower per-user stakes. The batch job failing on non-critical reports has the lowest urgency because nothing customer-facing depends on it in the next few minutes.
Structured elaboration
Prioritization among simultaneous alerts should weigh three factors together, not any one alone:
- Impact per affected user. A failed payment is a much sharper failure than a slow page load; money and trust are on the line in a way that compounds if it isn't caught quickly.
- Scope. How many users or how much revenue is actually affected right now, not how loud the alert is. A noisy alert with low real impact should never outrank a quiet one with high impact.
- Business criticality and reversibility. Some failures get worse the longer they run (money moving incorrectly, data corrupting further); others are simply delayed (a report that's a few hours late is annoying but recoverable).
A good way to communicate this under pressure: state the ranking and the one-line reason out loud or in the incident channel immediately, then explicitly assign or acknowledge who is covering the lower-priority items so they aren't silently dropped, even while you focus on the top one.
Worked example
For the three alerts given: payment failures affecting 1% of transactions, including high-value customers, go first, because even a small volume of incorrect financial outcomes needs immediate first-action (typically confirming whether payments are failing safely, i.e., not charging without fulfilling, versus failing unsafely). Second, the public API 5xx errors affecting 20% of users across regions, because the sheer scope makes it the next highest-impact item even though each individual failure is less severe than a payment error. Third, the internal nightly batch job, which is deprioritized to 'someone will pick this up after the first two are stable' since it affects no external users right now. First concrete action on the payment issue: check whether failures are being safely rejected (no charge, clear error to the user) or unsafely processed (charge succeeds but order fails), since that distinction determines whether this needs an urgent stop-the-bleeding action or can tolerate a few more minutes of investigation.
Trade-offs and pitfalls
A common pitfall is anchoring on whichever alert is loudest or has the highest raw volume, rather than the one with the highest actual business impact; a batch job failing nightly can generate more page noise over time than a rare but severe payment issue. Another pitfall specific to this pattern: sometimes a single root cause produces what looks like several simultaneous alerts (a bad deploy triggering a flood of unrelated-looking alerts across a fleet), and prioritizing them as independent problems wastes time that a single fix would resolve; it's worth a quick check for a shared root cause before treating three alerts as three separate incidents. At a higher level, a manager juggling multiple simultaneous incidents across teams faces the same decision with an added dimension: whether the aggregate is severe enough to formally declare a larger, cross-team incident rather than three parallel smaller ones.
Unlock Full Question Bank
Get access to all 12 Incident Response and Management interview questions and detailed answers.
Sign in to ContinueJoin thousands of developers preparing for their dream job.