Budget: ~15 hrs/week (2 hrs × 5 weekdays + 5 hrs across the weekend). Scale up or down, but keep the ratio: 50% coding, 30% system design, 20% behavioral + review.
Non-negotiable rule: every practice problem is done out loud, on a timer, in a plain editor (Google Docs or a text file — no autocomplete, no linter, no running the code). This is the single biggest gap between people who grind LeetCode and people who pass Google.
Weekly rhythm (template)
| Day | Block | Content |
|---|---|---|
| Mon | 2h | 2 coding problems (timed 25 min each) + review |
| Tue | 2h | 1h system design reading/building blocks · 1h coding |
| Wed | 2h | 2 coding problems + rewrite one from memory |
| Thu | 2h | 1 full system design problem (45 min, spoken, whiteboard/doc) |
| Fri | 1h | Behavioral: write/refine 1–2 STAR stories out loud |
| Sat | 3h | Mixed timed set (3 problems) + full review of the week’s misses |
| Sun | 2h | Spaced repetition: re-solve 3 previously-failed problems cold |
Sunday spaced repetition is where the retention actually happens. Do not skip it for new problems.
Week 1 — Baseline + foundations
Goal: find out where you actually are, and rebuild the primitives.
- Take a cold baseline: 3 medium problems, 25 min each, timed, spoken. Record results in
05-practice-log.md. Do not look anything up. - Topics: arrays, strings, two pointers, sliding window, hashing, prefix sums.
- Re-derive from scratch (write, don’t read): binary search with all three variants (exact, lower bound, upper bound), quicksort partition, iterative tree traversal.
- Set up your environment: a Google Doc with a monospace font, and a timer. Practice there exclusively.
- Behavioral: brain-dump every project from the last 3 years into
04-behavioral-story-bank.md— raw notes only, no formatting yet.
Exit criteria: you can write a correct binary search that handles duplicates, first pass, no debugging.
Week 2 — Core patterns I
Goal: stop pattern-recognizing and start pattern-deriving.
- Topics: stacks & monotonic stacks, queues, linked lists, intervals (merge/insert/sweep line), sorting-based tricks, heaps & top-K.
- 12–14 problems, all timed. Target: 70% solved within 25 min.
- System design starts here: read the estimation + non-functional requirements sections of
03-system-design-curriculum.md. Do 3 back-of-envelope estimates (QPS, storage/year, bandwidth) on paper. - Behavioral: convert 3 raw projects into full STAR stories.
Exit criteria: given “find the next greater element”, you reach monotonic stack in under 60 seconds and can explain why it’s amortized O(n).
Week 3 — Core patterns II: trees & graphs
Goal: graphs are Google’s favorite category. Own them.
- Topics: binary trees (traversals, LCA, path sums, serialization), BST invariants, tries, BFS/DFS on grids and graphs, topological sort, union-find, Dijkstra, cycle detection.
- 14–16 problems. At least 6 must be grid/matrix problems — Google loves them.
- Implement from memory, no reference: union-find with path compression + union by rank, Dijkstra with a heap, Kahn’s topological sort.
- System design: building blocks — load balancing, caching, CDN, SQL vs NoSQL, replication, sharding. One page of notes per topic in your own words (
06-system-design-reference.mdhas the depth; write yours from it, don’t copy it). - Behavioral: 3 more STAR stories (target: 6 total).
Exit criteria: you can write union-find and Dijkstra cold, correctly, in under 10 minutes each.
Week 4 — DP, backtracking, and design-y coding
Goal: clear the categories most people avoid.
- Topics: 1-D DP, 2-D DP, knapsack variants, LIS (both O(n²) and O(n log n)), interval DP, bitmask DP (Google does ask), backtracking/permutations, greedy + exchange argument.
- 14–16 problems. Every DP problem: write the recurrence in words first, then memoized recursion, then bottom-up. Never jump straight to a table.
- Object-design coding: LRU cache, LFU cache, an iterator class, a rate limiter, a file system, an in-memory key-value store with TTL. These test API design, which is an L5 signal.
- System design: consistency models, CAP in practice, message queues, pub/sub, idempotency, rate limiting.
- First timed mock coding interview with a human or an AI interviewer. Record it.
Exit criteria: you can go from problem statement → correct recurrence → working bottom-up DP in 25 minutes for a standard medium.
Week 5 — System design intensive I
Goal: shift the center of gravity. Design becomes the main event.
- 5 full design problems, 45 min each, spoken, timed. Pick from: URL shortener, rate limiter, web crawler, search typeahead/autocomplete, distributed cache.
- After each: write a self-critique — what did you miss? Did you scope before designing? Did you estimate? Did you name a failure mode?
- Read 2 Google papers and take notes: MapReduce and Bigtable. Being able to reference real systems by name is a differentiator.
- Coding maintenance: 8 problems, mixed, timed — do not let coding decay.
- Behavioral: 4 more stories (target: 10). Start rehearsing them at 2 minutes each.
Exit criteria: you can run the first 10 minutes of a design (scope → requirements → estimation → API) without hesitating.
Week 6 — System design intensive II + behavioral polish
- 5 more design problems: news feed, chat/messaging system, video streaming (YouTube), Google Drive/Dropbox, distributed job scheduler.
- Read Spanner and GFS papers (skim, focus on the tradeoffs and why they were made).
- Deep-dive drills: pick 3 designs you’ve already done and go one level deeper on a single component (the sharding scheme, the hot-key problem, the consistency guarantee). L5 interviews live in these deep dives.
- Behavioral: rehearse all 10 stories out loud, recorded. Cut every one to ≤ 2.5 min. Prepare 3 sharp questions for your interviewers.
- Coding maintenance: 8 problems.
- Second mock: full system design round with a human.
Exit criteria: no story runs long, no story is missing a measurable outcome, and every story answers “what would you do differently?”
Week 7 — Full mock loops
Goal: simulate the real thing, then repair.
- Two full mock loops on separate days: 3 coding + 1 design + 1 behavioral, back-to-back, no breaks longer than 10 min. Fatigue is a real failure mode — train for it.
- Ruthless weak-area repair: whatever the mocks exposed gets 100% of your remaining discretionary time.
- Re-solve every problem you have ever failed in the log, cold.
- Coding: 10 problems at hard difficulty, timed.
Exit criteria: two mock loops where an experienced interviewer would say “hire” on the coding and “hire” or “leaning hire” on design.
Week 8 — Taper and execute
Goal: peak, don’t cram. Cramming the week before actively hurts performance.
- Volume drops ~50%. 1–2 problems/day, medium difficulty, for warmth only.
- Re-read your own notes — not new material. No new topics this week.
- Re-read your story bank once daily. Do not re-memorize; re-familiarize.
- Logistics: test the video setup, the shared doc, the camera, the room, the backup internet. Have water and paper.
- Day before: one easy problem, one story read-through, then stop by noon. Sleep.
Day-of checklist:
- Restate the problem back before writing anything.
- Ask clarifying questions — always, even if the problem seems obvious.
- State the brute force, then improve it. Never sit silently.
- Say the complexity before you’re asked.
- Walk through your own code with a concrete example before declaring done.
- If you’re stuck for 90 seconds, say what you’re considering and why it isn’t working. Silence is scored; struggling out loud is not.
Tracking
Keep exactly these numbers in 05-practice-log.md. Nothing else matters:
- Solve rate at 25 min, cold, unaided. Target ≥ 80% on mediums, ≥ 40% on hards by Week 7.
- First-pass correctness — how often your code is right before you debug it. Target ≥ 70%. This is the L5 coding signal.
- Design coverage — of the 12 problems, how many you’ve run end-to-end at full 45-min length.
- Stories rehearsed out loud — target 10+, each under 2.5 minutes.