node

Node.js, zero to senior

The runtime behind your backend — event loop, modules, async and streams — built up to senior depth.

15 units·53 lessons·~16 h

Start track →

Open the Mastery Lab

Curated hands-on challenges: build, diagnose, master.

00

Start from zero

What Node is: V8 + libuv, one event loop, non-blocking I/O.

01 What Node.js actually is 14 min

01

Modules & runtime

CommonJS vs ESM, and how npm resolves and locks dependencies.

01 CommonJS vs ESM 16 min 02 package.json, npm, semver and lockfiles 16 min 03 The module cache: identity, singletons, and duplicate copies 17 min 04 Runtime bootstrap and the event loop 18 min 05 Process lifecycle and graceful shutdown 18 min

02

Async & streams

Callbacks → promises → async/await, and streams with backpressure.

01 Async patterns and error handling 17 min 02 Streams, pipes and backpressure 17 min 03 Concurrency control: combinators, bounded fan-out, and cancellation 18 min 04 Async iterators and generators: pull-based streams without the buffer 18 min 05 Stream pipelines, transforms, and the .pipe() error trap 18 min

03

Errors & diagnostics

How Node surfaces, propagates, and lets you diagnose failures.

01 Error handling: throw, reject, and never swallow 18 min 02 Debugging Node with --inspect and DevTools 18 min 03 Diagnostics: channels, async context, and profiles 19 min

04

Performance

Find and fix the event-loop and memory bottlenecks.

01 Monitoring event-loop lag 18 min 02 CPU profiles and the heap-snapshot leak hunt 19 min 03 Worker threads and clustering 19 min

05

HTTP & frameworks

From the raw http module to a production HTTP service.

01 The http module: servers, clients, and streams 18 min 02 Express vs Fastify: middleware and throughput 18 min 03 Middleware, error boundaries, and graceful shutdown 18 min

06

Testing

Fast, trustworthy Node tests.

01 Unit testing with node:test and Vitest 18 min 02 Integration testing an HTTP API 18 min 03 Test doubles and mocking: seams, not sledgehammers 18 min 04 Test isolation and flakiness: making tests deterministic 18 min 05 Coverage, mutation testing, and what's worth testing 18 min

07

Security

The Node-specific attack surface.

01 Input validation and handling secrets 19 min 02 Dependencies and supply-chain risk 19 min 03 Authentication and sessions: cookies, JWTs, and password hashing 18 min 04 Security headers, CORS, and TLS posture 18 min 05 SSRF, ReDoS, and path traversal: the server attack surface 19 min

08

Packaging & deploy

Ship a Node service.

01 Bundling and publishing: ESM, CJS, and exports 18 min 02 Containerizing Node: PID 1, signals, and slim images 18 min 03 Configuration and runtime flags: env, fail-fast, and heap limits 18 min 04 Zero-downtime deploys: health probes, draining, and rollouts 19 min 05 The release pipeline: versioning, dist-tags, and npm provenance 18 min

09

Putting it together

Design and harden a small Node HTTP service end to end.

01 Capstone: designing and hardening a production Node service 20 min

10

Networking, deep

Below HTTP: raw TCP and UDP sockets, and the production traps.

01 TCP and the net module: sockets, lifecycle, and backpressure 18 min 02 UDP and dgram: datagrams, message boundaries, and when to drop reliability 16 min 03 Sockets in production: timeouts, limits, and fd exhaustion 18 min

11

TLS and HTTP/2

Encrypted transport and the multiplexed protocol above it.

01 TLS and HTTPS in Node: ship the whole chain 16 min 02 HTTP/2 and ALPN: one connection, many streams, one failure mode 18 min 03 The HTTP client deep dive: undici, pools, timeouts, and leaked sockets 16 min

12

Native addons & FFI

Calling C/C++ from Node — and when not to.

01 Native addons with Node-API: the stable ABI and the boundary 18 min 02 Building native addons, prebuilds, and when not to: WASM and the alternatives 18 min 03 FFI: calling a prebuilt shared library from JS with koffi — and who owns the memory 20 min

13

Modules, deep

How Node finds code, and how packages expose it.

01 The module resolution algorithm: how Node finds your code 18 min 02 Package exports and conditions: the public API contract 20 min 03 Module customization hooks: intercepting resolve and load 18 min 04 CJS/ESM interop, deeply: require(esm), named exports, and TLA 19 min 05 Module load performance: cold start, compile cache, and snapshots 19 min

14

V8 internals & crypto

How V8 optimizes your code, and using crypto correctly.

01 V8 optimization: hidden classes, inline caches, and the JIT tiers 18 min 02 Node crypto, used right: KDFs, HMAC, signatures, and constant-time compares 16 min 03 Heap snapshots and flame graphs: finding leaks and hot paths in production Node 18 min

Build with this track

Guided projects that exercise what you learn here.

Hot-Path Profiler Lab

Take a deliberately slow piece of JavaScript and turn it into a controlled experiment. You'll build a micro-benchmark harness you actually trust, profile the hot path until you can name what the engine is doing, and apply engine-aware fixes — monomorphism, killing megamorphic call sites, cutting allocations — proving each win with numbers instead of vibes. This is the whole discipline of performance work in miniature: measure, form a hypothesis about the engine, change one thing, measure again.

Mini CRUD API

Build your first real backend: a tiny HTTP API that creates, reads, updates, and deletes notes — backed by SQLite so the data survives a restart. You go from a one-line 'hello' server to a small service that validates input and stores rows, one honest step at a time.

Production-Shaped Nest Service

NestJS rewards you for structure and punishes you for skipping it. Build a service the way a team would ship it: feature modules with real boundaries, DTOs that validate at the edge, guards and interceptors that own cross-cutting concerns, a typed config you can't typo, and an e2e suite that boots the whole app. This is the difference between knowing Nest's decorators and knowing why they exist.

NestJS, zero to senior

A structured framework for Node backends — it gives your server a clear, opinionated shape so a TypeScript codebase stays organized as it grows into production.