How much Node.js do you already have?

• ○Runtime & toolingcoming soon

  What Node is: V8 + libuv, how it differs from the browser · node, npm, npx and the REPL · Node globals vs browser globals

• ○Modules & npmcoming soon

  CommonJS require/module.exports · ESM in Node ("type": "module", import/export) · package.json, npm install, scripts, semver

• ○File system & pathscoming soon

  fs read/write — sync vs async vs promises API · The path module, __dirname vs import.meta.url

• ○Core HTTPcoming soon

  The http module: creating a server · Request and response objects, basic routing by hand

• ○Express basicscoming soon

  Routes, middleware, req/res · Serving static files, parsing JSON bodies

• ○Environment & configcoming soon

  process.env, .env files, process.argv · The process object: exit codes, signals (surface level)

• ○Async in Nodecoming soon

  Callbacks and the error-first convention · util.promisify, async/await with fs and http

• ○Error handling & debuggingcoming soon

  try/catch, uncaughtException and unhandledRejection (surface level) · console, node --inspect, reading a stack trace

• ○Building your first APIcoming soon

  Putting it together: a small CRUD API end to end

✅ Checkpoint: you can build a small CRUD API with Express, reading and writing a file or a simple store, without copying a tutorial.

• ○The event loop in Nodecoming soon

  libuv phases: timers, poll, check, close callbacks · Timers vs setImmediate vs microtasks in Node

• ○EventEmitter & the observer patterncoming soon

  The EventEmitter class — on/emit/once/removeListener · Why http, streams and most of Node's core API extend it · Custom events, error events, the maxListeners warning

• ○Streams & bufferscoming soon

  Readable, writable, duplex and transform streams · Piping, backpressure, the Buffer type

• ○REST APIs at scalecoming soon

  Middleware chains and error-handling middleware · Request validation (Zod/Joi)

• ○REST API design principlescoming soon

  Versioning, pagination, filtering, sorting · Idempotency, and using status codes correctly · API docs (OpenAPI/Swagger), HATEOAS (surface level)

• ○Databasescoming soon

  SQL and NoSQL clients, connection pooling · Migrations and ORMs (Prisma, Mongoose)

• ○Caching with Rediscoming soon

  Cache-aside vs write-through, TTLs and invalidation · Redis as a cache vs Redis as a queue backend

• ○Authentication & sessionscoming soon

  JWTs, cookies, bcrypt · Sessions and CSRF basics

• ○Testing Node appscoming soon

  Jest/Vitest, supertest for HTTP · Mocking, fixtures, test databases

• ○Child processes & the OScoming soon

  spawn, exec, fork · The os module

• ○Logging & monitoringcoming soon

  Structured logging: morgan, winston, pino · Health checks

• ○Security fundamentalscoming soon

  helmet, input sanitization, rate limiting, CORS

• ○Real-time with WebSocketscoming soon

  ws and Socket.IO basics

• ○Background jobs & queuescoming soon

  Cron jobs, Redis-backed queues (BullMQ)

• ○Deployment basicscoming soon

  Process managers (PM2), Docker basics · Config across environments

✅ Checkpoint: you can ship a tested REST API with a real database, auth, structured logging, and a Docker image someone else can run.

• ○Node internalscoming soon

  The libuv thread pool, event loop phases in depth · process.nextTick, microtask starvation

• ○Worker threads & clusteringcoming soon

  worker_threads for CPU-bound work · The cluster module, scaling across cores

• ○Streams at scalecoming soon

  Custom streams, transform pipelines · Backpressure tuning, Web Streams in Node

• ○Performance & profilingcoming soon

  --prof, clinic.js, heap snapshots · Memory leaks, flame graphs, benchmarking

• ○AsyncLocalStorage & async_hookscoming soon

  Request-scoped context without threading params · Structured concurrency, cancellation

• ○Scalable architecturescoming soon

  Microservices and service boundaries · API gateways and service discovery (surface level)

• ○Message queues & event-driven systemscoming soon

  RabbitMQ vs Kafka: topics, partitions, consumer groups · At-least-once vs exactly-once delivery, dead-letter queues · Event-driven architecture vs request/response

• ○Serverless architecturescoming soon

  The execution model: Lambda, Vercel, Cloudflare Workers · Cold starts, statelessness, timeouts · When serverless helps, and when it doesn't

• ○GraphQL & advanced APIscoming soon

  Schema design, the N+1 problem, dataloaders

• ○Security in depthcoming soon

  OWASP for Node APIs, prototype pollution · Dependency auditing, secrets management

• ○Native addonscoming soon

  N-API basics, when to reach for native code

• ○Observabilitycoming soon

  Distributed tracing (OpenTelemetry), metrics, APM tooling

• ○TypeScript in Node at scalecoming soon

  tsconfig for Node, ts-node vs a build step · Typed environment and config

• ○Build tooling & monoreposcoming soon

  Bundling server code, ESM/CJS interop edge cases · Monorepo tooling for Node services

• ○CI/CD pipelinescoming soon

  Pipeline stages: lint, test, build, deploy · GitHub Actions (or equivalent) for a Node service · Environments, secrets in CI, deployment gates

• ○Production readinesscoming soon

  Graceful shutdown, zero-downtime deploys · Circuit breakers, retries with backoff

• ○Advanced HTTPcoming soon

  HTTP/2, keep-alive tuning, compression, caching headers

✅ Checkpoint: you can profile a memory leak from a heap snapshot, explain why an endpoint blocked the event loop, and defend a scaling decision (cluster vs workers vs microservices) with tradeoffs.