Mid-Level / Intermediate Interview Prep
This guide is for: Engineers with 2–5 years of professional experience interviewing for IC2/IC3 roles (L4 at Google/Meta, SDE II at Amazon, mid-level at most companies).
Time budget: 2–3 weeks, ~1.5 hours/day
What Interviewers Expect at This Level
Mid-level is where the bar shifts meaningfully. You're no longer expected to just write working code — you're expected to write good code and start showing independent thinking.
| What they test | What they're really asking |
|---|---|
| DSA (medium difficulty) | Can you navigate problems without heavy guidance? |
| Code quality | Is your code clean, readable, and handles edge cases? |
| Debugging | Can you find and fix bugs under pressure? |
| Ownership | Have you shipped real features independently? |
| Collaboration | Can you disagree constructively and work across teams? |
| Basic system design | Do you understand how services talk to each other? |
The key shift from entry-level: Interviewers expect you to arrive at a clean solution with minimal hints. A brute-force-only solution is not enough at this level.
The 2-Week Study Plan
Week 1 — Sharpen DSA to Medium Level
Days 1–2: Core Patterns Review
If you've done LeetCode before, this is a calibration. Solve these in under 20 minutes each:
- LeetCode 15 — 3Sum (Two Pointers)
- LeetCode 238 — Product of Array Except Self (Arrays)
- LeetCode 347 — Top K Frequent Elements (Heap)
- LeetCode 424 — Longest Repeating Character Replacement (Sliding Window)
If any of these took > 30 minutes, that topic needs focused practice this week.
Days 3–4: Trees & Graphs (hardest category for most mid-levels)
// Pattern 1: DFS with return value (most tree problems)
function maxPathSum(root) {
let maxSum = -Infinity;
function dfs(node) {
if (!node) return 0;
const left = Math.max(0, dfs(node.left)); // ignore negative paths
const right = Math.max(0, dfs(node.right));
maxSum = Math.max(maxSum, node.val + left + right); // update global max
return node.val + Math.max(left, right); // return best single path
}
dfs(root);
return maxSum;
}
// Pattern 2: BFS for shortest path
function shortestPath(grid, start, end) {
const queue = [[...start, 0]]; // [row, col, distance]
const visited = new Set([`${start[0]},${start[1]}`]);
while (queue.length) {
const [r, c, dist] = queue.shift();
if (r === end[0] && c === end[1]) return dist;
for (const [dr, dc] of [[1,0],[-1,0],[0,1],[0,-1]]) {
const [nr, nc] = [r + dr, c + dc];
const key = `${nr},${nc}`;
if (nr >= 0 && nr < grid.length && nc >= 0 && nc < grid[0].length
&& grid[nr][nc] !== 1 && !visited.has(key)) {
visited.add(key);
queue.push([nr, nc, dist + 1]);
}
}
}
return -1;
}
Focus problems:
- LeetCode 235 — Lowest Common Ancestor of BST
- LeetCode 102 — Binary Tree Level Order Traversal
- LeetCode 200 — Number of Islands
- LeetCode 207 — Course Schedule (cycle detection) ⭐
- LeetCode 417 — Pacific Atlantic Water Flow
Days 5–6: Dynamic Programming (the most feared topic)
The secret to DP: always ask "what am I maximizing/minimizing, and what is my last step?"
// 1D DP: House Robber
// dp[i] = max money robbing houses 0..i
// dp[i] = max(dp[i-1], dp[i-2] + nums[i])
function rob(nums) {
let prev2 = 0, prev1 = 0;
for (const num of nums) {
[prev2, prev1] = [prev1, Math.max(prev1, prev2 + num)];
}
return prev1;
}
// 2D DP: Unique Paths
// dp[i][j] = number of paths to reach cell (i,j)
// dp[i][j] = dp[i-1][j] + dp[i][j-1]
function uniquePaths(m, n) {
const dp = Array.from({ length: m }, () => new Array(n).fill(1));
for (let i = 1; i < m; i++) {
for (let j = 1; j < n; j++) {
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
return dp[m-1][n-1];
}
Focus problems:
- LeetCode 70 — Climbing Stairs
- LeetCode 198 — House Robber ⭐
- LeetCode 322 — Coin Change ⭐
- LeetCode 300 — Longest Increasing Subsequence
- LeetCode 1143 — Longest Common Subsequence
Day 7: Weak area deep-dive + 2 full timed sessions
Week 2 — System Design + Behavioral
Days 8–9: System Design Fundamentals
At mid-level, you won't be expected to design Twitter from scratch. But you should understand the building blocks and have an opinion on trade-offs.
The 5 building blocks every mid-level must know:
1. Load Balancer
[Client] → [Load Balancer] → [Server 1]
→ [Server 2]
→ [Server 3]
- Distributes traffic across multiple servers
- Round-robin, least-connections, or consistent hashing
- Enables horizontal scaling and eliminates single point of failure
2. Cache (Redis)
- Cache-aside pattern: check cache → miss → query DB → store in cache
- When to use: read-heavy data, expensive queries, session storage
- Key question: when does the cache become stale? (TTL, write-through, invalidation)
3. Database Design
-- Think about: indexes, foreign keys, normalization
-- Mid-level should know:
-- PRIMARY KEY, FOREIGN KEY, INDEX
-- SELECT with JOIN, WHERE, GROUP BY, ORDER BY
-- When to use SQL vs NoSQL
4. API Design
REST conventions:
GET /users → list users
POST /users → create user
GET /users/:id → get user
PUT /users/:id → update user
DELETE /users/:id → delete user
Status codes you must know:
200 OK, 201 Created, 400 Bad Request,
401 Unauthorized, 403 Forbidden, 404 Not Found, 500 Server Error
5. Async Processing (Queues)
[Web Server] → [Queue] → [Worker] → [DB/Email/etc]
Use when: email sending, image processing, notifications,
anything that can be delayed without affecting the user response
Sample mid-level system design question:
"Design a URL shortener."
Good mid-level answer covers:
- POST
/shortenAPI that takes a long URL and returns a short code - GET
/:codethat redirects to the long URL - Database table:
urls(id, short_code, long_url, created_at) - Redis cache for popular URLs (O(1) redirect)
- Hash function to generate short codes (mention collision handling)
- Estimate: 100M URLs, 10B redirects/day → need cache
Days 10–11: Behavioral Depth
Mid-level interviewers want real stories with real impact. "We built a feature" is not enough — they want to know your specific role and measurable outcome.
The 8 stories every mid-level must have:
| Story | What it proves |
|---|---|
| Project you owned end-to-end | Independence, full-stack thinking |
| Performance optimization you did | Technical depth, initiative |
| Bug you tracked down | Debugging skills, persistence |
| Time you improved a process | Ownership beyond your immediate tasks |
| Disagreement with a teammate/manager | Communication, healthy pushback |
| Time you mentored or helped someone | Early leadership signals |
| Project that didn't go as planned | Handling adversity, learning mindset |
| Most complex technical decision you made | Depth of technical thinking |
High-frequency mid-level behavioral questions:
- "Tell me about a time you took ownership of something that wasn't strictly your responsibility."
- "Describe a complex technical problem you solved."
- "Tell me about a time you disagreed with your tech lead's approach."
- "How do you prioritize when you have multiple things competing for your time?"
- "Tell me about a time you improved a system's performance."
- "Describe a time you collaborated across teams to deliver something."
- "What's the most impactful thing you've shipped in the last year?"
Day 12: Mid-level specific question drill
Practice answering these with STAR format, aiming for 2–3 minutes each:
- Walk me through your most complex project.
- How do you approach a codebase you've never seen?
- Tell me about a time a project was at risk. What did you do?
Days 13–14: Full mock loops
Do 2 complete mock interviews (each is 45 min DSA + 15 min behavioral + 10 min system design).
Mid-Level Cheat Sheet
LeetCode Problem Targets
| Category | Problems to solve | Target time |
|---|---|---|
| Easy | All easy in your weak area | < 10 min |
| Medium — Arrays/Strings | 10–15 | < 20 min |
| Medium — Trees/Graphs | 10–15 | < 25 min |
| Medium — DP | 8–10 | < 30 min |
| Medium — Heap | 5–8 | < 20 min |
| Hard | 3–5 (stretch goal) | < 40 min |
System Design Vocabulary (know these)
| Term | One-line definition |
|---|---|
| Horizontal scaling | Add more servers (vs vertical = bigger server) |
| CAP theorem | Can only guarantee 2 of: Consistency, Availability, Partition-tolerance |
| Eventual consistency | Replicas may be temporarily out of sync but will converge |
| Idempotency | Calling an API N times has the same effect as calling it once |
| CDN | Servers geographically close to users that cache static assets |
| Message queue | Decouples producer and consumer; enables async processing |
| Sharding | Horizontal partitioning of a database across multiple machines |
| Index (DB) | Data structure that speeds up lookups at the cost of write speed |
| Read replica | Copy of DB that handles read traffic, freeing up primary for writes |
Interview Anti-Patterns at This Level
❌ Brute force and done — always discuss complexity and mention potential optimizations ❌ Vague behavioral stories — "we built a thing" → "I redesigned the caching layer, reducing p99 latency from 800ms to 120ms" ❌ No system design opinion — even if you're unsure, articulate trade-offs ❌ Not asking clarifying questions — mid-level engineers define the scope before they build ❌ Only talking about "we" — interviewers want to know what you specifically did
Salary Negotiation Note
Mid-level is often where engineers leave significant money on the table. Always:
- Anchor high — research the market using levels.fyi and Glassdoor
- Never give a number first if you can avoid it
- Negotiate total comp (base, equity, bonus), not just base
- Get competing offers if you can — they're your best leverage