TL;DR: The NeetCode roadmap is a free dependency tree that orders the NeetCode 150 into 18 topics. It starts at Arrays and Hashing and ends at 2-D Dynamic Programming. The order is good, and you should follow it top to bottom. What the tree does not do is teach recognition: it tells you what to solve, not how to spot which technique a new question needs. This walkthrough covers the whole tree, the time each stage takes, and the named patterns that hide inside its broad topic boxes.
The roadmap lives at neetcode.io and it is the best free study order in interview prep. A dependency tree means each topic box points to the topics that need it first. Arrays feed Two Pointers. Two Pointers feed Sliding Window. Trees feed Tries and Backtracking. You never meet a problem that needs a tool you have not seen.
This article walks the tree stage by stage, then covers the part the tree cannot show you. If your question is whether the 150 problems are enough, that is a separate answer: Is NeetCode 150 Enough for FAANG?
The 18 topics, in walking order
The tree branches, so several orders are valid. This is the order that keeps every topic after its prerequisites.
Stage 1: the foundation. Arrays & Hashing, then Two Pointers, then Stack. These three teach the moves every later topic reuses: index arithmetic, hash-map counting, and last-in-first-out bookkeeping. Do not rush them. Weak hashing skills show up later as "hard" tree and graph problems that are actually easy.
Stage 2: the array toolkit. Sliding Window, Binary Search, Linked List. Sliding Window is Two Pointers with a rule attached, so it comes quickly after stage 1. Binary Search here means more than finding a value: the important half is searching over answers.
Stage 3: trees. Trees, then Tries, then Heap / Priority Queue. Trees are the center of the tree, literally and in interview frequency. Recursion becomes automatic here or it never does.
Stage 4: the hard middle. Backtracking, Graphs, 1-D Dynamic Programming. These three are where most people slow down, because each one introduces a new kind of thinking rather than a new data structure. Give this stage double the time of any other.
Stage 5: the advanced topics. Advanced Graphs, 2-D Dynamic Programming, Greedy, Intervals, Math & Geometry, Bit Manipulation. These finish the 150. Skip Math & Geometry and Bit Manipulation on a tight schedule; they are the rarest topics in real loops.
A realistic pace is one stage per week at two hours a day, so the full tree is five to seven weeks. If you have less time than that, do not walk faster. Walk a shorter list instead, and pick it with Blind 75 vs NeetCode 150 vs Grokking 75.
What the roadmap does well
The order is correct. Prerequisites really do come first. That alone puts it ahead of solving random problems, which is how most people waste their first month. We measured that waste in How Many LeetCode Problems Do You Actually Need?
The videos are excellent. Every problem on the tree has a free video walkthrough, and Navdeep Singh explains as clearly as anyone in this space.
It is honest about size. The tree is 150 problems, not 500. A finishable list beats a complete one.
What the roadmap leaves out
The tree names topics, not patterns. A topic is a data structure; a pattern is a reusable solution shape with a tell you can recognize in the question. The tree's 18 boxes hide many named patterns inside them. Monotonic Stack is filed under Stack. Top K Elements is filed under Heap. Topological Sort and Union-Find are filed under Graphs and Advanced Graphs. K-way Merge and Cyclic Sort have no box at all. You meet these patterns by solving their problems. But the tree never names them, and it never teaches the words in a question that point to each one. The full list of 42 named patterns, with the tell for each, is free in the pattern guide.
It orders problems, it does not teach before them. On the roadmap you learn by attempting a problem, failing, then watching the video. That works, and it is slow. A curriculum teaches the pattern first, then hands you problems ordered to stretch it one variation at a time. That inversion is the entire design of Grokking the Coding Interview. It teaches 42 patterns before their problems, in text you can skim again the week of your onsite.
Video does not review well. Two days before an interview you will not rewatch forty hours of walkthroughs. You will skim written summaries. Keep written notes per topic as you walk the tree, or use a written reference like the template page alongside it.
Roadmap or pattern course?
| NeetCode roadmap | Pattern-first course | |
|---|---|---|
| Cost | Free | $79 one-time |
| Unit of study | Topic (18 boxes) | Pattern (42, named) |
| Order | Dependency tree | Sequenced chapters |
| Teaching | Video after attempting | Text before attempting |
| Recognition training | Implicit | Explicit tell per pattern |
| Review before onsite | Rewatch videos | Skim summaries |
The two are not enemies. The strongest free setup is the roadmap plus the free pattern guide, so every problem you solve gets filed under a named pattern. The strongest paid setup is the course as the spine and NeetCode's videos as the second explanation when a written solution does not click. That pairing is covered honestly in Grokking vs NeetCode.
The takeaway
Follow the roadmap top to bottom: foundation, array toolkit, trees, the hard middle, then the advanced topics. Budget five to seven weeks and give Backtracking, Graphs, and 1-D DP double time. Then patch the gap the tree leaves: learn the named pattern behind each box. The interviewer's question arrives without a topic label. Recognizing the pattern from the wording is the actual tested skill.
Want the patterns taught first? Grokking the Coding Interview teaches all 42 patterns before their problems, with 300+ problems in six languages, for a one-time $79. On a deadline? Grokking 75 compresses it into six weeks.
FAQs
What order should I do the NeetCode roadmap in? Top to bottom: Arrays & Hashing, Two Pointers, Stack, then Sliding Window, Binary Search, Linked List. After that: Trees, Tries, Heap, then Backtracking, Graphs, 1-D DP, then the remaining advanced topics. Never start a box before finishing the boxes that point to it.
How long does the NeetCode roadmap take? About five to seven weeks at two hours a day, for all 150 problems. The middle stages, Backtracking through 1-D Dynamic Programming, take the longest. With less time available, switch to a 75-problem list rather than rushing the tree.
Is the NeetCode roadmap free? Yes. The tree, the 150 problem list, and every solution video are free. NeetCode Pro is a paid tier that adds courses and mock interviews, but the roadmap itself costs nothing.
Is the NeetCode roadmap enough to pass FAANG interviews? It can be, for a disciplined candidate who finishes it and adds mock practice. Its gap is recognition: it never teaches the tell that maps a new question to a technique. Pair it with a named-pattern reference, and read our full answer in Is NeetCode 150 Enough for FAANG?
Should I do NeetCode 150 or 250? Do the 150 with the roadmap. The 250 adds easier warm-up problems per topic, which helps true beginners, but the 150 already covers the tested space for most candidates. Volume past 150 pays less than mock interviews with the time you saved.