---

name: interview-technique-coach description: Teaches technical interview techniques, communication strategies, problem-solving approaches, and how to handle coding interviews effectively. Use when discussing interview preparation, how to approach problems during interviews, communication skills, or interview best practices.

Interview Technique Coach

Master the art of technical interviews beyond just solving problems.

The Interview Process Framework

Successful interviews require more than correct code - you need to demonstrate problem-solving ability, communication skills, and engineering judgment.

The 5-Phase Approach

1. Clarification (3-5 minutes)

What to do:

• Restate the problem in your own words
• Ask about edge cases and constraints
• Confirm input/output format
• Understand the expected complexity

Example Questions:

• "Can the array be empty?"
• "Are there duplicate values allowed?"
• "What's the expected size of the input - thousands or millions?"
• "Should I optimize for time or space complexity?"
• "What should I return if there's no valid answer?"

Why this matters:

• Shows you think before coding
• Prevents solving the wrong problem
• Demonstrates thoroughness
• Uncovers hidden requirements

2. Planning (5-10 minutes)

What to do:

• Discuss multiple approaches (brute force → optimal)
• Explain tradeoffs between solutions
• Get buy-in before coding
• Confirm the approach with interviewer

Template:

"Here's my thought process:

The brute force approach would be [describe] with time complexity O(n²).

We can optimize this by [technique] which would give us O(n log n).

If we use [data structure], we can achieve O(n) time but O(n) space.

I think the [chosen approach] would be best here because [reasoning].
Does that sound good to you?"

Why this matters:

• Shows structured thinking
• Gives interviewer chance to guide you
• Prevents wasting time on wrong approach
• Demonstrates you understand tradeoffs

3. Implementation (15-20 minutes)

What to do:

• Write clean, readable code
• Use meaningful variable names
• Add comments for complex logic
• Think out loud as you code
• Test as you go with simple examples

Communication while coding:

• "I'm creating a hash map to store..."
• "Now I'll iterate through the array..."
• "I need to handle the edge case where..."
• "Let me add a helper function for..."

Code quality tips:

• Consistent naming conventions (camelCase or snake_case)
• Clear function/variable names (not a, b, temp)
• Proper indentation and spacing
• Early returns for edge cases
• Extract complex logic into helper functions

Why this matters:

• Shows you write production-quality code
• Demonstrates you think about maintainability
• Easier for interviewer to follow
• Mirrors real engineering work

4. Testing (5-10 minutes)

What to do:

• Walk through your code with examples
• Test edge cases
• Trace through complex logic
• Find and fix bugs yourself

Testing strategy:

"Let me test this with a few examples:

1. Normal case: [1, 2, 3, 4] → expected output 10
   - Step through the logic...
   - ✓ Works

2. Edge case: Empty array []
   - Should return 0
   - ✓ Works

3. Edge case: Single element [5]
   - Should return 5
   - ✓ Works

4. Edge case: Negative numbers [-1, -2, -3]
   - Let me trace through...
   - Oh, I need to fix this condition on line 15"

Why this matters:

• Shows you care about correctness
• Demonstrates debugging skills
• Catches bugs before interviewer points them out
• Builds confidence in your solution

5. Analysis & Optimization (3-5 minutes)

What to do:

• State time and space complexity
• Explain why these are the complexities
• Discuss potential optimizations
• Consider alternative approaches

Template:

"The time complexity is O(n log n) because we're sorting the array.
The space complexity is O(1) if we don't count the output array.

We could potentially optimize further by [idea], but that would
add complexity without significant benefit for typical input sizes.

If the input had [specific property], we could use [alternative]
to achieve O(n) time."

Why this matters:

• Shows you understand algorithmic analysis
• Demonstrates you think about performance
• Reveals depth of knowledge
• Shows engineering judgment

Communication Best Practices

Think Out Loud

Good:

• "I'm thinking we need a way to track duplicates, so a hash set makes sense here"
• "This loop needs to go backwards because we're modifying the array"
• "I'm considering using binary search since the array is sorted"

Bad:

• Complete silence while coding
• Only speaking when asked
• Not explaining your reasoning

Ask for Hints Strategically

Good way to ask:

• "I'm considering approaches A and B. Am I on the right track?"
• "I'm stuck on optimizing this part. Could you give me a hint about the data structure?"
• "I feel like there's a pattern I'm missing here"

Bad way to ask:

• "I have no idea how to solve this"
• Sitting in silence without attempting anything
• Asking for the complete solution

Handle Mistakes Gracefully

When you realize an error:

• "Actually, I see a bug in my logic here on line 12"
• "Let me fix this edge case I missed"
• "I need to reconsider this approach"

Don't:

• Get flustered or defensive
• Make excuses
• Blame the problem or interviewer
• Give up

Manage Your Time

Time allocation for 45-minute interview:

• Clarification: 5 minutes
• Planning: 7 minutes
• Implementation: 20 minutes
• Testing: 8 minutes
• Optimization discussion: 5 minutes

If running behind:

• "I notice we're running short on time. Should I finish implementing this or move to testing?"
• Prioritize working code over perfect code
• Skip minor optimizations

Problem-Solving Strategies

When You're Stuck

1. Talk through examples

   • Work through 2-3 concrete examples manually
   • Look for patterns in how you solve them

2. Simplify the problem

   • "What if the array only had 2 elements?"
   • "What if we ignore the constraint about X?"

3. Consider related problems

   • "This reminds me of the two-sum problem"
   • "I've seen similar with [pattern]"

4. Break it down

   • "Let me solve the subproblem of X first"
   • "What if I could use a helper function that does Y?"

5. Think about data structures

   • What information do I need to track?
   • What operations do I need to perform?
   • Which structure gives me those operations efficiently?

Pattern Recognition

When you see these keywords, think:

• "All pairs" → Nested loops or hash map
• "Optimal/maximum/minimum" → DP or greedy
• "Sorted array" → Binary search or two pointers
• "Substring/subarray" → Sliding window
• "Tree" → DFS or BFS
• "Graph" → DFS, BFS, or union-find
• "Top K elements" → Heap
• "In-place" → Two pointers or careful swapping

Common Pitfalls to Avoid

Technical Mistakes

1. Off-by-one errors

   • Double-check loop boundaries
   • Test with small examples
   • Be careful with inclusive vs exclusive ranges

2. Null/undefined handling

   • Check for null inputs
   • Handle empty arrays/strings
   • Consider undefined behavior

3. Integer overflow

   • Be aware when dealing with large numbers
   • Mention if it could be an issue
   • Use appropriate data types

4. Modifying while iterating

   • Be careful iterating and deleting
   • Consider iterating backwards
   • Use a copy if needed

Communication Mistakes

1. Not asking clarifying questions

   • Always ask about constraints
   • Don't make assumptions
   • Confirm edge cases

2. Jumping straight to code

   • Always discuss approach first
   • Get buy-in from interviewer
   • Show your thought process

3. Not explaining tradeoffs

   • Discuss multiple approaches
   • Explain why you chose your approach
   • Mention alternatives

4. Getting defensive

   • Hints are help, not criticism
   • Bugs are expected
   • Stay collaborative

Language and Syntax Tips

Python

# Good: Clear and Pythonic
def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

JavaScript

// Good: Modern and clean
function twoSum(nums, target) {
    const seen = new Map();
    for (let i = 0; i < nums.length; i++) {
        const complement = target - nums[i];
        if (seen.has(complement)) {
            return [seen.get(complement), i];
        }
        seen.set(nums[i], i);
    }
    return [];
}

General tips:

• Use descriptive names: seen not m or map
• Use language idioms: enumerate() in Python, forEach() in JS
• Know built-in methods: Array.prototype.map(), dict.get(), etc.
• Consistent style: pick camelCase or snake_case and stick with it

Mock Interview Practice

Self-Practice Routine

1. Set a timer (30-45 minutes)
2. Read problem (don't peek at solution)
3. Follow the 5-phase approach out loud
4. Write code on whiteboard or paper (not IDE)
5. Test manually without running code
6. Review solution and note what you missed

Practice with Others

• Take turns being interviewer and candidate
• Give honest feedback
• Practice explaining thought process
• Simulate realistic time pressure

What to Practice

• Weeks 1-2: Easy problems, focus on communication
• Weeks 3-4: Medium problems, mix of patterns
• Weeks 5-6: Medium/hard, time pressure
• Week 7+: Mock interviews, company-specific problems

Red Flags to Avoid

What interviewers don't want to see:

• ❌ Silence for extended periods
• ❌ Refusing to consider alternative approaches
• ❌ Not testing your code
• ❌ Sloppy, unreadable code
• ❌ Ignoring hints or feedback
• ❌ Making assumptions without asking
• ❌ Getting visibly frustrated
• ❌ Giving up easily

Green Flags to Show

What impresses interviewers:

• ✅ Clear communication throughout
• ✅ Asking thoughtful questions
• ✅ Considering multiple approaches
• ✅ Writing clean, readable code
• ✅ Thorough testing
• ✅ Graceful handling of mistakes
• ✅ Good time management
• ✅ Collaborative attitude

Day-of-Interview Tips

Before the Interview

• Get good sleep (more important than last-minute practice)
• Review common patterns (don't learn new topics)
• Warm up with 1-2 easy problems
• Test your equipment (camera, mic, screen sharing)
• Have water and paper/pen ready

During the Interview

• Smile and be personable
• Treat interviewer as a teammate, not adversary
• Don't panic if you don't immediately know the answer
• Use the hints they give you
• Show enthusiasm for the problem

After the Interview

• Send thank-you email
• Reflect on what went well and what didn't
• Don't dwell on mistakes
• Learn from the experience

Remember

The interview is not just about getting the right answer - it's about demonstrating:

• Problem-solving ability
• Communication skills
• Coding proficiency
• Ability to work with others
• Learning from feedback

Many candidates with perfect solutions fail because of poor communication. Many candidates with imperfect solutions succeed because they showed great process.

The process matters as much as the result.