Mastering Technical Interviews

Lesson 7 — Wednesday, March 10, 2027 • King 150, 5:45–6:45 PM

Previous Lesson Next Lesson

Lesson Overview

Conquer technical interviews with confidence through systematic preparation, problem-solving frameworks, and hands-on practice. Learn to tackle coding challenges, system design questions, and behavioral interviews like a pro.

Technical Interviews Problem Solving

Lesson Slides

Use arrow keys or click the arrows to navigate • Press F for full screen

Technical Interviews — Demystified

What they actually look like and how to not freak out

Lesson 7 March 10, 2027 Interview Skills

What a Technical Interview Actually Looks Like

Not what you think. Most entry-level tech interviews are:

  • 45–60 minutes with an engineer or team lead
  • 1–2 coding problems (not necessarily hard LeetCode)
  • Conversation, not examination — they want to see how you think
  • Collaborative — they'll give hints. It's okay to ask for them.

⚠️ The biggest lie about tech interviews: "It's all about grinding LeetCode Hard." For entry-level roles, communication and problem-solving process matter more than whether you solved it.

The Interview Process Flow

  1. Resume Screen — ATS + recruiter review (pass/fail)
  2. Recruiter Phone Screen — 15–30 min, behavioral + background (pass/fail)
  3. Technical Phone Screen — 45–60 min, 1 coding problem or take-home
  4. Onsite / Virtual Final Round — 3–5 interviews: technical, system design (junior), behavioral
  5. Offer — Negotiate! Even interns can negotiate start date, location, stipends.

💡 Small companies often skip straight to a take-home project or single technical call. Know your target company's process.

What They're Actually Testing

Technical Signal

  • Can you break down a problem?
  • Do you know your data structures?
  • Can you write working code?
  • Do you test your solution?

Communication Signal

  • Do you ask clarifying questions?
  • Can you explain your thinking?
  • Do you recover well from hints?
  • Are you pleasant to work with?

💡 A candidate who solves the problem silently and gets it right often loses to a candidate who talks through their approach and gets it 80% right.

Data Structures You MUST Know

  • Arrays & Strings — Two pointers, sliding window, basic manipulation
  • Hash Maps / Sets — O(1) lookup, frequency counting, duplicate detection
  • Linked Lists — Traversal, reversal, cycle detection
  • Stacks & Queues — Matching brackets, BFS, monotonic patterns
  • Trees & Graphs — DFS, BFS, binary search tree operations
  • Sorting & Binary Search — Know the complexities, when to use each

✅ For internships, master Arrays, Hash Maps, and Trees. That covers ~70% of interview problems you'll see.

The 4-Step Interview Framework

  1. Clarify — Ask questions before writing a line of code. "Can the input be empty? Are there duplicates? What's the expected output for edge cases?"
  2. Plan — Talk through your approach before coding. Mention brute force first, then optimize. State time/space complexity.
  3. Code — Write clean, readable code. Narrate what you're doing. It's okay to be slow.
  4. Review — Test with examples, including edge cases. Find your own bugs. Say "let me trace through this."

🎯 This framework works even if you don't know the answer. Interviewers hire candidates who have a strong process.

Talking Through Your Code

This is what separates good candidates from great ones:

  • "I'm going to use a hash map here so I get O(1) lookup instead of O(n)..."
  • "The brute force would be O(n²) with nested loops. Can I do better? Let me think..."
  • "I'm initializing this pointer at the start of the array..."
  • "Wait, I think I have an off-by-one error here. Let me trace through..."

✅ Think of it as pair programming. You're the driver, the interviewer is the navigator. Keep them in the loop at all times.

LeetCode: How Much Is Enough?

Realistic prep advice (not "grind 500 problems"):

  • Master Easy problems first — If you can't do these reliably, Hard problems are pointless
  • 50–75 well-understood Medium problems — By pattern, not memorization
  • Learn the patterns: Two pointers, sliding window, BFS/DFS, dynamic programming basics
  • Practice explaining out loud — Solving silently doesn't train interview skills
  • Neetcode 150 — The best curated list for internship-level prep

⚠️ 2–3 months of consistent practice beats 2 weeks of panic grinding. Start now.

Mock Interview Activity

Pair up. One person is the interviewer, one is the candidate.

Problem: Given an array of integers, return the two numbers that add up to a target sum. Assume exactly one solution exists.

  • Candidate: Clarify, then explain approach before coding
  • Interviewer: Watch for: Does the candidate talk through their thinking? Do they test their solution?
  • After 10 minutes: Switch roles

✅ This is the #1 most common "easy" LeetCode problem. Everyone should be able to solve it in multiple ways.

Key Takeaways

  • Technical interviews test thinking process as much as correctness
  • Always clarify before coding — never start in silence
  • Master the 4-step framework: Clarify → Plan → Code → Review
  • For entry-level: focus on Arrays, Hash Maps, Trees, and Sorting
  • Use Neetcode 150. Practice explaining out loud, not just solving silently

🏠 Homework: Complete 5 LeetCode Easy problems using the 4-step framework. Write down your thought process for each.

Discussion Topics & Talking Points

Opening: The Technical Interview Reality

Question: "What's your biggest fear about technical interviews?"

  • Blanking out on algorithms you know
  • Not knowing the "right" answer immediately
  • Coding under pressure with someone watching
  • System design questions seeming impossible
  • Imposter syndrome hitting hard

Reality Check: Technical interviews test problem-solving process, not just final answers!

What Interviewers Actually Look For:

  • Problem-solving approach: How you break down complex problems
  • Communication skills: Can you explain your thinking clearly?
  • Code quality: Clean, readable, maintainable code
  • Debugging ability: How you handle errors and edge cases
  • Collaboration: How you work with hints and feedback
  • Growth mindset: How you handle challenges and learn

The Anatomy of Technical Interview Types

Know What You're Walking Into

1. Coding Challenges (Most Common)

  • Format: 45-60 minutes, whiteboard or shared editor
  • Topics: Data structures, algorithms, problem-solving
  • Examples: Array manipulation, tree traversal, dynamic programming
  • Goal: Working solution with good time/space complexity

2. System Design Interviews

  • Format: 45-60 minutes, whiteboard or drawing tool
  • Topics: Architecture, scalability, trade-offs
  • Examples: Design Twitter, URL shortener, chat system
  • Goal: Demonstrate understanding of large-scale systems

3. Behavioral Interviews

  • Format: 30-45 minutes, conversational
  • Topics: Past experiences, teamwork, leadership
  • Examples: "Tell me about a challenging project"
  • Goal: Assess cultural fit and soft skills

4. Take-Home Assignments

  • Format: 2-8 hours, your own environment
  • Topics: Full application or specific feature
  • Examples: Build a REST API, create a React component
  • Goal: See your real-world coding abilities

5. Pair Programming Sessions

  • Format: 60-90 minutes, collaborative coding
  • Topics: Working on actual company codebase
  • Examples: Fix a bug, add a feature, refactor code
  • Goal: See how you collaborate and communicate

The UMPIRE Method for Coding Problems

Your Step-by-Step Problem-Solving Framework

U - Understand the Problem

  • Read the problem statement carefully
  • Ask clarifying questions about inputs, outputs, constraints
  • Work through 2-3 examples manually
  • Identify edge cases and special scenarios
  • Example questions: "What if the array is empty?" "Are there duplicate values?"

M - Match to Known Patterns

  • Does this remind you of problems you've solved before?
  • What data structures might be useful?
  • Is this a searching, sorting, or graph problem?
  • Could you use two pointers, sliding window, or divide and conquer?

P - Plan Your Approach

  • Outline your solution in plain English
  • Break down into smaller steps
  • Consider multiple approaches and their trade-offs
  • Get interviewer buy-in before coding

I - Implement Your Solution

  • Write clean, readable code
  • Use meaningful variable names
  • Think out loud as you code
  • Handle edge cases as you go

R - Review Your Code

  • Walk through your solution with an example
  • Check for bugs, typos, and logic errors
  • Verify edge cases are handled
  • Discuss time and space complexity

E - Evaluate and Optimize

  • Can you improve the time or space complexity?
  • Are there alternative approaches?
  • What would you do differently with more time?
  • How would this scale with larger inputs?

Essential Data Structures and Algorithms

Your Technical Interview Toolkit

Must-Know Data Structures:

  • Arrays/Lists: Indexing, iteration, two-pointer techniques
  • Strings: Manipulation, parsing, pattern matching
  • Hash Tables/Maps: O(1) lookups, counting, caching
  • Stacks: LIFO operations, expression evaluation, backtracking
  • Queues: FIFO operations, BFS, level-order traversal
  • Linked Lists: Node manipulation, cycle detection, reversal
  • Trees: Binary trees, BSTs, traversals, tree properties
  • Graphs: Adjacency lists/matrices, DFS, BFS, shortest paths

Core Algorithms to Master:

  • Sorting: Quick sort, merge sort, heap sort
  • Searching: Binary search and its variations
  • Tree Traversals: Inorder, preorder, postorder, level-order
  • Graph Algorithms: DFS, BFS, Dijkstra's, topological sort
  • Dynamic Programming: Memoization, tabulation, common patterns
  • Greedy Algorithms: Activity selection, interval scheduling
  • Divide and Conquer: Merge sort, quick sort, binary search

Common Problem Patterns:

  • Two Pointers: Array problems, palindromes, pair finding
  • Sliding Window: Substring problems, array subarrays
  • Fast & Slow Pointers: Cycle detection, middle element
  • Merge Intervals: Overlapping intervals, scheduling
  • Cyclic Sort: Missing numbers, duplicate finding
  • Tree DFS: Path problems, tree manipulation
  • Tree BFS: Level-order problems, minimum depth
  • Backtracking: Permutations, combinations, N-Queens

System Design Interview Mastery

Thinking Like a Senior Engineer

The System Design Process:

  1. Clarify Requirements (5-10 minutes)
    • Functional requirements: What should the system do?
    • Non-functional requirements: Scale, performance, availability
    • Constraints: Budget, timeline, existing systems
  2. Estimate Scale (5 minutes)
    • How many users? Daily active users?
    • Read vs. write ratio
    • Data storage requirements
    • Bandwidth and QPS estimates
  3. High-Level Design (10-15 minutes)
    • Draw major components and their interactions
    • API design for key operations
    • Database schema design
    • Basic data flow
  4. Detailed Design (15-20 minutes)
    • Deep dive into critical components
    • Algorithm choices and trade-offs
    • Data structures and storage decisions
    • Caching strategies
  5. Scale and Optimize (5-10 minutes)
    • Identify bottlenecks
    • Scaling strategies (horizontal vs. vertical)
    • Load balancing and sharding
    • Monitoring and alerting

Key System Design Concepts:

  • Scalability: Horizontal vs. vertical scaling
  • Reliability: Fault tolerance, redundancy, backup
  • Availability: Uptime, disaster recovery, failover
  • Consistency: ACID properties, eventual consistency
  • Partition Tolerance: CAP theorem, network failures
  • Performance: Latency, throughput, response time

Common System Design Questions:

  • Design a URL shortener (like bit.ly)
  • Design a social media feed (like Twitter)
  • Design a chat system (like WhatsApp)
  • Design a video streaming service (like YouTube)
  • Design a ride-sharing service (like Uber)
  • Design a search engine (like Google)
  • Design a recommendation system (like Netflix)

Behavioral Interview Excellence

The STAR Method for Compelling Stories

STAR Framework:

  • Situation: Set the context and background
  • Task: Describe your responsibility or challenge
  • Action: Explain what you did specifically
  • Result: Share the outcome and what you learned

Common Behavioral Questions:

  • "Tell me about a time you faced a significant challenge"
  • "Describe a situation where you had to work with a difficult team member"
  • "Give me an example of when you showed leadership"
  • "Tell me about a time you failed and what you learned"
  • "Describe a project you're particularly proud of"
  • "How do you handle tight deadlines and pressure?"
  • "Tell me about a time you had to learn something new quickly"
  • "Describe a situation where you disagreed with your manager"

Story Bank Categories:

  • Leadership: Times you took charge or influenced others
  • Problem-Solving: Complex challenges you overcame
  • Teamwork: Successful collaboration experiences
  • Conflict Resolution: Disagreements you handled well
  • Learning: New skills or technologies you mastered
  • Failure: Mistakes you made and lessons learned
  • Innovation: Creative solutions you developed
  • Impact: Results you delivered or improvements you made

Crafting Compelling Stories:

  • Choose stories that highlight different skills
  • Include specific metrics and outcomes when possible
  • Show growth and learning from experiences
  • Keep stories concise (2-3 minutes max)
  • Practice until they feel natural

Interview Day Strategy and Mindset

Performing Under Pressure

Pre-Interview Preparation:

  • Technical Review: Practice 2-3 problems the night before
  • Company Research: Recent news, products, culture, values
  • Question Preparation: Have 3-5 thoughtful questions ready
  • Materials Ready: Resume copies, portfolio, notebook
  • Logistics Confirmed: Location, time, interviewer names

During the Interview:

  • Think Out Loud: Verbalize your thought process
  • Ask Questions: Clarify requirements and constraints
  • Stay Calm: Take deep breaths, it's okay to pause
  • Be Collaborative: Work with the interviewer, not against them
  • Show Enthusiasm: Genuine interest in the role and company

When You're Stuck:

  • Don't Panic: It's normal to get stuck sometimes
  • Think Aloud: Share what you're considering
  • Ask for Hints: "Could you give me a hint about the approach?"
  • Start Simple: Brute force solution first, then optimize
  • Use Examples: Work through small examples to find patterns

Handling Rejection:

  • Ask for Feedback: What could you improve?
  • Learn and Iterate: Use feedback to get better
  • Stay Positive: Each interview is practice for the next
  • Keep Applying: Don't let one rejection stop you

Homework

Do 5 LeetCode easy or medium problems this week. The goal isn't to memorize solutions — it's to practice thinking out loud. Explain your approach as you go, even if you're alone. That's the actual skill.

Not mandatory, but technical interviews are a skill, not a talent. Five problems a week compounds fast. Start now and you'll be a different person by interview season.

Submit through the Homework tab when done.

🎯 Week 1, Days 5-7: Mock Interview Practice

What to do: Conduct 3 mock technical interviews with peers or mentors

How to do it:

  • Schedule mock interviews with classmates or use Pramp/InterviewBuddy
  • Practice both interviewing and being interviewed
  • Record sessions to review communication and problem-solving
  • Get feedback on technical accuracy and presentation

Example submission:

"Mock Interview 1: Solved binary search problem in 18 minutes, feedback was good technical solution but need to communicate approach better. Mock Interview 2: Struggled with dynamic programming, learned to break down problem into subproblems. Mock Interview 3: Successfully solved tree traversal, interviewer praised clear explanation."

🗣️ Week 2, Days 8-11: Behavioral Interview Preparation

What to do: Prepare compelling stories using the STAR method

How to do it:

  • Write 8-10 STAR stories covering leadership, teamwork, challenges, failures
  • Practice common behavioral questions with friends or family
  • Research company values and prepare relevant examples
  • Record yourself answering questions to improve delivery

Example submission:

"Prepared 10 STAR stories: Leadership (led team project, organized study group), Teamwork (group programming assignment, hackathon collaboration), Challenge (debugging complex issue, learning new framework), Failure (missed deadline, learned time management). Practiced with roommate, improved from rambling answers to concise 2-minute responses."

🏢 Week 2, Days 12-14: Company-Specific Preparation

What to do: Research target companies and practice system design basics

How to do it:

  • Research 5 target companies' interview processes and common questions
  • Learn basic system design concepts (scalability, databases, APIs)
  • Practice explaining your projects in technical detail
  • Prepare thoughtful questions to ask interviewers

Example submission:

"Company research: Google (focus on algorithms, system design), Microsoft (behavioral + technical), Amazon (leadership principles + coding). System design basics: learned about load balancers, databases, caching, microservices. Can explain my web app architecture: React frontend, Node.js backend, MongoDB database, deployed on AWS. Prepared 15 questions about company culture, team structure, growth opportunities."

Homework

Do 5 LeetCode easy or medium problems this week. The goal isn't to memorize solutions — it's to practice thinking out loud. Explain your approach as you go, even if you're alone. That's the actual skill.

Not mandatory, but technical interviews are a skill, not a talent. Five problems a week compounds fast. Start now and you'll be a different person by interview season.

Submit through the Homework tab when done.

Previous Lesson Next Lesson