The Complete Node.js Course
Learn server-side JavaScript from the ground up. Begin with the Node.js runtime, modules, npm, files, and asynchronous programming, then grow toward production APIs, databases, testing, security, performance, and scalable architecture.
Phase 1 · Node.js Foundations
Set up Node.js, learn the runtime, organize modules, use npm, work with files, and build a practical command-line app.
Introduction, Setup & Your First Program
Discover what Node.js is, install the current LTS release, and run JavaScript from both the terminal and the interactive REPL.
JavaScript Essentials for Node.js
Build the modern JavaScript foundation needed for Node.js with values, functions, objects, collections, destructuring, and clean control flow.
Inside the Node.js Runtime
Understand how V8, libuv, the global environment, and the process object work together to execute a Node.js program.
Modules & Code Organization
Split applications into focused files and create clear public APIs with both modern ES modules and CommonJS.
npm, Dependencies & Scripts
Create repeatable projects, install third-party packages safely, understand semantic versions, and automate common tasks with npm scripts.
Files, Paths & Essential Core APIs
Read, write, and organize local data safely using Node.js core modules and promise-based file-system operations.
Async Foundations, Events & Errors
Write reliable non-blocking programs with callbacks, promises, async/await, events, timers, and deliberate error handling.
Phase Project: Build a Task Tracker CLI
Combine the entire phase into a useful command-line task tracker that stores data, validates input, and handles failure cleanly.
Phase 2 · Web Servers & HTTP APIs
Understand HTTP, build native and Express servers, design REST APIs, compose middleware, handle errors, test endpoints, and ship a complete API.
HTTP Fundamentals & Your First Server
Understand the HTTP request-response contract and build a small JSON web server directly with Node.js core APIs.
Requests, Responses & Native Routing
Read bounded request bodies, validate JSON, extract route parameters, and organize a native Node.js server without a framework.
Express 5 Fundamentals & Routers
Move from native HTTP mechanics to focused Express applications with routes, routers, JSON parsing, and async handlers.
REST API Design & CRUD
Design predictable resource-oriented endpoints with correct methods, statuses, validation, filtering, pagination, and CRUD behavior.
Middleware, Validation & Composition
Build an intentional Express pipeline for request IDs, logging, validation, authorization boundaries, and reusable route behavior.
Configuration, Errors & Observability
Turn failures into safe, consistent API responses while validating configuration, producing useful logs, and shutting down cleanly.
API Testing & Documentation
Protect API contracts with Node's test runner, unit and integration tests, isolated server lifecycles, and concise OpenAPI documentation.
Phase Project: Build a Task REST API
Combine Phase 2 into a layered, tested Express API with CRUD routes, JSON persistence, validation, structured errors, and documentation.
Phase 3 · Databases & Persistent Data
Model relational and document data, use PostgreSQL and MongoDB safely, manage migrations and transactions, add caching, and build a durable API.
SQL & Relational Data Modeling
Design a PostgreSQL-ready relational model with tables, keys, constraints, joins, aggregates, and query-driven indexes.
PostgreSQL from Node.js
Connect through node-postgres, pool connections, parameterize queries, map rows, and integrate database lifecycle with the API.
Transactions & Concurrency
Preserve multi-step invariants with transactions, isolation, row locks, optimistic concurrency, and correct retry boundaries.
Repositories, Migrations & Data Access
Create stable persistence boundaries, evolve schemas with migrations, and test real database behavior without leaking SQL into routes.
MongoDB & Document Modeling
Model aggregates as documents, use the official MongoDB driver, design indexes, and choose embedding or references deliberately.
Mongoose Schemas & Validation
Use Mongoose for schemas, validation, middleware, queries, and controlled document serialization while respecting database constraints.
Redis & Application Caching
Apply cache-aside safely with node-redis, TTLs, invalidation, stampede protection, and observable cache behavior.
Phase Project: Data-Backed Task API
Replace JSON storage with PostgreSQL, migrations, transactions, integration tests, and a measured Redis read cache.
Phase 4 · Authentication & Security
Protect identities, sessions, tokens, permissions, input, secrets, dependencies, uploads, and multi-user data with defense in depth.
Web Security & Threat Modeling
Model assets, trust boundaries, abuse cases, and API risks before selecting controls, using defense in depth and least privilege.
Password Authentication & Sessions
Build registration and login with password hashing, constant-time verification, server-side sessions, secure cookies, and rotation.
JWTs, Access Tokens & Refresh Rotation
Use signed tokens only where they fit, validate every claim, rotate refresh tokens, revoke sessions, and prevent replay.
Authorization, RBAC & Multi-Tenancy
Enforce object ownership, roles, permissions, and tenant isolation at every query and service boundary.
API Hardening: Validation, Headers, CORS & CSRF
Harden Express input and browser boundaries with allowlists, parameterized queries, Helmet, precise CORS, CSRF defenses, and safe output.
Rate Limits, Secrets & Supply-Chain Security
Protect high-risk operations with layered throttling, secret management, dependency review, audit response, and secure configuration.
Secure File Uploads & Object Storage
Stream uploads through strict limits and type checks, isolate object storage, prevent path attacks, and serve untrusted files safely.
Phase Project: Secure Multi-User API
Add accounts, sessions, roles, tenant isolation, security middleware, audits, and abuse-case tests to the data-backed API.
Phase 5 · Advanced Node.js & Architecture
Master streams, runtime internals, parallel work, real-time systems, queues, architecture, and performance engineering.
Buffers, Streams & Backpressure
Process large and binary data safely with buffers, readable and writable streams, transforms, pipeline, and backpressure.
Event Loop, libuv & Async Internals
Reason precisely about phases, microtasks, nextTick, the worker pool, async context, latency, and event-loop saturation.
Worker Threads & Child Processes
Choose and operate worker threads, child processes, and process pools for CPU work, isolation, external tools, and parallel execution.
WebSockets & Real-Time Systems
Build authenticated real-time channels with connection lifecycle, heartbeats, rooms, ordering, backpressure, and horizontal scaling.
Queues & Background Jobs
Move durable work behind queues with idempotency, retries, backoff, dead-letter handling, scheduling, and observable workers.
Architecture, Dependency Injection & Patterns
Structure larger Node.js systems with explicit boundaries, dependency inversion, use cases, adapters, events, and modular monolith design.
Performance, Memory & Profiling
Measure latency, throughput, event-loop delay, CPU, allocation, and memory retention before applying targeted optimizations.
Phase Project: Real-Time Processing Service
Build a real-time job service combining WebSockets, queues, worker threads, streams, observability, and resilient architecture.
Phase 6 · Testing, Delivery & Production
Add deep testing, TypeScript, containers, CI/CD, observability, deployment, scaling, and reliability practices.
Advanced Testing with Node's Test Runner
Design a balanced test portfolio with node:test suites, hooks, mocks, fixtures, coverage, property checks, and deterministic concurrency.
Contract, End-to-End & Resilience Testing
Verify system boundaries with database integration, API contracts, end-to-end workflows, fault injection, and performance smoke tests.
TypeScript for Production Node.js
Migrate Node.js boundaries to strict TypeScript with narrowing, generics, runtime validation, typed errors, and correct ESM configuration.
Docker, Images & Local Infrastructure
Package Node.js into minimal reproducible images, run as non-root, compose dependencies, manage signals, and scan build artifacts.
CI/CD & Release Automation
Build a secure pipeline for clean installs, checks, tests, artifacts, migrations, staged deployments, and rollback-aware releases.
Observability: Logs, Metrics & Traces
Instrument services with structured logs, RED metrics, distributed traces, context propagation, sampling, dashboards, and alerts.
Deployment, Scaling & Reliability
Operate stateless Node.js services behind proxies with replicas, health probes, timeouts, load shedding, graceful shutdown, and reliability targets.
Phase Project: Production Delivery
Convert the secure API into a typed, containerized, observable service with CI/CD, production configuration, deployment, and operational documentation.
Phase 7 · Professional Portfolio
Package reusable tools and deliver three capstones that demonstrate production APIs, real-time systems, and senior-level design reasoning.
Portfolio Project: Publish a Node.js CLI Package
Design, test, document, version, package, and publish a cross-platform CLI with a stable programmatic API and automated release workflow.
Capstone: Production SaaS API
Build a multi-tenant production API with PostgreSQL, Redis, authentication, authorization, billing-ready boundaries, observability, and delivery automation.
Capstone: Real-Time Collaboration Service
Create a horizontally scalable collaboration backend with WebSockets, presence, durable events, queues, authorization, and failure recovery.
System Design & Portfolio Review
Present architecture decisions, tradeoffs, reliability targets, threat models, diagrams, demos, and evidence as a professional Node.js portfolio.