6-Month Serious Track
Audience: You’re targeting strong Big Tech readiness. You can put in 15–25 hours/week sustainably for 6 months.
Tradeoffs:
- You will cover Phase 7 (competitive) selectively — not full grandmaster prep.
- You will get to “consistently solves FAANG hards in 45–60 minutes” with strong follow-ups.
- You will have meaningful depth in your primary language’s runtime.
- This is the recommended track for most readers.
Sufficient for: all FAANG levels including senior, infrastructure, platform, distributed systems, most backend specialties.
Daily Cadence
- Weekday: 2–3 hours
- 60 min: new content (read + 1 lab or 2–3 concept docs)
- 60 min: problem solving (2–4 problems)
- 30 min: review queue
- Saturday: 4 hours
- 1 mock interview (90 min)
- 2 hours problem solving
- 30 min: failure analysis + review
- Sunday: 2 hours
- Re-solves at Tier 4–5
- Weakness drilling
Total: 18–22 hours/week
Monthly Milestones
Month 1 — Foundations (Weeks 1–4)
Cover: Phase 0 + Phase 1 fully, Phase 9 (your primary language) partially.
- Week 1: Phase 0 (all 7 labs), 25 Easy problems
- Week 2: Phase 1 DS docs (arrays, strings, hashmaps, stacks, queues, linked lists), Phase 1 runtime (stack vs heap, scope, value/reference, mutability), 30 problems
- Week 3: Phase 1 DS continued (heaps, sorting, binary search, recursion, basic trees, basic graphs, basic DP), 30 problems, 2 labs
- Week 4: Phase 1 runtime complete (hash collisions, iterator invalidation, GC, memory leaks, deep/shallow copy), Phase 9 your-language (first half), 30 problems, 3 labs
End-of-month: all Phase 1 mastery checks pass. 1 mock at Easy level, scored 7+/10.
Volume: ~115 problems, 10+ labs.
Month 2 — Patterns Mastery (Weeks 5–8)
Cover: Phase 2 fully, Phase 9 your-language fully.
- Week 5: two pointers, sliding window, prefix sums, difference arrays, hashing, sorting+greedy. 5 problems per pattern.
- Week 6: binary search, binary search on answer, monotonic stack, monotonic queue, intervals, linked list manipulation. 5 per pattern.
- Week 7: tree DFS/BFS, graph DFS/BFS, topological sort, union find. 5 per pattern. 3 labs.
- Week 8: backtracking, basic DP, 1D DP, 2D DP, knapsack basics, subsequence DP, string DP, trie, heap top-K, K-way merge. 4 per pattern.
End-of-month: mastery check on all 28 patterns. 4 mocks (Easy-Medium-Medium-Medium-Hard).
Volume: ~140 problems, 9 labs.
Month 3 — Graphs + DP Deep (Weeks 9–12)
Cover: Phase 4 fully, Phase 5 fully (except convex hull / Knuth optimization, those are Month 6).
- Week 9: Phase 4 fundamentals (BFS variants, DFS, Dijkstra, Bellman-Ford, Floyd-Warshall, topo). Solve 30 graph problems. 2 graph labs.
- Week 10: Phase 4 advanced (SCCs, bridges/articulation, MST, bipartite, max flow basics, graph modeling). Solve 25. 3 graph labs.
- Week 11: Phase 5 categories: 1D, 2D, knapsack, LIS, edit distance, palindrome, string DP. Solve 25. 3 DP labs (full brute→memo→tab→space progression).
- Week 12: Phase 5 categories: tree DP, interval DP, bitmask DP, digit DP (intro), DP on DAGs, game DP. Solve 25. 3 DP labs.
End-of-month: all of Phase 4 + Phase 5 mastery checks. 4 mocks (Medium-Medium-Medium-Hard mix).
Volume: ~110 problems, 11 labs.
Month 4 — Greedy, Advanced DS, Practical Engineering (Weeks 13–16)
- Week 13: Phase 6 fully (greedy choice, exchange arg, cut property, invariants, monovariants, amortized analysis). 6 greedy labs (with proofs). 20 greedy problems.
- Week 14: Phase 3 (segment tree, Fenwick tree, sparse table, KMP, Z, rolling hash, trie variants, bit manipulation, bitmask DP, meet-in-the-middle). 20 problems. 3 advanced DS labs.
- Week 15: Phase 8 first half (LRU, LFU, rate limiter, task scheduler, thread pool, job queue, autocomplete, log parser, file dedup). 9 labs with full follow-up answers.
- Week 16: Phase 8 second half (consistent hashing, message dispatcher, pubsub, timer wheel, KV store, retry/backoff, circuit breaker, metrics, web crawler, in-memory FS). 10 labs.
End-of-month: Phase 3 + Phase 6 + Phase 8 (most of it) complete. 4 mocks including 1 Big Tech phone screen.
Volume: ~80 problems, 28 labs.
Month 5 — Hard Problems + Concurrency + Senior-Level Skills (Weeks 17–20)
- Week 17: Phase 8 final 4 labs + Phase 10 (testing/debugging concept docs). 5 testing/debugging labs. 15 problems.
- Week 18: Concurrency deep dive — re-read Phase 9 concurrency sections, solve 5 concurrency-flavored problems, do mock-11 twice. 15 problems.
- Week 19: Hard problem week — 25 LeetCode Hards across all patterns. 1 mock per day (5 mocks).
- Week 20: Phase 7 selectively (modular arithmetic, sieve, binary exponentiation, combinatorics, sweep line, coordinate compression — skip ICPC-only topics). 20 problems including 8 from Codeforces Div 3. 1 mock.
End-of-month: all of Phase 8, Phase 10, parts of Phase 7. 8 mocks total.
Volume: ~100 problems including ~25 hards.
Month 6 — Polish, Mock Marathon, Production Awareness (Weeks 21–24)
- Week 21: Mock-heavy week. 5 mocks (mix mock-05, 06, 07, 09, 11). Failure analysis on each. 15 problems focused on top failure category.
- Week 22: Phase 12 selective topics (only those relevant to your role) — for backend/platform: max flow modeling, advanced combinatorics inclusion-exclusion. For systems: nothing additional, focus on Phase 8 polish. 20 problems.
- Week 23: Re-solve marathon — re-solve all Tier 5 and Tier 6 problems. Verify READINESS_CHECKLIST.md honestly. 3 mocks.
- Week 24: Light week. 2 mocks. 10 problems. Rest. Final readiness check.
End-of-program: READINESS_CHECKLIST.md fully passed.
Volume: ~50 problems, 13 mocks across the month.
Aggregate Volume
| Month | New Problems | Labs | Mocks |
|---|---|---|---|
| 1 | 115 | 10 | 1 |
| 2 | 140 | 9 | 4 |
| 3 | 110 | 11 | 4 |
| 4 | 80 | 28 | 4 |
| 5 | 100 | 5 | 8 |
| 6 | 50 | 0 | 13 |
| Total | ~595 | ~63 | ~34 |
Review / Spaced Repetition
Full 6-tier schedule from SPACED_REPETITION.md:
- Tier 1: same day
- Tier 2: 2 days
- Tier 3: 1 week
- Tier 4: 2 weeks
- Tier 5: 1 month
- Tier 6: 3 months
By Month 6 you should have ~50–80 Tier 6 graduates.
Mock Schedule
Required mocks across the program (see phase-11-mock-interviews/):
| Mock | When | Pass Threshold |
|---|---|---|
| mock-02 (Easy) | end of Month 1 | 7/10 |
| mock-03 (Medium) ×3 | Month 2 | 6/10 → 7/10 |
| mock-04 (Hard) ×2 | Month 3 | 6/10 |
| mock-05 (Big Tech phone) ×3 | Months 4–6 | 7/10 |
| mock-06 (Big Tech onsite) ×3 | Months 5–6 | 7/10 |
| mock-07 (senior) ×2 | Months 5–6 | 6/10 |
| mock-09 (runtime) ×2 | Months 5–6 | 7/10 |
| mock-11 (concurrency) ×2 | Month 5 | 6/10 |
| mock-10 (system-heavy) ×2 | Month 6 | 6/10 |
Revision Plan
Weekly: Friday evening — skim review log, identify the week’s failure pattern. Monthly: Last weekend — aggregate failures, identify top 3 categories, dedicate next month’s Sunday drilling to category #1. Bi-monthly: End of months 2, 4, 6 — do a “blind mock” with a problem you’ve never seen, no warmup. Score honestly.
What This Track Buys You
- ~600 deeply-owned problems
- All 28 patterns recognizable in <2 minutes
- ~35 production-style labs with full follow-up answers
- Strong concurrency + runtime depth in your primary language
- Genuine readiness for FAANG senior-level coding interviews
- 30+ mock interviews of practice — pressure tolerance is real
What It Does Not Buy You
- Codeforces Div 1 / AtCoder AGC level (you’d need Phase 7 + 12 fully)
- Quant/HFT-level math depth (math heavy, beyond Month 5 scope)
- Compiler/runtime team specialty (you’d need Phase 9 fully across multiple languages)