12-Month Elite Track

Audience: Top-tier targets. Senior/staff/principal practical, FAANG L6+, Jane Street / Citadel / Two Sigma, distributed systems specialty teams, compiler/runtime teams, or competitive programmers building toward Codeforces 2100+.

Commitment: 15–20 hours/week sustained for 12 months. Not a sprint.

This track will get you to:

• Phase 7 + Phase 12 substantial depth
• Codeforces Div 2 reliable, Div 1 attempt-capable
• Multi-language runtime fluency in primary + 1 secondary
• Production-system thinking comparable to a working senior/staff engineer
• The specific gap between “Big Tech ready” and “elite-tier ready”

Annual Phase Map

Daily Cadence

• Weekday: 2 hours
• Saturday: 5 hours (mock + problems + labs)
• Sunday: 3 hours (review + drilling)
• Total: 17–18 hours/week

You will scale up in Months 8–11 to 22 hours/week temporarily.

Monthly Detail

Month 1 — Phase 0 + Phase 1

Identical to Month 1 of 6-Month Serious, but with extra depth on runtime docs (read all 10) and an additional 30 Easy problems for fluency.

Volume: 130 problems, 12 labs, 1 mock.

Month 2 — Phase 2 (Patterns)

• All 28 pattern docs read in detail
• 8 problems per pattern (vs 5 in Serious track)
• Every pattern: write a personal template after solving the 8 problems
• 5 mocks across the month

Volume: 224 problems, 9 labs, 5 mocks.

Mastery check: Can derive each pattern’s template from memory in <5 minutes.

Month 3 — Phase 4 (Graphs)

• All 21 graph algorithms with implementation
• All 9 product-style labs
• 60 graph problems (mix of LeetCode + Codeforces Div 3 graph problems)
• 4 mocks

Volume: 60 problems, 9 labs, 4 mocks.

Mastery check: Can implement BFS / DFS / Dijkstra / Bellman-Ford / Floyd-Warshall / Kruskal / Prim / Kosaraju / Tarjan from scratch error-free in <12 minutes each.

Month 4 — Phase 5 (Dynamic Programming)

• All 22 DP concept + category docs
• All 10 DP labs with full progression (brute → memo → tab → space)
• 80 DP problems
• Every problem you solve: explicitly state recurrence + base case + evaluation order before coding
• 4 mocks (DP-heavy)

Volume: 80 problems, 10 labs, 4 mocks.

Mastery check: Can derive state + transition for unseen DP problems in <8 minutes.

Month 5 — Phase 3 (Advanced DS) + Phase 6 (Greedy/Proofs)

• All 24 advanced DS docs
• All 9 advanced DS labs
• All 7 greedy concept docs + all 6 labs (with proofs)
• 50 problems mixing advanced DS and greedy
• 4 mocks

Volume: 50 problems, 15 labs, 4 mocks.

Mastery check: Can implement segment tree (with lazy propagation), Fenwick tree, KMP, rolling hash, trie, treap from scratch.

Month 6 — Phase 8 (Practical Engineering) + Phase 10 (Testing/Debugging)

• All 23 practical engineering labs
• Every lab includes: working implementation + unit tests + smoke tests + concurrency tests where relevant + answers to all 13 standard follow-ups
• All 13 testing/debugging concept docs + all 5 labs
• Property-based test 5 implementations
• 30 problems
• 5 mocks (mix mock-08 staff practical, mock-10 system-heavy, mock-11 concurrency)

Volume: 30 problems, 28 labs, 5 mocks.

Mastery check: Can build any of (LRU, rate limiter, autocomplete, KV store, thread pool) from scratch in 45 minutes with tests.

Month 7 — Phase 9 (Language & Runtime)

• Primary language: read entire track end to end. Take written notes. Solve 5 problems per major topic targeting the gotchas.
• Secondary language: read 50%+ of the track. Solve 20 problems in this language to build fluency.
• 30 problems total in primary language (focused on runtime gotchas: overflow, recursion limits, hash adversarial, GC pressure, concurrency)
• 4 mocks including 2 mock-09 (runtime/language deep dives)

Volume: 50 problems, 0 labs (concept-heavy month), 4 mocks.

Mastery check: Can fluently explain stack vs heap, GC behavior, hashmap internals, concurrency model for both languages.

Month 8 — Phase 7 First Half

Competitive programming acceleration starts here. Move to Codeforces full-time for problem solving (LeetCode for review only).

• Topics: fast I/O, modular arithmetic, GCD/LCM, sieve, prime factorization, modular inverse, combinatorics, binary exponentiation, matrix exponentiation, geometry basics, coordinate compression
• Codeforces Div 3 → solve 6 contests (virtual or real). Goal: solve 4–5 problems per Div 3.
• AtCoder Beginner Contest: solve 4 contests. Goal: solve 5 of A–F.
• 1 mock per week (varied — competitive-flavored mock-13)

Volume: ~80 problems (Codeforces + AtCoder), 6 labs, 4 mocks.

Mastery check: Solve Codeforces 1500–1700 rated problems consistently within contest time.

Month 9 — Phase 7 Second Half

• Topics: sweep line, offline queries, Mo’s algorithm, parallel binary search (overview), randomized stress testing, interactive problems, game theory (Nim, Sprague-Grundy)
• Codeforces Div 2 → 6 virtual contests. Goal: solve A–C reliably, attempt D.
• AtCoder Regular Contest → 3 contests, attempt A–C.
• Implement a stress-testing harness for 5 problems
• 4 mocks including mock-13 (competitive hard) twice

Volume: ~70 problems, 4 mocks.

Mastery check: Codeforces Div 2 ABC reliable. D attempted and sometimes solved.

Month 10 — Phase 12 (Selective)

Pick topics by role:

Backend/platform:

• Max flow modeling, min-cost max-flow overview
• Advanced combinatorics + inclusion-exclusion
• Randomized algorithms

Distributed systems:

• Persistent data structures
• Consistent hashing deep
• Lockless / wait-free data structures (research)

Compiler/runtime:

• Suffix automaton
• Heavy-light decomposition
• Constraint solving / SAT-like reasoning

Quant/HFT:

• FFT/NTT
• Computational geometry
• Probability DP + expected value
• Game theory deep

Pure competitive:

• HLD, centroid decomposition, segment tree beats, FFT/NTT, suffix automaton

Pick 5–7 topics. Read deeply. Implement reference code. 3 labs from Phase 12.

Volume: 30 problems (very hard / CP-hard), 3+ labs, 4 mocks.

Mastery check: can articulate selected topics + implementation risks; have working reference implementations.

Month 11 — Mock Marathon

This is the highest-pressure month.

• 4 mocks per week (16 total)
• Mix all 14 mock types — including grandmaster final boss (mock-14) at least twice
• Failure analysis on every mock
• Every Sunday: aggregate failure pattern, drill the top category Mon–Wed
• 60 problems (almost entirely focused on weak areas surfaced by mocks)

Volume: 60 problems, 16 mocks.

Month 12 — Polish, Re-solve, Final Readiness

• Week 49: Re-solve all Tier 5 + Tier 6 problems. Aim for 80+ Tier 6 graduates.
• Week 50: 4 cold blind mocks (no warmup, varied difficulty). Score brutally honestly.
• Week 51: Address any remaining gaps. Light schedule (10 hours total).
• Week 52: Rest, sleep, exercise. 1 final readiness check via READINESS_CHECKLIST.md. Interview confidently.

Volume: 30 re-solves, 4 mocks, 1 readiness audit.

Aggregate Volume

Contest Practice (unique to this track)

By end of Month 9, you should have completed:

• 12+ Codeforces Div 3/4 contests
• 6+ Codeforces Div 2 contests
• 6+ AtCoder Beginner Contests
• 3+ AtCoder Regular Contests

Goal Codeforces rating after 12 months: 1700–1900 (Expert range).

What Distinguishes This Track

vs 6-month Serious:

• ~1.5× the problems
• 2× the labs (especially in Phase 7 / 12)
• 2× the mocks (mostly in Months 8–11)
• Real contest experience (vs 0 in 6-month track)
• Multi-language runtime depth
• Phase 12 awareness (selective implementation)

vs Competitive-only training:

• This track does NOT skip practical engineering, system thinking, communication, or runtime depth
• A candidate trained purely on competitive programming often struggles in mock-08 (staff practical) and mock-10 (system-heavy) — this track does not have that gap

Honest Limitations

Even after this track:

• You will not reach grandmaster (CF 2400+) — that requires sustained contest practice for years
• You will not be a domain expert in a specific area (e.g., compilers, distributed consensus) — that requires actual work on those systems
• 12 months of part-time prep cannot replicate 5 years of full-time engineering experience

What it can do is take you from intermediate to elite-candidate level — enough to interview confidently for very hard roles and have a fighting chance.