Most engineers prepare for tech interviews by grinding LeetCode. Many are surprised when they still get rejected from Google, Stripe, or the mid-size SaaS company down the street. The coding challenge is just one of four rounds that determine whether you get the offer, and it is often not the deciding one.

Here is the complete tech interview prep playbook — what to actually study, in what proportion, and the parts candidates routinely underestimate.

The four-round model

Modern tech interviews for mid to senior engineering roles are structured around four evaluation areas:

Coding / algorithms — 1-2 rounds
System design — 1-2 rounds (senior+)
Behavioral / leadership — 1 round
Domain or language depth — sometimes 1 round (backend, frontend, ML, etc.)

Distribute your prep time roughly in proportion to how these rounds are weighted in the final decision:

Coding: 40%
System design: 30% (higher for senior roles)
Behavioral: 20%
Domain depth: 10%

Most candidates do 90% coding and 10% everything else. That is why they fail.

Coding prep: do less, better

Grinding 500 LeetCode problems is the slow path. The fast path is pattern recognition. Most coding problems fall into 14 categories. Master the categories, not the problems.

The 14 patterns

Two pointers
Sliding window
Fast and slow pointers
Merge intervals
Binary search
Breadth-first search
Depth-first search
Backtracking
Topological sort
Dynamic programming (1D, 2D, knapsack)
Greedy
Heaps / top-k
Trie
Graph algorithms (Dijkstra, union-find)

Pick 3-4 problems per pattern (medium difficulty). That's 50-60 problems total — enough to cover 85% of interview questions. Do them twice: once with hints, once cold.

How to practice

Time yourself: aim for 30 minutes per medium problem, explained out loud
Talk through tradeoffs: brute force → optimization → complexity analysis
Write clean code: named variables, small functions, edge-case handling — interviewers mark you down for messy code even if it works
Mock interview: Pramp, Interviewing.io, or a friend. Solo practice misses the communication dimension that is half the evaluation.

System design: the round that decides senior offers

For mid-level and above, system design is usually the highest-weighted round. A good design interview signals scope, judgment, and tradeoff thinking — a bad one ends the process.

What they are testing

Not whether you can design Twitter from scratch. They are testing:

Can you clarify ambiguous requirements
Can you decompose a problem cleanly
Do you know the building blocks (databases, caches, queues, CDNs)
Can you make and defend tradeoffs
Do you catch obvious bottlenecks

The 40-minute structure

Most system design rounds are 45-60 minutes. Use this cadence:

0-5 min — Requirements: ask clarifying questions. Users, scale, features, consistency vs availability priorities.
5-10 min — Capacity estimation: QPS, storage, bandwidth. Back-of-envelope math.
10-15 min — API design: 3-5 core endpoints, request/response shapes.
15-25 min — High level design: clients, load balancer, services, databases, caches, queues. Draw it.
25-35 min — Deep dive: pick 1-2 components and go deep. Data schema, sharding, consistency, failure modes.
35-45 min — Scale and failures: what breaks at 10x? 100x? How do we handle it?

Topics you must know cold

Databases: relational vs NoSQL, indexing, partitioning, replication, CAP theorem
Caching: Redis vs Memcached, write-through vs write-back, invalidation strategies
Queues: Kafka, SQS, RabbitMQ — when to use what
Load balancing: round robin, consistent hashing, L4 vs L7
CDNs: when they help, cache invalidation
Consistency models: strong, eventual, causal
Common patterns: rate limiting, idempotency, retries with backoff, circuit breakers, pub/sub
Microservices vs monolith: when each is right

Practice problems

Aim for these classics, in order:

URL shortener
Twitter feed
WhatsApp / chat system
YouTube / video streaming
Uber / ride dispatch
Search typeahead
Rate limiter
Distributed cache
Payment processing system

Walk through each one with a timer. Record yourself. Where did you hesitate?

Behavioral: the round that decides close offers

When two candidates are equal technically, the behavioral round breaks the tie — and it decides ~40% of close calls at companies like Amazon, Meta, and Stripe.

What they are actually evaluating

Ownership
Bias for action
Dealing with ambiguity
Handling conflict
Judgment under pressure
Growth mindset

Prepare 8 stories

See the STAR method guide — same principles apply. Cover these themes:

A hard technical problem you solved
A time you failed
A conflict with a coworker or manager
A time you delivered under a tight deadline
A time you influenced without authority
A time you changed your mind based on new information
Your proudest technical achievement
A time you mentored or helped someone level up

Write each one in STAR format. Rehearse out loud until each lands in under 2 minutes.

Amazon-specific: Leadership Principles

If you are interviewing at Amazon, map every story to one or more of the 16 Leadership Principles. Amazon interviewers explicitly score against these, and candidates who don't reference them by name (or at least clearly map to them) lose ground.

Domain / language depth

Some rounds test how deeply you know your stack. Common examples:

Backend: concurrency, threading, memory management, SQL query optimization, indexing strategy
Frontend: event loop, render pipeline, React reconciliation, CSS specificity, browser performance
iOS / Android: lifecycle, memory management, threading, platform-specific patterns
ML: training vs inference, evaluation metrics, model selection, feature engineering

Brush up on fundamentals for the role you're actually applying to, not broad CS theory.

The often-skipped prep

1. Know the company

Spend an hour on their engineering blog. Read two or three posts. Reference one in the interview. "I read your post on how you sharded the billing database — I was curious about the rebalancing strategy..." This signals preparation and gives you genuine questions to ask.

2. Have 5 good questions ready

At the end of every round you'll be asked "Do you have questions for me?" Bad candidates ask about vacation policy. Good candidates ask:

What does the on-call rotation look like?
How are technical decisions typically made?
What is the hardest part of working here?
How is engineering quality measured?
Walk me through how the team shipped its most recent big project.

3. Know your resume cold

Interviewers will pick one bullet and ask you to go 3-4 levels deep. If you claim "Optimized database queries reducing latency by 40%", be ready to explain exactly which queries, what tooling you used to profile, what the final solution was, and what tradeoffs you accepted. Vague claims get exposed fast.

4. Salary negotiation research

Before your final round, know:

The role's salary band at that company (Levels.fyi is the best source)
The equivalent level if you have competing offers
Your walk-away number

You will be asked your expected compensation at some point. A prepared answer here can be worth $20-50k.

The 6-week plan

If you have 6 weeks, spend them roughly like this:

Week 1: Coding patterns 1-7, system design fundamentals (databases, caching)
Week 2: Coding patterns 8-14, system design patterns (queues, load balancing)
Week 3: Two full system design mocks, start writing behavioral stories
Week 4: 5 coding mocks (Pramp), 5 behavioral stories rehearsed, 2 design mocks
Week 5: Company-specific research, deep dive on weak areas, negotiation research
Week 6: Light practice only, rest, sleep well before the loop

The mindset

Tech interviews are as much about signal as skill. Interviewers are asking: would I trust this person to own a hard problem on my team? Technical ability, communication, humility, and judgment all feed that signal. Prepare across all four dimensions, not just LeetCode, and your offer rate will climb sharply.

Tech Interview Prep: Beyond the Coding Challenge