Roadmap

337 lessons, 6 phases, one order. Each module unlocks nothing — you can start anywhere — but this is the sequence that needs the least backtracking.

The path starts here

Big-O

Foundations

Cost, then the one structure everything else is built on. Nothing here is optional.

0 / 48 lessons

Big-O
You are here
Read growth curves at a glance instead of memorising a table.
5 lessons · 22 min0 / 5
Start here
Arrays
Pointers, windows and in-place tricks, drawn out step by step.
14 lessons · 69 min0 / 14
Start here
Strings
Characters in a row — palindromes, windows, and the hashing that finds a needle fast.
11 lessons · 54 min0 / 11
Start here
Searching
Watch a search space collapse until only the answer is left.
8 lessons · 42 min0 / 8
Start here
Sorting
See why the clever sorts beat the obvious ones.
10 lessons · 50 min0 / 10
Start here

Ten shapes for holding data, and the trade each one makes to be fast at something.

0 / 81 lessons

Linked Lists
Follow the pointers — and learn every trick they hide.
10 lessons · 51 min0 / 10
Start here
Stacks & Queues
Two humble rules, LIFO and FIFO, doing surprisingly heavy lifting.
9 lessons · 47 min0 / 9
Start here
Hash Tables
Trade a bit of memory for answers in constant time.
8 lessons · 40 min0 / 8
Start here
Trees & BST
Hierarchies, ordered searches, and the paths between nodes.
14 lessons · 75 min0 / 14
Start here
Tries
A tree of prefixes: autocomplete, word search and spell-check in one shape.
4 lessons · 20 min0 / 4
Start here
Heaps
Keep the most important thing on top — without sorting the rest.
7 lessons · 41 min0 / 7
Start here
Two Heaps & K-Way Merge
Two heaps that lean on each other, and one that merges k sorted streams.
4 lessons · 25 min0 / 4
Start here
Graphs
Nodes, edges, and the searches that ripple across them.
16 lessons · 91 min0 / 16
Start here
Matrix & Grid
Rows, columns and neighbours — the grid problems interviews keep drawing.
5 lessons · 23 min0 / 5
Start here
Union-Find
Merge groups in near-constant time, then ask who belongs together.
4 lessons · 20 min0 / 4
Start here

Recursion, backtracking and greedy choices, then recursion with a memo — plus the sweep-line, bit and number tricks that are pure technique.

0 / 52 lessons

Recursion
Watch the call stack grow, shrink, and finally make sense.
8 lessons · 45 min0 / 8
Start here
Backtracking
Try a choice, go deeper, undo it — and prune the branches that cannot win.
5 lessons · 27 min0 / 5
Start here
Greedy
Take the best local move and see exactly when that is enough.
5 lessons · 27 min0 / 5
Start here
Intervals
Sort by start, sweep once — merges, overlaps and meeting rooms fall out.
4 lessons · 19 min0 / 4
Start here
Bit Manipulation
Flip, mask and shift — the tricks that turn a loop into one instruction.
5 lessons · 22 min0 / 5
Start here
Math & Number Theory
Modular arithmetic, primes and fast powers, drawn so the shortcuts make sense.
5 lessons · 23 min0 / 5
Start here
Dynamic Programming
Solve every subproblem once, then let the table do the work.
20 lessons · 117 min0 / 20
Start here

What happens once one machine is not enough — and once one thread is not either. Then the same ideas as AWS services and as a Kubernetes cluster.

0 / 97 lessons

System Design
Scale, cache, shard — and know what each choice costs you.
17 lessons · 93 min0 / 17
Start here
System Design Cases
Design a URL shortener, a chat app, a feed — the interview round, end to end.
20 lessons · 135 min0 / 20
Start here
AWS for Interviews
IAM, S3, queues, VPCs and caches — the AWS round, drawn as requests moving through boxes.
18 lessons · 119 min0 / 18
Start here
Docker & Kubernetes for Interviews
Images, Pods, Services and rollouts — the container round, drawn as replicas moving through a cluster.
12 lessons · 80 min0 / 12
Start here
Concurrency
Threads, locks and races — watch the interleavings that bite.
15 lessons · 71 min0 / 15
Start here
SQL
Queries you can watch run — joins, groups, indexes, transactions.
15 lessons · 80 min0 / 15
Start here

The two rounds that are not about algorithms: object design, and telling a true story well.

0 / 27 lessons

Low-Level Design
Objects, interfaces and patterns that survive the follow-up question.
15 lessons · 80 min0 / 15
Start here
Behavioral
Tell true stories that carry signal — and skip the traps.
12 lessons · 57 min0 / 12
Start here

Embeddings, retrieval, evaluation, agents — the round that did not exist five years ago.

0 / 32 lessons

AI & ML
From embeddings to agents — see how modern AI actually works.
32 lessons · 157 min0 / 32
Start here