Use values, variables, strings, numbers, booleans, arrays, conditions, and loops in JavaScript. Build small command-line programs that transform input into useful output.

Write functions, pass data into them, return results, and handle scope. Practice breaking a script into small reusable pieces instead of one long file.

Work with objects, arrays of objects, destructuring, spread syntax, dates, JSON, and common built-in methods. Use these tools to model real data such as users, orders, files, and settings.

Trace how Node.js grew from server-side JavaScript into a major backend runtime. Cover CommonJS, npm, the event loop model, async programming changes, long-term support releases, and how the ecosystem shaped modern web development.

See how Node.js runs JavaScript outside the browser, including the V8 engine, the runtime, core modules, and the process object. Use command-line arguments, environment variables, exit codes, and standard input/output.

Use callbacks, promises, async/await, timers, and error handling for asynchronous work. Build small programs that wait for files, network calls, and timers without blocking the whole process.

Study the call stack, task queues, microtasks, libuv, and how Node.js handles many operations with one main thread. Diagnose common timing surprises and avoid blocking code that freezes a server.

Use CommonJS require/module.exports and the package.json file to organize code. Create a small multi-file project with local modules, scripts, and configuration.

Use import/export, package type settings, file extensions, and interop rules between ES modules and CommonJS. Convert a small project to modern module syntax and handle practical migration issues.

Install packages, manage versions, read package.json and package-lock.json, and use npm scripts. Practice choosing packages by maintenance signals, license, security history, and fit for the job.

Use Node’s filesystem APIs to read, write, copy, delete, and watch files and folders. Build file-processing scripts that handle paths, permissions, encodings, and common filesystem errors.

Work with Buffer, binary data, encodings, readable streams, writable streams, pipes, and backpressure. Build memory-safe tools for processing large files and network responses.

Use Node’s built-in HTTP module to create servers, parse requests, send responses, and handle status codes and headers. Build a small API without a framework so the web server mechanics are clear.

Use fetch, Web Streams, URL, URLSearchParams, FormData, AbortController, and AbortSignal in modern Node.js. Build clients that call external APIs, cancel slow requests, and handle timeouts cleanly.

Build routes, middleware, error handlers, and request validation with Express. Create a practical REST API that accepts input, returns JSON, and keeps routing logic organized.

Use Fastify’s schema-driven routing, plugins, hooks, and performance-focused design. Compare framework choices by project needs rather than popularity alone.

Design REST resources, use status codes consistently, paginate responses, and version APIs. Add OpenAPI documentation so humans and tools can use the service correctly.

Validate request bodies, query strings, headers, and environment variables before they reach business logic. Use schema validation to return clear errors and reduce security and data quality problems.

Connect Node.js to PostgreSQL, run queries, manage connection pools, and use transactions. Build API endpoints that safely create, read, update, and delete database records.

Use query builders and object-relational mappers to model tables, relationships, and migrations. Compare direct SQL, Knex-style query builders, Prisma-style clients, and TypeORM-style entity models.

Use MongoDB from Node.js, model documents, index collections, and handle common query patterns. Build features where flexible document structure is useful and recognize when it is not.

Use Redis for caching, rate limits, sessions, distributed locks, and lightweight queues. Add Redis to an API to reduce database load while keeping correctness in mind.

Hash passwords, manage sessions, issue and verify JWTs, and integrate OAuth-style login flows. Build authentication that protects accounts without storing secrets carelessly.

Apply secure coding practices for injection, cross-site scripting, CSRF, broken access control, secret leakage, dependency risk, and unsafe file handling. Use Helmet, CORS settings, rate limits, and threat modeling on real Node.js routes.

Write unit tests, integration tests, and API tests using the built-in Node.js test runner and common assertion patterns. Use test doubles, fixtures, coverage, and test databases without making tests brittle.

Use breakpoints, stack traces, source maps, logging, and profiling tools to find real defects. Practice diagnosing async failures, memory leaks, slow requests, and production-only bugs.

Use TypeScript to type functions, objects, APIs, errors, and configuration in a Node.js project. Set up tsconfig, compile or run TypeScript, and use types to prevent common backend mistakes.

Configure linting, formatting, Git hooks, environment files, and project scripts that make a team codebase consistent. Build a maintainable repository structure for services, libraries, tests, and documentation.

Use child processes, worker threads, clustering, and message passing for CPU-heavy work and process isolation. Decide when concurrency belongs inside Node.js and when it belongs in another service or queue.

Use job queues for email, media processing, scheduled tasks, retries, and delayed work. Build a worker-based feature that survives crashes and handles duplicate jobs safely.

Build real-time features with WebSockets and Socket.IO-style patterns. Handle rooms, presence, reconnects, message ordering, and horizontal scaling for live applications.

Build GraphQL schemas, resolvers, mutations, subscriptions, and data loaders in Node.js. Compare GraphQL with REST for client flexibility, caching, authorization, and operational complexity.

Structure larger applications with layered architecture, dependency injection, domain services, configuration boundaries, and clear error handling. Refactor a growing API so features can change without breaking unrelated code.

Build a complete Node.js service from product request to running system: requirements, API design, database schema, implementation, tests, security checks, documentation, deployment, and monitoring. This chapter ties together the everyday workflow of a professional backend project.

Use GitHub Actions or similar tools to run tests, security checks, builds, and deployments automatically. Create a pipeline that turns a commit into a verified release artifact.

Package Node.js apps with Docker, write Dockerfiles, handle environment variables, run local multi-service stacks, and produce smaller safer images. Use containers to make development and deployment more predictable.

Run Node.js services on virtual machines, managed platforms, and container hosts. Configure process managers, reverse proxies, TLS, health checks, environment secrets, and zero-downtime restarts.

Use Kubernetes objects such as Deployments, Services, ConfigMaps, Secrets, Ingress, probes, and resource limits for Node.js workloads. Deploy a service that can roll out, recover, and scale in a cluster.

Build function-based Node.js workloads on serverless platforms, including HTTP handlers, scheduled jobs, and event triggers. Handle cold starts, stateless design, local testing, timeouts, and cloud permissions.

Run JavaScript at the edge with platform runtimes that differ from full Node.js. Adapt code for limited APIs, low-latency routing, caching, and Web-standard runtime constraints.

Measure latency, throughput, memory use, garbage collection, event loop delay, and database wait time. Use profiling and load testing to improve performance with evidence instead of guesses.

Use logs, metrics, traces, correlation IDs, alerts, and service dashboards to operate Node.js systems. Add OpenTelemetry instrumentation so requests can be followed across services and databases.

Protect the package lifecycle from malicious or vulnerable dependencies, typosquatting, secret leaks, and unsafe build scripts. Use lockfiles, audits, signing, provenance, SBOMs, and dependency update workflows.

Design services that communicate over HTTP, messaging, and event streams. Handle service boundaries, contracts, retries, idempotency, distributed tracing, and failure isolation in Node.js systems.

Use Node.js native addons, N-API, WebAssembly, and bindings to reuse lower-level code when JavaScript is not enough. Weigh performance gains against portability, build complexity, and maintenance risk.

Compare Node.js with Deno, Bun, and browser-compatible JavaScript runtimes. Evaluate package compatibility, security models, TypeScript support, performance claims, and migration tradeoffs.

Use AI coding assistants to generate tests, explain unfamiliar code, draft API clients, and review refactors while still verifying behavior yourself. Practice prompt patterns, guardrails, and review habits that keep generated Node.js code safe and maintainable.

Map Node.js skills to backend, full-stack, platform, DevOps, serverless, and open-source roles. Build proof-of-skill projects, prepare for interviews or certifications where useful, contribute to packages, and stay current with Node.js releases and security advisories.