How much JavaScript 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 write working code.”
Start at the bottom of the ladder. Types, values, operators, functions — the words every other explanation assumes you already know.
- You have written a few scripts
this, closures and hoisting still feel like magic- You want the foundation, in order, once
“I understand why it works.”
You know the syntax. Now learn the machinery: closures you can explain, objects and prototypes, and the event loop that decides what runs when.
- Comfortable with functions, arrays and objects
- Promises work, until they don't
- You want to stop memorising and start reasoning
“I can reason about the engine and the ecosystem.”
Prototypes, microtasks, modules, memory and how V8 actually stores your objects. The layers almost nobody can explain out loud.
- You can already explain closures and
this - You debug performance and memory, not just bugs
- You want the why under every behaviour
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.
Beginner8 / 8 sections written
The layer everybody skips — and it shows in interviews.
Eight types, one conversion table, and the equality check that never stops mattering.
Every operator here has an interview question hiding behind it.
A function is a value first, a block of code second.
The two shapes almost everything you build is made of.
The DOM is a live tree of objects — and JS can poke every branch of it.
Just enough to fetch something and not freeze the page doing it.
The beginner track's last stop — reading what the engine is trying to tell you.
✅ Checkpoint: you can build a to-do list app with localStorage and an API call, without copying a tutorial.
Intermediate9 / 9 sections written
Closures and this — the two ideas most interviews spend the most time on.
The rest of the object/array toolbox — past what B5 already covered.
class is real syntax now — but it's still prototypes underneath, every time.
Promises, done right — and the sequential-vs-parallel mistake almost everyone makes once.
Everything that turns files full of JS into one thing a browser can run.
Four unrelated toolboxes every real app ends up reaching for.
The Intermediate track's close-out — past what B8 already covered.
fetch answers one question at a time. This is what answers a stream of them.
localStorage was the whole story two chapters ago. Past a few MB, it stops being enough.
✅ Checkpoint: you can explain closures and the event loop to someone else, and debug an async race condition without guessing.
Advanced9 / 9 sections written
What V8 is actually doing while your code just runs.
Past promises: pausable functions, streams, and running real work concurrently.
Code that changes how ordinary-looking code behaves.
What happens once a number, a string, or a file gets big or exotic enough to need its own type.
Shapes that show up again and again once code has to scale past one file.
Making a page feel fast is a different skill than making code run fast.
The mistakes that turn into a real incident, not just a bug.
The close-out — how the tools around JS actually work, and where the language itself comes from.
Not optional at this level — and this whole site's own test suite is the example.
✅ Checkpoint: you can find a memory leak from a heap snapshot, explain why a function deoptimized, and defend an architectural choice with tradeoffs.
- DOM and events are the most commonly missing piece — for most jobs that's half the actual work. It sits beside the beginner objects/arrays chapter, not off at the end.
- Regex, dates and Intl are the "boring" topics that show up in every real codebase and every interview take-home.
- Security and testing aren't optional at the advanced tier — they're often what separates "senior" from "writes good code."