Ninety courses. Six benches.

Values, types, and control flow, written as small scripts that change a page. You finish able to read a tutorial without skipping the parts that look like noise.

• Run JavaScript in the browser and from a file
• Explain a value, a type, and a variable
• Read a short script and predict what it does

Scope, parameters, and return values, practiced until you can point at a variable and say what it holds. Closures get a proper course later; this is the ground they stand on.

• Predict what a name refers to at any line
• Write a function with a clear input and output
• Find a variable that leaked out of its block

Before this: JavaScript, in the Browser

Objects, arrays, destructuring, and the methods that replace most loops. You will reshape a tangled script into something you can read aloud.

• Choose between an array, an object, and a Map
• Replace most loops with map, filter, and reduce
• Pull nested values out without a long chain

Before this: Values, Scope, and Functions

A small interactive page and no dependencies. You will see the work a framework is doing for you, which makes the framework less mysterious later.

• Build an interactive page with no framework
• Create and update nodes without innerHTML soup
• Explain what a framework saves you from doing by hand

Before this: Objects, Arrays, and Methods

Bubbling, the event target, and one listener that serves a whole list. You will stop leaking listeners as a list grows.

• Use one listener for a list that changes
• Tell target from currentTarget
• Remove a listener when the node goes away

Before this: The DOM, No Framework

You will build a small promise so you can see what await is hiding, then add timeout, retry, and a rejection path that does not vanish.

• Run async work in parallel when it is safe
• Handle rejection, timeout, and cancellation
• Explain what await is waiting on

Before this: Events, and Who Handles Them

Call stack, tasks, microtasks, and timers. Advanced, because you will hand-trace mixed snippets and check yourself in the browser until the surprises stop.

• Predict the order of timers and promises mixed together
• Explain why a long loop freezes the page
• Break blocking work into chunks that keep the UI alive

Before this: Promises and async/await

Imports, the module graph, and a bundle that got too big. You will split the first load without treating the bundler as weather.

• Explain how a bundler resolves an import
• Split a bundle so the first page stays small
• Debug a build that produced the wrong file

Before this: Objects, Arrays, and Methods

Status codes, JSON, loading, and the empty response. You will stop treating the network as a function that always returns an array.

• Read a status code and decide what the UI should do
• Show loading and failure as designed states
• Cancel a request when the person navigates away

Before this: Promises and async/await

Advanced, because the platform already does more than most forms use. You will build one that works before any script runs, then improve it.

• Read a form with FormData
• Use constraint validation before custom script
• Submit without losing the person's input on failure

Before this: Events, and Who Handles Them

You will test an interface the way a person uses it, and learn what not to mock. A test that fails for a useless reason is treated as a bug.

• Write a test that survives an internal refactor
• Query the UI the way a person finds a control
• Diagnose a flaky test instead of retrying it

Before this: Promises and async/await

The prototype chain, classes, and the three ways to pin this. You will break it on purpose so the fix is a choice, not a superstition.

• Trace a property lookup up the prototype chain
• Say what this refers to at a call site
• Choose a class, a factory, or a plain object

Before this: Values, Scope, and Functions

Routing by hand, state in one place, and a render you can point at. The point is to feel the cost, so a framework later is a trade you understand.

• Hold UI state in one place you can name
• Render a view from that state
• Move between two screens without a framework router

Before this: The DOM, No Framework

Long tasks, the performance panel, and work that does not belong on the thread painting the page. You will measure before you rewrite.

• Find a long task in the performance panel
• Split work so input stays responsive
• Justify a change with a before-and-after trace

Before this: The Event Loop, Slowly

You pick the product. We cut scope until it ships: events, fetch, a form, and tests that describe what a person can do.

• Ship an interface with no UI framework
• Cover the critical path with behavior tests
• Show loading and failure without a blank screen

Before this: A UI with No Framework