How much DSA in JS do you already have?
Be honest — nobody is watching. This only decides which chapters come first; every chapter stays open to you either way.
“I can solve easy problems reliably.”
Start with complexity analysis, then the toolkit every pattern is built from: arrays, hashing, two pointers, sliding window, binary search, stacks, linked lists and recursion.
- You know JavaScript's arrays, objects and functions comfortably
- You can solve some LeetCode Easy problems, slowly, by trial and error
- You want Big-O and the foundational patterns once, in order
“I can solve mediums and recognize the pattern fast.”
You have the toolkit. Now learn the structures and techniques that cover most real interview questions: trees, graphs, backtracking, DP, greedy and bit tricks.
- Comfortable with two pointers, sliding window and basic recursion
- You can solve LeetCode Mediums, but slower than you'd like in a live interview
- You want tree/graph/DP problems to stop feeling like a fresh puzzle every time
“I can solve hards and design the efficient answer.”
Advanced DP, union-find, the harder graph algorithms, tries and segment trees — plus the interview strategy that turns pattern knowledge into offers.
- You can already solve most Mediums within an interview window
- LeetCode Hards feel possible, not hopeless, but still take too long
- You want the deepest structures and a real interview strategy, not just more problems
Not sure? Start at Beginner — every path opens at the section people usually skip.
Full syllabus
Everything each level eventually covers — ticked sections are written, the rest are still on the desk.
Beginner10 / 10 sections written
The one skill every interviewer is silently scoring, whether they say so or not.
The two data structures every other pattern is built on top of.
The single most common way an O(n²) brute force becomes O(n).
One pass, two positions — how an O(n²) search collapses to O(n).
Stop re-scanning the same elements — slide the window instead.
Halving the search space is the single highest-leverage trick in DSA.
You'll rarely hand-write one, but you'll constantly need to reason about them.
Two rules for order, and half of interview problems secretly need one of them.
No index math, no shifting cost — the tradeoff array questions can't make.
Trees, backtracking, DP and divide-and-conquer are all recursion wearing a costume.
✅ Checkpoint: you can solve most LeetCode Easy problems in one pass, state the time/space complexity of your solution without guessing, and recognize which basic pattern a new problem wants.
Intermediate12 / 12 sections written
A linked list that's allowed to branch — and the three orders you can walk it in.
Construction, LCA, balance and serialization — the four questions traversal alone doesn't answer.
You don't need the whole thing sorted — you need the extreme value, fast, repeatedly.
A tree is a graph with no cycles and one root — now drop both restrictions.
Three questions that reuse the exact same BFS/DFS you just learned, with one twist each.
Try a choice, recurse, undo the choice — DFS over a tree of decisions instead of a graph.
Recursion, minus the part where you solve the same subproblem twice.
Same idea as 1D, one more dimension — a grid table instead of a row.
The best DP alternative — when the locally best choice happens to be globally best too.
Every interval question starts the same way: sort by start time. Then it's bookkeeping.
A small, fixed toolkit of tricks that turn up constantly once you recognize them.
A grid is an array of arrays — every trick here is index bookkeeping, done carefully.
✅ Checkpoint: you can solve most LeetCode Medium problems within a 30-45 minute interview window, and explain why you reached for that pattern before you've finished coding it.
Advanced12 / 12 sections written
Once you can design the state, every "impossible" DP is just a normal DP over a stranger index.
Twenty lines that answer "are these two connected?" in effectively constant time — forever.
BFS is shortest path when every edge costs 1 — here is what to do when they don't.
The cheapest wiring that reaches every node — greedy is provably optimal here, and there are exactly two ways to be greedy.
Store the string as a path, not a value — and every prefix question becomes a walk instead of a scan.
Prefix sums die the moment the array can change — these two structures buy back updates for a log factor.
Preprocess the pattern once, and you never have to look backward in the text again.
Throw away every element that can never win again — what survives is already sorted.
The interface is the spec — pick the data structure combo that meets the complexity contract before you write a line of code.
Same three lines as before — the advanced part is saying "no" earlier and storing state in bits.
Any problem phrased as "X must come before Y" is a DAG asking to be linearized.
The algorithm is half the score — the other half is everything you say before, during and after writing it.
✅ Checkpoint: you can solve most LeetCode Hard problems by recognizing which advanced structure or DP shape it wants, and run a full mock interview — thinking out loud, handling a hint, landing on a working solution.
- This curriculum is deliberately pattern-first, not problem-first — every chapter is "the shape of problem this solves," because that's what actually transfers to a problem you've never seen in an interview.
- Trees and graphs each get two chapters (structure, then the harder problems built on it) because that split is where most intermediate candidates plateau.
- Interview strategy is its own advanced chapter, not an afterthought — knowing the patterns and communicating your thinking clearly under pressure are different skills, and top offers depend on both.