| Where you are | What happens when you sit down to fix it |
|---|---|
| The material has faded | You still know what a heap is. Whether you'll think to use one on a problem that quietly needs it, under a clock, with someone watching — that's the part that slips. |
| The problem list has no end | Thousands of problems, ordered by difficulty rather than by what to learn first, so the plan becomes “solve more.” |
| Reading solutions only gets you so far | You'll follow the editorial fine. Coming back to a slightly different version of it two days later and building it yourself is a much shakier proposition, and that's closer to what an interview actually asks of you. |
| Nothing holds the schedule | You're consistent for a week or two. Then a deadline at work eats your evenings and the plan just dies somewhere in week three, without you ever really deciding to quit. |
None of that gets fixed by reading another explanation. What actually helps is kind of boring. Someone else decides the order, so you stop relitigating what to study every night, and there's a deadline you can't just move when it gets inconvenient. That is most of what a cohort is for.
Recognize the three shapes that turn an O(n²) scan of a sequence into one pass, and know which one a problem is asking for.
Write a binary search with the boundary correct on the first try, then use the same loop on a problem with no sorted array in sight.
Traversal as one recursive template, what a binary search tree buys you, and when a level-order sweep is the right answer instead. Graphs, next, are the same two traversals on a more general structure.
See the graph hiding in a grid or a list of dependencies, then run the same depth-first and breadth-first traversals on it and read an ordering off the result.
Enumerate candidates as a search tree, prune the branches that cannot work, and tell the difference between a problem that needs every answer and one that needs the best one.
Keep the K best without sorting everything, and handle interval problems, which almost always reduce to sorting once and then sweeping.
Dynamic programming is larger than one topic can cover, so this is an introduction. You get the state-and-transition method and enough worked recurrences to recognize the common families.
You finish having worked each pattern family a standard coding round draws on, and having practiced choosing between them on problems you have not seen.
About ninety minutes of live teaching, covering one pattern family and how to recognize the problems that call for it.
A short problem set on the current pattern, drawn from AlgoMonster, so you arrive at the next session having already tried it.
Everyone's on the same topic the same week, so when someone asks a question it's usually the one you were about to ask too.
Each session leaves time for questions about the material being taught.
It goes through the pattern list in order and then it's finished. When it's over it's over, and there's no membership left auto-renewing in the background.
We've spent years chasing one question, more or less: what is the quickest reliable way to get this material back for an interview. The usual answer is grind more problems, which for most people just eats months. AlgoMonster came out of the opposite bet — that there's a fairly small set of patterns interviews keep reusing, and the thing actually worth practicing is looking at a new problem and knowing which one it is. That last part is where most prep falls down.
The curriculum on AlgoMonster is the one taught here — by the people who built it, live rather than as an article.
It has changed a lot since then. Real interview questions kept poking holes in it, a few very strong competitive programmers helped patch those, and the whole thing stays pointed at what interviews test instead of what a university algorithms course wanders through. The bootcamp is that, taught live and in order, with room in each session to ask about whatever is on screen.
For a lot of people this is the kind of thing that just sits on a to-do list for a year. A real date on the calendar does more than you'd think.
A hands-on intensive on working with coding agents: context, tooling, self-correcting loops, and shipping a feature with agents in parallel.
See the courseA repeatable framework for system design rounds: requirements, data at scale, capacity estimation, trade-offs, and how interviewers score you.