Your Code Fails a Test Case Live? How to Debug Calmly in a Coding Interview
You finish writing your solution, you click run (or the interviewer hands you an example to walk through), and the output is wrong. Maybe it's an off-by-one. Maybe it returns an empty list. Maybe it crashes with an index error you didn't see coming. The room goes quiet and your first instinct is to start changing lines at random until something passes.
That instinct is the single most expensive habit in live coding rounds. A failing test, on its own, rarely sinks a candidate. Interviewers see buggy first drafts constantly; most working engineers write them every day. What they're watching for is whether you can find a bug methodically, explain what you're doing, and fix it without breaking three other things along the way.
This guide gives you a short, repeatable routine for exactly that moment.
Why a failing test is an opportunity, not a verdict
Most coding interview rubrics have a category for testing and debugging, separate from "got the right answer." A candidate who writes clean code that happens to pass gets credit for correctness. A candidate who writes code with a bug, spots it through a deliberate trace, and fixes it while narrating their reasoning gets credit for correctness and debugging and communication.
So when your code fails, reframe the moment: you've just been handed a chance to show a skill that the candidate who passed on the first try never got to demonstrate. The goal now isn't to make the failure disappear as fast as possible. It's to make your debugging visible and calm.
Step 1: Pause and say what you see
Before touching the code, take two or three seconds and state the facts out loud:
"Okay, for the input
[3, 1, 2]I expected[1, 2, 3]and I got[1, 3, 2]. So the first element is right but the last two are swapped."
This does three things. It slows your heart rate down. It tells the interviewer you're in control. And it forces you to compare expected versus actual precisely, which is usually where the first clue lives. "It's wrong" gives you nothing to work with. "The last two are swapped" points you toward a loop boundary or a comparison.
If the failure is a crash, read the error message fully. An index-out-of-range on line 14 tells you exactly where to look first. Candidates under pressure often skip the error text entirely and start scanning the whole function.
Step 2: Form one hypothesis before you change anything
Resist the urge to edit. Instead, name the most likely cause:
"My guess is the inner loop stops one element early, because I used
n - 1there andn - i - 1in the outer bound."
A single, spoken hypothesis keeps you from shotgun debugging, where you change several things at once and lose track of which change mattered. It also gives the interviewer a chance to nudge you. If your hypothesis is far off, many interviewers will ask a question that redirects you, and that hint is far more useful when they know what you're thinking.
Common hypotheses worth checking first, roughly in order of how often they show up:
- Off-by-one in a loop bound or slice (
<versus<=,nversusn - 1). - Wrong initial value (starting a max at
0when inputs can be negative, an empty result that should hold a base case). - State not reset between iterations or test runs (a counter, a visited set, a running sum).
- Mutating input you're also reading from, like modifying a list while iterating it.
- Edge input you didn't handle: empty array, single element, all duplicates, negative numbers.
- Return in the wrong place, such as returning inside a loop instead of after it.
Step 3: Trace the smallest failing input by hand
If the failing case is large, shrink it. Find the smallest input that still breaks, often two or three elements. Then walk through your code line by line with that input, tracking variable values out loud or in a comment block:
i=0, j=0: arr=[3,1,2] compare 3>1 swap -> [1,3,2]
i=0, j=1: compare 3>2 ... loop already ended (j < n-1-i-1)
Tracing a tiny input is slower than staring at the code, but it's far more reliable. Bugs hide in the gap between what you think a line does and what it actually does, and a hand trace is the only thing that closes that gap. It also makes your reasoning completely transparent, which is exactly what the interviewer wants to see.
If you're in an environment where you can print, a single well-placed print of the key variables is fine. Just say why you're adding it, and remove it afterwards.
Step 4: Fix one thing, then say why it's the fix
When the trace reveals the problem, make the smallest change that addresses it and explain the connection:
"The inner loop bound should be
n - i - 1, notn - i - 2. I was excluding the last unsorted pair. Changing that now."
Avoid the temptation to also "clean up" nearby code in the same edit. If your fix plus a refactor still fails, you won't know which change caused what. One bug, one fix, one re-test.
Step 5: Re-run the failing case, then one case you haven't tried
Re-run the exact input that failed and confirm it passes. Then pick one more input that stresses a different path, usually an edge case:
"That passes now. Let me also try an empty array and a single element, since my loop bounds changed."
This shows you understand that a fix can introduce a new bug, and that you test like someone who ships code. If time is tight, at least name the edge cases you'd check, even if you don't run them all.
What to say if you can't find the bug
Sometimes the trace doesn't reveal it, and the clock is running. Silence is the worst option here. Instead:
- Summarize what you've ruled out. "The loop bounds look right for this input, and the initial values are fine. So the issue is probably in how I merge the two halves."
- Ask a focused question. "Would it be okay if I added a print in the merge step to see the intermediate state?" Most interviewers will say yes, and the question itself reads as mature.
- Offer the plan if time runs out. "If I had five more minutes, I'd trace the merge with
[1, 3]and[2]specifically, because that's where the ordering goes wrong." A clear next step earns partial credit; frantic editing earns none.
Mistakes that turn a small bug into a bad round
- Silent editing. Changing code without narrating leaves the interviewer guessing whether you understand the problem or are hoping for luck.
- Rewriting from scratch. Unless your approach is fundamentally wrong, throwing out working code to fix one bug wastes the time you need most.
- Blaming the test. "That test case seems unusual" is almost never a good look. Treat every failing input as valid until proven otherwise.
- Apologizing repeatedly. One "good catch, let me look" is plenty. Repeated apologies signal panic, not humility.
- Declaring victory after one pass. A single passing input after a fix doesn't prove much. Always check at least one more case.
How to practice this before the real thing
Debugging calmly is a skill you can rehearse, and most people never do. When you practice problems, don't just aim for "accepted." Deliberately keep your first buggy draft, then debug it out loud as if someone is watching: state the failure, name a hypothesis, trace a small input, fix one thing, re-test. Time yourself so you get used to doing it under a clock.
It also helps to practice in the same setup you'll interview in, with your code pad, a timer, and a place to jot hypotheses and edge cases next to the problem. If you want a structured way to rehearse that, Luna Interview is a Chrome side-panel practice copilot that sits beside your pad so you can run timed mock rounds, keep your notes in view, and review how you handled moments like this afterwards.
FAQ
Does failing a test case in a coding interview mean I failed the round?
Usually not. Interviewers expect first drafts to have bugs. How you find and fix the bug often matters as much as whether the first version was correct.
Should I debug silently to save time?
No. Narrating your debugging is part of what's being evaluated, and it lets the interviewer redirect you if you're heading the wrong way. Short, clear statements are enough.
How many test cases should I run after a fix?
Re-run the case that failed, then at least one edge case that exercises the code you changed, such as empty input or a single element.
Is it okay to use print statements in a live coding interview?
In most environments that allow running code, yes. Say why you're adding the print, keep it targeted to the variables you suspect, and remove it once you've found the issue.
Rehearse with an AI interview copilot, then browse commonly reported interview questions.