Roadmap
Eight weeks, about eight hours a week. Then what to do when the interview is two days away.
Some honesty first. The reading in this course is 6.8 hours; becoming good enough to pass a big-tech loop takes closer to two or three months. The ratio that decides the outcome is roughly one part reading to four parts solving problems unaided. This plan is built around that ratio, which is why every week is mostly problems.
Treat the week numbers as a sequence rather than a schedule. If week 7 takes you three weeks, that is normal and it is not a sign you are behind — dynamic programming takes most people longer than everything before it combined. What matters is the checklist at the end of each week, not the date.
How a study session should go
Ninety minutes, roughly split like this. The proportions matter more than the total.
- Ten minutes reviewing. Reproduce one template from memory. Not reading it — writing it.
- Twenty-five minutes reading the current lesson, running every panel. When output surprises you, change a line and run it again.
- Fifty minutes on problems. Two or three, out loud, with a timer. Twenty minutes of genuine effort before you open a hint.
- Five minutes writing your notes line for each problem you did.
Two things to avoid, because both feel productive and are not. Reading solutions to problems you have not attempted teaches you to recognise answers rather than produce them. And doing problems silently trains the opposite of the skill being assessed — a silent candidate with a working answer scores below a talking candidate with a partial one.
The eight weeks
Cost, arrays, strings, hashing
Read
Lessons 01 – 04
Solve
Arrays and hashing (9)
Budget
6–8 hours
Nothing here is difficult, and skipping it is the single most common mistake. Lesson 01 is what lets you answer “what is the complexity” without hedging, and lesson 04 is the pattern you will use more than any other. Spend the time.
Move on when you can
- Look at any loop and say its time and space complexity out loud, without pausing.
- Explain why
arr.shift()in a loop isO(n²). - Solve Two Sum, Group Anagrams and Contains Duplicate from an empty editor, in under ten minutes each.
Two pointers, sliding window, prefix sums
Read
Lessons 05 – 07
Solve
Two pointers (7), sliding window (6), prefix sums (5)
Budget
7–9 hours
The first real step up, and the highest return on effort in the whole course. These three patterns turn nested loops into single passes, and between them they cover a large slice of every interview bank.
Move on when you can
- State the difference between a longest-valid and a shortest-valid window, and where each records its answer.
- Explain why a sliding window fails on an array containing negative numbers.
- Write Longest Substring Without Repeating Characters from memory.
Linked lists, stacks, queues
Read
Lessons 08 – 10
Solve
Linked lists (8), stacks (6)
Budget
7–9 hours
Linked lists are pure pointer discipline — draw them on paper, every time. Monotonic stacks are the part of this week that will feel like a trick until it suddenly does not, and then it will feel obvious.
Move on when you can
- Reverse a linked list, find its middle, and detect a cycle, without looking anything up.
- Explain why a monotonic stack is
O(n)despite the innerwhileloop. - Say when you need a dummy head node and why.
Recursion, binary search, sorting
Read
Lessons 11 – 13
Solve
Binary search (6)
Budget
7–9 hours
Binary search deserves more of this week than its length suggests. The array version is easy; searching the answer space is what separates candidates, and it is the single most under-practised technique on this list.
Move on when you can
- Write binary search with no off-by-one error, on the first attempt, twice in a row.
- Recognise a “minimise the maximum” problem and set up the feasibility check.
- Explain why quicksort is
O(n²)in the worst case but preferred in practice.
Trees and binary search trees
Read
Lessons 14 – 15
Solve
Trees and BSTs (10)
Budget
7–9 hours
Almost every tree problem is one recursive function, and one shape recurs constantly: return a value to the parent while accumulating an answer outside the recursion. Once you see height, diameter and balance as the same function, this week collapses.
Move on when you can
- Traverse a tree in all four orders, recursively and iteratively.
- Explain why checking
node.left.val < node.valdoes not validate a BST. - Solve Diameter of Binary Tree and Validate BST from scratch.
Heaps and graphs
Read
Lessons 16 – 18
Solve
Heaps (5), graphs and grids (9)
Budget
8–10 hours
The heaviest week. Write the heap from memory until it is automatic, because JavaScript does not give you one. Then BFS and DFS, and be strict with yourself about which one answers which question.
Move on when you can
- Write a binary heap from an empty editor in under ten minutes.
- Explain why BFS finds shortest paths and DFS does not.
- Write union-find with path compression, and use it to detect a cycle.
- Recognise a topological sort from the words “prerequisites” or “build order”.
Backtracking and dynamic programming
Read
Lessons 19 – 20
Solve
Backtracking (6), dynamic programming (11)
Budget
9–12 hours
The week most people find hardest, and the one that decides senior outcomes. Do not memorise DP solutions. Practise the method: honest recursion, then a cache, then a table. Doing it in that order means you always have something working.
Move on when you can
- Produce the backtracking skeleton from memory and adapt it to subsets, permutations and combinations.
- Take any recursive solution and memoise it without changing its logic.
- Convert a memoised solution to a bottom-up table, then reduce its space.
- Say whether a problem wants a list (backtracking) or a count or best (DP).
Greedy, intervals, grids, bits, and mixed practice
Read
Lessons 21 – 24
Solve
Greedy and intervals (8), then mixed review
Budget
8–10 hours
The remaining patterns are quick. Spend most of this week on mixed practice: random problems with the pattern label hidden. That is the only way to test recognition, and recognition is what the interview actually measures.
Move on when you can
- Name the pattern for an unseen problem within a minute, most of the time.
- Justify a greedy choice with an exchange argument, or reject greedy with a counterexample.
- Know whether to sort intervals by start or by end, and why.
- Solve two random medium problems in one sitting, talking out loud throughout.
Weeks 9 and beyond: volume and randomness
Once the checklists are clear, the course has given you what it can and the remaining work is repetition under realistic conditions. Three things, in order of value.
- Random mediums against a clock. Thirty-five minutes, pattern label hidden, talking out loud the whole time. This is the closest thing to the real event.
- Mock interviews with another person. Uncomfortable, and worth more than ten solo problems. The discomfort is the training — you are learning to think while being watched, which is the actual skill.
- Revisit your notes list, not the problems. Re-solve the ones where you wrote “got the pattern, botched the boundary”. Those are cheap points you are currently losing.
Aim for breadth over depth here. Two hundred problems spread across every pattern beats fifty done four times each, because recognition comes from variety.
The last 48 hours
Nothing you learn now will land. The goal for these two days is to arrive rested with your fundamentals warm, so the plan is deliberately light.
Two days before
- Reproduce all of the templates from an empty editor. Binary search, BFS, the heap, union-find, the backtracking skeleton. Fix whichever one you fumbled.
- Reread the patterns lookup table once, slowly. Just the signals, not the code.
- Do three easy problems you have already solved. The point is confidence and warm hands, not learning.
- Reread your own notes list. It is the most targeted revision material you have.
The day before
- One or two mediums in the morning, out loud, timed. Then stop.
- Skim the constraints table — the one mapping the size of
nto the intended complexity. It is the most useful thing to have fresh. - Prepare the boring logistics: link, editor, water, a notebook, a quiet room. Test your microphone.
- Write your first four sentences for the start of the interview (below). Having them ready removes the worst thirty seconds.
- Stop by early evening. No new material. Sleep is worth more than another problem, and this is not a claim people take seriously enough.
The morning of
- Write out binary search once. That is your whole warm-up.
- Reread your four opening sentences.
- Do not attempt a new problem. Getting stuck an hour beforehand costs you real composure for no gain.
If you have less than eight weeks
Cut, do not rush. Rushing produces a shallow familiarity with everything that collapses under pressure; cutting leaves you genuinely solid on less.
- Four weeks. Lessons 01–08, 12, 14, 16–17, 20. Patterns: hashing, two pointers, sliding window, binary search, trees, BFS, and the DP method. Skip bit manipulation, sorting internals, and the harder graph algorithms entirely.
- Two weeks. Lessons 01–06, 12, 14, 17. Do the easy and medium problems in those groups only. You will not be ready for a hard question, and that is an acceptable trade for being solid on the rest.
- One week. Read the patterns page, learn three templates cold — binary search, BFS, the heap — and do twenty easy problems. Aim to be unshakeable on the fundamentals rather than thin across everything.
In every one of those, keep the notes habit. It is the cheapest thing on this page and it is the reason the same mistake stops recurring.