Node.js Quest

Tracks

1. 01⚙️Runtime Fundamentals

   0/5 lessons

   V8, libuv, the event loop — what `node` actually is

   The runtime under everything you `npm install`. V8 executes your JavaScript; libuv handles the waiting; the event loop is the clock. Plus the escape hatches when single-threaded isn't enough.

   Lesson list (5)

   • 01
     What Is Node, Really?~12 min · runtime, v8, javascript, foundations
   • 02
     V8 — The Engine Underneath~14 min · runtime, v8, jit, performance
   • 03
     libuv and the Event Loop~16 min · runtime, libuv, event-loop, async
   • 04
     The Single-Threaded Model (And Its Escape Hatches)~13 min · runtime, threading, worker-threads, concurrency
   • 05
     The `node` Binary — A CLI That's Also a Runtime~12 min · runtime, cli, repl, flags

   ✓Quiz · 5 questions→

2. 02📦The Module System

   0/5 lessons

   CJS, ESM, package.json, semver, and the npm/pnpm/bun ecosystem

   Two module systems living in one runtime, four dependency buckets, three competing package managers — and the lockfile that keeps them all honest. By the end you'll read any package.json and know what the consumer experience is.

   Lesson list (5)

   • 01
     CJS vs ESM — Two Module Systems, One Runtime~14 min · modules, cjs, esm, interop
   • 02
     package.json Anatomy and Semver~14 min · modules, package-json, semver, exports
   • 03
     npm vs pnpm vs Bun — How Package Managers Actually Work~14 min · modules, npm, pnpm, bun, lockfiles
   • 04
     dependencies vs devDependencies vs peer vs optional~12 min · modules, dependencies, peer-deps
   • 05
     Workspaces and Monorepos~13 min · modules, workspaces, monorepo, pnpm

   ✓Quiz · 5 questions→

3. 03🎼Async — Callbacks, Promises, and the Modern Toolkit

   0/5 lessons

   From error-first callbacks to AsyncLocalStorage, with the event-loop machinery in plain sight

   Three eras of Node async live in 2026: callbacks (still right for repeated events), promises (single eventual values), and the modern primitives (AsyncIterator for streams of values, AbortController for cancellation, AsyncLocalStorage for context). You'll know when each is correct and which traps live in each.

   Lesson list (5)

   • 01
     Callbacks — How Node Started Its Async Life~12 min · async, callbacks, history
   • 02
     Promises — A Value That Doesn't Exist Yet~13 min · async, promises, mental-model
   • 03
     async / await — Sugar Over Promises (With Teeth)~13 min · async, async-await, promises
   • 04
     Microtasks vs Macrotasks — The Scheduler's Two Queues~14 min · async, microtasks, scheduling, event-loop
   • 05
     AsyncIterator, AbortController, AsyncLocalStorage~14 min · async, async-iterator, abort-controller, async-local-storage

   ✓Quiz · 5 questions→

4. 04🚿Streams — Bounded Memory, Composable Pipelines

   0/5 lessons

   Readable, Writable, Duplex, Transform, and the Web Streams that quietly arrived

   Streams aren't a performance optimization — they're a modularity tool. By the end you'll naturally reach for streams when input is large, unbounded, or naturally chunked, and you'll know why `pipeline` beat `.pipe()` and why both Node Streams and Web Streams now live in the same runtime.

   Lesson list (5)

   • 01
     Why Streams Exist~12 min · streams, memory, fundamentals
   • 02
     Readable and Writable — The Two Foundations~13 min · streams, readable, writable
   • 03
     Duplex and Transform — Streams in Both Directions~12 min · streams, duplex, transform
   • 04
     .pipe() vs pipeline — and Backpressure~13 min · streams, pipe, pipeline, backpressure
   • 05
     Web Streams in Node + Async Iteration~12 min · streams, web-streams, async-iter

   ✓Quiz · 5 questions→

5. 05📡I/O and Networking

   0/5 lessons

   fs/promises, http, native fetch, WebSocket, file watchers

   Five surfaces of Node speaking to the world: the filesystem, raw HTTP servers, the built-in fetch client, persistent two-way WebSocket connections, and the file watcher that powers dev servers. Each has its native idiom and one or two foot-guns worth knowing in advance.

   Lesson list (5)

   • 01
     fs/promises — File I/O the Modern Way~12 min · io-net, fs, filesystem
   • 02
     The http Module — HTTP From Scratch~14 min · io-net, http, server
   • 03
     Native fetch — Node's Built-In HTTP Client~12 min · io-net, fetch, undici, http-client
   • 04
     WebSocket — Persistent Two-Way Connections~12 min · io-net, websocket, realtime
   • 05
     File Watchers — fs.watch and the OS Quirks Beneath~11 min · io-net, fs-watch, filesystem

   ✓Quiz · 5 questions→

6. 06⚡Modern Node — The 2026 Reality

   0/5 lessons

   Native features that retired entire npm dependency categories

   Node 22 / 24 / 26 ship features that most devs still don't know exist. Built-in test runner, native fetch + Web Streams, --env-file, --watch, --experimental-strip-types, permissions, single-executable apps, node:sqlite. Each replaces an entire npm dependency category. Together they shift what 'a Node project' even looks like.

   Lesson list (5)

   • 01
     node --test — The Built-In Test Runner~12 min · modern-node, testing, node-test
   • 02
     Native fetch + Web Streams — Deeper~12 min · modern-node, fetch, web-streams
   • 03
     --env-file + --watch — dotenv + nodemon, Both Built In~10 min · modern-node, env-file, watch
   • 04
     Native TypeScript — --experimental-strip-types~11 min · modern-node, typescript, strip-types
   • 05
     Permissions Model + SEA + node:sqlite~13 min · modern-node, permissions, sea, sqlite

   ✓Quiz · 5 questions→

7. 07🔨Tooling — From a Node-Runtime Perspective

   0/5 lessons

   Vite, esbuild, swc, Bun, monorepos — all explained as Node programs orchestrating native binaries

   Frontend's tooling renaissance happened in 2020-2024. Most JavaScript build tools are now Go or Rust under a thin Node wrapper. Understanding the runtime/binary split explains both why they're fast and where their performance ceilings live. Plus: bundle-vs-no-bundle, pnpm + turborepo for monorepos.

   Lesson list (5)

   • 01
     Bundle vs No-Bundle — The 2026 Paradigm~11 min · tooling, bundler, build
   • 02
     esbuild and swc — JavaScript Tools That Aren't JavaScript~11 min · tooling, esbuild, swc, transpilation
   • 03
     Vite Under the Hood — A Node Server in Disguise~12 min · tooling, vite, dev-server
   • 04
     Bun — A JS Runtime That's Also a Toolchain~11 min · tooling, bun, runtime
   • 05
     Monorepos — pnpm Workspaces and Turborepo~12 min · tooling, monorepo, pnpm, turborepo

   ✓Quiz · 5 questions→

8. 08🚢Production — Shipping Node Services With Eyes Open

   0/5 lessons

   Security, profiling, observability, deploy, graceful shutdown

   What changes when a Node service goes to production. Supply-chain security (npm is your attack surface). Performance profiling (where time actually goes — usually not where you guess). Observability (logs + metrics + traces). Deploy substrates (launchd, systemd, PM2, SEA). Graceful shutdown (don't drop requests on every deploy). These are the unglamorous details that turn 'it works on my machine' into a real service.

   Lesson list (5)

   • 01
     Supply Chain Security — npm Is Your Attack Surface~13 min · production, security, supply-chain, npm-audit
   • 02
     Performance Profiling — Where Time Actually Goes~12 min · production, profiling, performance, inspect
   • 03
     Observability — Logging, Traces, Metrics~12 min · production, observability, logging, opentelemetry
   • 04
     Deploy Patterns — launchd, PM2, SEA, systemd~12 min · production, deploy, launchd, pm2
   • 05
     Graceful Shutdown — Don't Drop Requests on Deploy~12 min · production, shutdown, signals, zero-downtime

   ✓Quiz · 5 questions→