skip to content
‹ All posts

By Riya Madaan

How to run a live debugging interview that isn't torture

A practical guide to running a live debugging interview: environment prep, hint policy, think-aloud prompts, timeboxing, and a scoring sheet that works.

#hiring

A live debugging interview is the highest-signal hour in infra hiring - watching a candidate work a real fault tells you things no conversation can. It is also the easiest interview to run badly. Done wrong, it's an hour of a stressed human being watched in silence while an environment misbehaves in ways even the interviewer doesn't fully understand, followed by a gut-feel score.

The difference between signal and torture is entirely in the logistics. Here they are, end to end.

Prepare the environment like it's production (because it's your funnel)

The fault comes first. Pick one real failure, plant it deliberately, and solve it yourself under the candidate's conditions before any candidate sees it. If your own engineer can't fix it in half the allotted time with the tools the candidate gets, it's too hard. Good faults for a 45-minute box: a service with an empty endpoints list, a pod stuck in Pending on a taint, a CrashLoopBackOff with the evidence one --previous flag away, a full disk where df and du disagree.

Non-negotiables:

  • Reset to identical state between candidates. Snapshot or rebuild. A candidate debugging the previous candidate's leftovers is being graded on noise.
  • Zero setup friction for the candidate. Every minute spent on VPN configs and SSH keys is a minute of signal lost and stress gained. Browser-based access or a pre-provisioned jump host; test the joining flow with someone outside your team.
  • One fault, not three. Compound faults feel clever and grade terribly - you can't tell which part they failed.
  • Decide the AI policy in advance and say it out loud. Allowed (recommended - your engineers use it at work, and watching a candidate drive it is signal) or not, but never ambiguous. Ambiguity punishes honest candidates.

The opening two minutes decide the interview's temperature

Say all of this, explicitly, before the clock starts:

  • "The environment is genuinely broken. It's supposed to be. You didn't break it."
  • "We grade your process, not just whether it's fixed at the end. Partial progress with good reasoning scores well."
  • "Please think out loud. If you go quiet, I'll nudge you - that's not a penalty."
  • "You can ask questions. Asking a good question counts for you."
  • "45 minutes. I'll give you time checks at 20 and 5."

That last framing matters more than any other logistics choice. A candidate who believes only the fix counts will panic-guess. A candidate who knows process counts will show you the process - which is what you came for.

Should you give hints in a debugging interview?

Yes, but only from a ladder you wrote down before the first candidate, applied identically. Unstructured hints are the biggest fairness leak in a debugging interview. Friendly interviewers rescue candidates; stern ones let them drown; scores become interviewer biographies. Fix it with a ladder, written down in advance:

  1. Nudge (free): "What does the evidence you have so far rule out?"
  2. Orientation (note it): "Have you looked at the events on that object?"
  3. Directional (costs a rubric point, say so in your notes): "The problem is in how the service finds its pods."
  4. Rescue (ends scoring for diagnosis, keeps interview humane): show them the cause, let them do the fix - you can still observe fix quality and verification.

Every candidate gets the same ladder at the same trigger: roughly, ten minutes with no forward progress. Rescuing a stuck candidate isn't kindness at the expense of rigor, a candidate who spends 35 minutes stuck generates no signal at all. The ladder converts that dead time back into data.

Think-aloud prompts that don't lead the witness

Silence is unreadable - you can't tell methodical from lost. But bad prompts contaminate the sample. Keep a card of neutral ones:

  • "What are you looking at right now?"
  • "What would you expect to see if you're right?"
  • "What have you ruled out so far?"
  • "What are your candidate theories at this point?"

Never "have you considered the probe?" - that's a directional hint wearing a question's clothes, and it goes on the ladder as one.

Timeboxing: 45 minutes is the sweet spot

Long enough for a real diagnosis arc - orientation, wrong turn, recovery, fix, verification - short enough to respect the candidate and force prioritization, which is itself the skill you're measuring. Give time checks; sprung deadlines measure surprise tolerance, not engineering. And end on time even mid-fix: "walk me through what you'd do with ten more minutes" recovers most of the remaining signal in one question.

How do you score a live debugging interview?

On a written sheet, filled in immediately after, not from memory at the debrief. Five dimensions, 1-5, with a written anchor for each level - here's the skeleton:

Dimension 5 looks like 1 looks like
Hypothesis quality Evidence first; explicit, testable theories Mutation before observation; "try stuff"
Efficiency Each check eliminates a branch Repeats dead ends; unfocused wandering
Wrong-turn recovery Notices disproof fast, re-plans openly Sunk-cost digging; defensiveness
Verification Re-tests the original symptom unprompted "Should work now"
Blast radius Smallest viable intervention; cleans up Destructive shortcuts; leaves probes disabled

Note there's no "fixed it: yes/no" row carrying the sheet. Track it - but weight the outcome as a minority of the score. A lucky paste that works is worth less than a sound diagnosis that ran out of clock; the full argument is in how to grade an incident.

Also write down timestamps or quotes next to each score while they're fresh. "3 on verification - declared done at 38:00 without re-curling the endpoint" survives a hiring debate. "Seemed rushed" doesn't.

The failure modes to design out

  • Interviewer doesn't know the fault cold. You cannot grade navigation of territory you can't navigate. Solve it yourself first, twice.
  • Environment flakiness. If the lab breaks in an unplanned way, the interview is void - reschedule, don't improvise. Candidates can't tell your bug from theirs.
  • Grading charisma. Confident narration is not diagnosis. The scoring sheet exists precisely to protect quiet, methodical candidates from fluent flailers.
  • One-off environments. If each interviewer hand-builds their own fault, no two candidates take the same test. Standardize the scenario or rotate through a small vetted set. (This - plus a timestamped command log, so a second grader can check the first - is basically the job description of an assessment platform. The broken environment and the time box are what Faultybox packages, and the command log in the report means "what actually happened at minute 20" stops being a memory contest between interviewers.)

Run it this way and the live debugging interview stops being an endurance event and becomes the fairest hour in your loop: same fault, same hints, same sheet, real work. It's also - candidates tell interviewers this unprompted - the only interview format that's actually fun. Engineers who dread whiteboards will fight a broken cluster for sport; the deal is better than homework ever was, which is a big part of why the take-home test is dead.

FAQ

How long should a live debugging interview be?

45 minutes of hands-on time is the reliable sweet spot: long enough for a full diagnose-fix-verify arc on a single planted fault, short enough to respect candidates and force prioritization. Add ten minutes around it for framing and debrief questions.

Should candidates be allowed to use Google and AI during a debugging interview?

Allow both, and say so upfront. Your engineers use them on real incidents, and how a candidate uses them - what they search, whether they verify a model's suggestion before running it - is signal, not noise. Banning tools measures memorization under surveillance, which isn't the job.

What if the candidate fixes the fault in ten minutes?

Have a follow-up ready: a second variant of the fault, or deepening questions - "what would you monitor to catch this before users do?", "what's the least destructive permanent fix?" Fast finishes are a gift: you get to see the candidate's ceiling instead of their floor.

How do I keep debugging interviews fair across different interviewers?

Standardize everything that varies: same fault (or equivalent variants), a written hint ladder applied at the same triggers, one scoring sheet with anchored levels, and scores recorded with evidence immediately after the session. Recording the session - even just the terminal - lets a second grader calibrate the first.


Faultybox runs your candidates through a real broken cluster and shows you exactly how they fixed it - command log included. Start free →