Learn Node.js

Connect V8, the event loop, libuv, worker threads, and the native thread pool.

Understand the standard behind JavaScript and how runtimes implement language features.

Choose block-scoped declarations and understand hoisting and reassignment.

Use declarations, expressions, arrows, callbacks, and higher-order functions correctly.

Use lexical scope to retain private state and build reusable functions.

Understand prototype inheritance and control a function’s this value.

Recognize shared nested references and choose the correct copying strategy.

Combine small functions into readable data-processing pipelines.

Transform multi-argument functions into reusable chains of single-argument functions.

Choose for, for...of, forEach, map, filter, and reduce according to intent.

Coordinate sequential, parallel, and conditional asynchronous operations.

Choose and configure CommonJS or ES modules without mixing incompatible assumptions.

Work with process, Buffer, timers, module paths, and other runtime-provided values.

Manage project dependencies with npm and execute package binaries with npx.

Experiment with JavaScript interactively and use useful REPL commands.

Use promisify, format, inspect, and other utilities for integration and diagnostics.

Recognize blocking work and keep I/O-heavy services responsive.

Understand callback execution and replace deeply nested flows with clearer abstractions.

Model eventual results with promises and consume them safely with async/await.

Use promises and async/await to express asynchronous workflows and handle failures clearly.

Use all, allSettled, race, and any according to failure and completion requirements.

Distinguish concurrency, parallelism, asynchronous I/O, and CPU-bound execution.

Understand event-loop phases, microtasks, nextTick, timers, and non-blocking I/O.

Understand the native eventing and thread-pool layer beneath Node.js asynchronous APIs.

Understand how readiness events and handlers enable non-blocking I/O.

Create and consume event-driven APIs with Node.js EventEmitter.

Predict scheduling order across nextTick, promise microtasks, timers, and immediates.

Choose between exec, execFile, spawn, and fork when work must run outside the main process.

Use processes or threads appropriately for multi-core and CPU-intensive workloads.

Process data incrementally with readable, writable, duplex, and transform streams.

Read, write, update, and remove files with the Node.js file-system APIs.

Understand when synchronous file APIs block the event loop and when they are acceptable.

Return status codes that accurately describe successful and failed HTTP operations.

Use GET, POST, PUT, PATCH, DELETE, and idempotency correctly in an API.

Build a small Express server with middleware, routes, and a listening port.

Build request pipelines that validate, transform, authorize, and terminate requests.

Use browser cookies safely for sessions, preferences, and authentication state.

Issue, validate, expire, and protect signed tokens without confusing encoding with encryption.

Separate identity verification from permission checks and return the correct HTTP responses.

Compare deployment, ownership, data, and operational tradeoffs across architectures.

Compare scaling up with scaling out and understand their operational tradeoffs.

Structure, secure, observe, and scale maintainable Node.js services.

Prepare a Node.js service for deployment behind a process manager and reverse proxy.

Design localized applications with external message catalogs and locale-aware formatting.

Compare polling, server-sent events, WebSockets, and WebRTC for live applications.

Build a two-way event channel between a Node.js server and browser clients.

Balance unit, integration, and end-to-end tests for reliable HTTP services.

Create a minimal browser fixture for manually testing a Node.js HTTP or real-time server.

Understand the browser document model when a Node.js service renders or serves a web client.

Handle many browser events efficiently through bubbling and a shared ancestor.

Practice execution order, scope, and asynchronous behavior with focused examples.

Review the runtime, asynchronous execution, APIs, security, testing, and architecture.

Practice explaining Node.js internals, modules, APIs, and production decisions.