This is the plan the platform builds for someone starting from close to zero with about six hours a week. It is not the fastest possible path — it is the one that most people actually finish, which is a different optimisation.
Month 1 — Foundations
Arrays & Strings, Two Pointers, Hashing. Roughly 85 problems, and they are the easiest 85 in the catalogue. That is deliberate: the aim this month is not difficulty, it is fluency and the habit of solving something most days.
- →Target: 20 problems a week, mostly easy.
- →By the end: prefix sums, frequency maps and converging pointers should be automatic.
- →Checkpoint: three track quizzes passed.
Expect this month to feel encouraging and slightly too easy. Do not skip it. Every later track assumes these are reflexes, and the people who struggle in month three are almost always the people who skimmed month one.
Month 2 — Recursion and windows
Recursion & Backtracking, Sliding Window. This is the first real step up, and the first place people stall — not because the problems are hard but because recursion requires a different mental model, and there is no way to get it except by tracing stacks until it clicks.
Most people who abandon a plan do it in week 6 or 7, on recursion. If it feels bad, that is the expected experience, not evidence you cannot do it. Trace three call stacks on paper and it changes.
Month 3 — Trees
Trees & Traversal, then Heaps. Trees is the largest single track — 38 problems — and it is where the curriculum starts paying off, because once you see that most tree problems are post-order with a return value, a lot of them collapse into one shape.
- →Target: 12–15 problems a week; they are longer now.
- →By the end: any traversal from memory, iteratively or recursively.
- →Start entering the weekly contest, even if you solve one problem.
Month 4 — Graphs
Graphs, then Shortest Paths. 67 problems and the densest month in the plan. Everything here is built on trees and heaps, which is exactly why it comes fourth and not first.
Budget more time than the estimate suggests. Graph problems have more implementation surface — representation, visited sets, edge cases about disconnected components — and the debugging takes longer even when the idea is right.
Month 5 — Dynamic programming and interview shape
Dynamic Programming is 52 problems and the hardest track. Do not attempt to finish it in a month. Do the first twenty-five, which cover the common recurrences, and start the interview simulator in parallel.
DP is the second place people stop, usually by concluding they are not good at it. Almost nobody is good at DP early. The recurrences are memorisable and the intuition follows the memorisation, not the other way round.
What five months does not buy you
Advanced Structures, most of Greedy, and the back half of DP will still be open. That is fine. The set covered — arrays, pointers, hashing, recursion, windows, trees, heaps, graphs, shortest paths and core DP — is the overwhelming majority of what technical screens actually ask.
If you have less time
- →Two hours a week — the same order, about a year. Do not compress by skipping; compress by extending.
- →Twelve hours a week — roughly ten weeks, and the limiting factor becomes retention rather than volume. Add reviews, not more new problems.
- →Interview in three weeks — this plan is the wrong tool. Do the interview track and drill the patterns you already half-know.
The one rule
Do not start a track whose prerequisites are unfinished. The plan is not a suggestion about pace, it is a claim about dependencies — and the reason most self-directed attempts fail is that dynamic programming is genuinely impossible until recursion is genuinely easy.
Reading about a pattern is not the same as producing it under time pressure. The problems that drill this are in the curriculum, in order.