Defending your solution: the follow-ups after the code runs

Working code is half the round. Then the interviewer asks: why is it correct, what's the complexity and why, can you do better, what if the input changes, and how would you test it? This page shows what each follow-up is testing, and the difference between a solution that works and one you can defend, with the same solution defended two ways.

1. Passing code isn't the whole score

Interviewers score more than whether the code runs. The rubric in the open-source Tech Interview Handbook groups the signals into four areas: problem solving, technical competency, testing and communication. A strong candidate, it says, "determined time and space complexity accurately", "explained trade-offs of each solution clearly and correctly", "identified and self-corrected bugs in code" and "had time to discuss follow up problems/extensions". Company rubrics use different labels, but they score much the same things.

That's why the follow-ups matter: each one tests a signal the code alone doesn't show. This page builds on the six-step problem-solving method: its last two steps, Review and Evaluate, are where these questions come.

2. The five follow-ups

The proof ladder for a solution

Each thing you say about your solution sits on one of four rungs. Aim for rung 3 on every follow-up.

1. 0Outcome. "It passes the examples." True, and proves very little.
2. 1A label. "It's a sliding window." Names the idea without showing it applies.
3. 2The invariant. "The window never contains a repeated character." Now there's something to check.
4. 3The invariant, why each step keeps it, and what follows. "When a repeat enters, left jumps past its last position, so the window is valid again and no longer valid window is skipped; each index enters and leaves once, so O(n)."

3. One solution, defended twice

LeetCode 3, Longest substring without repeating characters. Both candidates write the same correct code. Then the interviewer asks the five follow-ups. Watch what reaches each set of notes.

def length_of_longest_substring(s: str) -> int:
    last = {}                      # char -> last index seen
    left = best = 0
    for right, ch in enumerate(s):
        if ch in last and last[ch] >= left:
            left = last[ch] + 1    # jump past the repeat
        last[ch] = right
        best = max(best, right - left + 1)
    return best

function lengthOfLongestSubstring(s: string): number {
  const last = new Map<string, number>();   // char -> last index seen
  let left = 0, best = 0;
  for (let right = 0; right < s.length; right++) {
    const seen = last.get(s[right]);
    if (seen !== undefined && seen >= left) left = seen + 1;   // jump past the repeat
    last.set(s[right], right);
    best = Math.max(best, right - left + 1);
  }
  return best;
}

static int lengthOfLongestSubstring(String s) {
    Map<Character, Integer> last = new HashMap<>();   // char -> last index seen
    int left = 0, best = 0;
    for (int right = 0; right < s.length(); right++) {
        Integer seen = last.get(s.charAt(right));
        if (seen != null && seen >= left) left = seen + 1;   // jump past the repeat
        last.put(s.charAt(right), right);
        best = Math.max(best, right - left + 1);
    }
    return best;
}

4. Try it yourself

Follow-up drill

Pick a problem you know, explain your solution out loud in a minute, then press Next follow-up and answer in under 60 seconds. Then reveal a strong answer and compare.

5. What interviewers look for

Each follow-up adds a line to the interviewer's notes, or doesn't.

6. Remember it

7. Common mistakes

8. Practice exercise (25 minutes)

1. Pick a problem you've solved (2 min). Any one from a pattern page, ideally one you could code from memory.
2. Write the five answers (12 min). One or two sentences each: the invariant, the counted complexity, whether you can beat it, one "what if", and three test cases that would catch a bug.
3. Drill it (8 min). Use the drill above: five random follow-ups, 60 seconds each, out loud.
4. Check against the pattern page (3 min). Does your invariant match the one on the page? Did your tests include its edge cases?

9. Self-check quiz

10. Go deeper