Mock Interviews and Practice

Solving problems alone isn't enough. You need to practice in interview conditions.

Why Mock Interviews Matter

The Performance Gap:

Solving alone: 80% success rate
Solving in interview: 40% success rate

What's different:

  • Someone is watching
  • You must explain your thinking
  • Time pressure is real
  • No pause button
  • Communication matters
  • Nerves affect performance

Solution: Practice in interview conditions regularly.

Types of Mock Interviews

1. Self-Administered (Weekly)

Setup:

1. Pick a problem you haven't seen
2. Set a 45-minute timer
3. No pausing, no hints
4. Code in a plain text editor (not IDE)
5. Talk out loud the entire time
6. Record yourself (optional but helpful)

After:

- Review the solution
- Grade yourself (1-4 scale)
- Note what went well/poorly
- Identify specific improvements

Example Setup:

# Mock Interview - Day 23
# Problem: Longest Palindromic Substring
# Start: 3:00 PM
# End: 3:45 PM

# [Solve problem here]

# Debrief:
# Score: 3/4 (Hire)
# Time: 38 minutes
# What went well: Identified pattern quickly, coded cleanly
# What to improve: Took too long to optimize
# Communication: Good - explained throughout

2. Peer Interviews (Bi-weekly)

Setup:

1. Find a study partner
2. Take turns being interviewer/candidate
3. 45 minutes per person
4. Give feedback after each

As Interviewer:

- Pick a problem they haven't seen
- Take notes on:
  * Problem solving approach
  * Code quality
  * Communication
  * Handling hints
- Give honest, constructive feedback

As Candidate:

- Treat it like a real interview
- Think out loud
- Ask questions
- Take feedback seriously

3. Platform Mock Interviews (Weekly)

Pramp (Free):

- Peer-to-peer mock interviews
- Automatically matched
- Both interview each other
- Pros: Free, realistic, feedback
- Cons: Peer quality varies

Interviewing.io ($$):

- Professional interviewers
- Anonymous (less pressure)
- Detailed feedback
- Pros: High quality, anonymous
- Cons: Expensive

LeetCode Mock Interview (Free):

- Simulated environment
- Random problem
- Timed
- Pros: Free, convenient
- Cons: No real interviewer

The Perfect Mock Interview

Pre-Interview (5 min)

Interviewer: "Hi! Ready to begin?"
Candidate: "Yes!"

Interviewer: "Great. I'll give you a problem. Feel free to ask
            clarifying questions. Let me know when you have a
            solution and we'll discuss. Ready?"

Candidate: "Ready!"

Problem Introduction (2 min)

Interviewer: Presents problem clearly
Candidate: Listens, takes notes

Clarification (3-5 min)

Good questions:
- Input constraints (size, range, type)
- Edge cases (empty, duplicates, negatives)
- Expected output format
- Can I modify input?
- Are there multiple solutions?

Solving (30-35 min)

Minute 0-5: Approach

Candidate: "Let me work through an example..."
          "I'm thinking about a few approaches..."
          "I'll start with X because Y..."

Minute 5-25: Implementation

Candidate: "I'll start by creating a hash map..."
          "Now I'll iterate through the array..."
          "Let me handle this edge case..."

Minute 25-30: Testing

Candidate: "Let me walk through my solution with an example..."
          "I should check these edge cases..."

Minute 30-35: Optimization

Candidate: "This is O(n²). Could we optimize with..."
          "The bottleneck is here..."

Wrap-up (5-10 min)

Interviewer: "How would you improve this?"
Candidate: Discusses time/space tradeoffs

Interviewer: "What about [edge case]?"
Candidate: Explains how code handles it

Interviewer: "Any questions for me?"
Candidate: Asks about team/role (practice!)

Interview Feedback Framework

What to Grade

Problem Solving (40%):

  • Asked clarifying questions (0-10)
  • Identified approach (0-10)
  • Handled edge cases (0-10)
  • Optimized solution (0-10)

Coding (30%):

  • Clean, readable code (0-10)
  • Correct implementation (0-10)
  • Proper syntax (0-10)

Communication (20%):

  • Explained thinking clearly (0-10)
  • Responded to hints (0-10)

Verification (10%):

  • Tested solution (0-10)

Total: __/100

Conversion:

  • 85-100: Strong Hire (4/4)
  • 70-84: Hire (3/4)
  • 50-69: Maybe (2/4)
  • < 50: No Hire (1/4)

Feedback Template

Strengths:
- [Specific thing done well]
- [Another strength]

Areas to Improve:
- [Specific issue with example]
- [Concrete suggestion]

Interview Score: X/4
Would hire: Yes/No/Maybe

Detailed Notes:
- Approach: [Comments]
- Implementation: [Comments]
- Communication: [Comments]

Common Mock Interview Mistakes

Mistake 1: Not Taking It Seriously

❌ "Hold on, let me check this real quick..."
❌ Pausing the timer
❌ Looking up syntax
❌ Taking breaks

✅ Treat it like a real interview
✅ No pauses, no lookups
✅ Work through discomfort

Mistake 2: Only Doing Happy Path

❌ Only testing the example given
❌ Skipping edge cases
❌ Not thinking about failure modes

✅ Test edge cases
✅ Consider invalid input
✅ Think about boundaries

Mistake 3: Silent Implementation

❌ *codes in silence for 20 minutes*

✅ "I'm creating a hash map to store..."
✅ "Now I'll handle the case where..."
✅ "Let me optimize this part..."

Mistake 4: Not Asking for Help

❌ Stuck for 15 minutes in silence

✅ "I'm stuck on X. Could I get a hint about Y?"
✅ "I've tried A and B. Any suggestions?"

Mistake 5: Ignoring Feedback

❌ "Yeah, yeah, I know"
❌ Making excuses
❌ Arguing with feedback

✅ "Good point, I didn't consider that"
✅ "How would you handle that case?"
✅ Taking notes on feedback

Practice Interview Schedule

Beginner (Weeks 1-4)

Week 1-2: None (learn fundamentals first)
Week 3: 1 self-administered mock
Week 4: 1 self-administered mock

Intermediate (Weeks 5-8)

Weekly: 1 self-administered mock
Bi-weekly: 1 peer mock

Advanced (Weeks 9-12)

Weekly: 1 self-administered mock
Weekly: 1 peer OR platform mock
Week 12: 3-4 company-style mocks

Simulating Different Interview Types

Phone Screen (45 min, 1 problem)

Setup:
- Use phone or video call
- Share screen with plain text editor
- Focus on one medium problem
- Expect to finish completely

Virtual Onsite (4-5 rounds)

Setup:
- Schedule 4-5 mocks back-to-back
- 45 minutes each
- Different problem types
- Short breaks between
- Practice endurance

Whiteboard Interview

Setup:
- Use actual whiteboard OR paper
- No syntax highlighting
- No running code
- Practice writing clearly
- Can't easily edit/refactor

Progress Tracking

Track your mock interview performance:

Mock Interview Log

Date: 2024-01-15
Platform: Self-administered
Problem: Longest Substring Without Repeating
Difficulty: Medium
Score: 2.5/4 (Borderline)
Time: 42 minutes
Notes: Struggled with window shrinking logic
      Need more sliding window practice

Date: 2024-01-22
Platform: Pramp (peer)
Problem: Course Schedule
Difficulty: Medium
Score: 3/4 (Hire)
Time: 38 minutes
Notes: Good! Identified graph pattern quickly
      Communication was clear

... continue tracking

Look for trends:

  • Improving scores over time?
  • Consistent weak areas?
  • Time management getting better?
  • Communication improving?

Mock Interview Debrief Checklist

After each mock, ask yourself:

Preparation:

  • Did I ask enough clarifying questions?
  • Did I work through examples?
  • Did I consider edge cases?

Approach:

  • Did I identify the pattern?
  • Did I consider multiple approaches?
  • Did I choose the right one?

Implementation:

  • Was my code clean?
  • Did I have bugs?
  • Did I finish in time?

Communication:

  • Did I explain my thinking?
  • Was I clear?
  • Did I respond well to feedback?

Optimization:

  • Did I analyze complexity?
  • Did I optimize when possible?
  • Did I discuss tradeoffs?

Red Flags to Fix

If you consistently:

Score < 2/4:

  • More fundamental practice needed
  • Not ready for interviews yet
  • Focus on easier problems

Run out of time:

  • Practice with strict timers
  • Do more speed drills
  • Pick slightly easier problems

Blank mind at start:

  • Need more pattern recognition
  • Practice more problems
  • Build pattern templates

Can't explain:

  • Practice talking out loud
  • Solve problems while explaining to wall
  • Do more peer mocks

Poor code quality:

  • Practice implementation
  • Review clean code principles
  • Code solutions after seeing them

Peer Mock Interview Script

Finding a Partner:

- LeetCode Discord
- Blind app
- Reddit r/cscareerquestions
- Bootcamp classmates
- Coworkers/friends

Session Structure:

6:00-6:45 PM: Person A interviews Person B
6:45-7:00 PM: Feedback session
7:00-7:45 PM: Person B interviews Person A
7:45-8:00 PM: Feedback session

Commitment:

- Meet weekly same time
- Alternate interviewer/interviewee
- Be honest with feedback
- Help each other improve

Key Takeaway

You can't prepare for interviews without simulating interview conditions. Mock interviews reveal gaps that solo practice can't: communication under pressure, time management with an audience, and handling unexpected questions. Schedule at least one mock per week, treat them seriously, and learn from every session. The difference between practice and mocks is the difference between knowing how to swim and swimming in the ocean.

PreviousChoosing the Right Problems
Congrats!Back to Courses