Free to read · Three levels

Node.js: from runtime foundations to reliable services

A complete self-study path through core Node.js, ESM, asynchronous programming, API design, testing, streams, persistence, security, and operations.

18 lessonsEnglish + ArabicContent reviewed
Start learning

In this course

Study eighteen developed lessons in three ordered levels. Each lesson connects a mental model to two complete examples, three diagnostic mistakes, two worked exercises, and official references. Examples use synthetic data and core modules so that the concepts stay visible without a framework.

Save complete JavaScript examples as .mjs files and run them with Node. Local verification used Node 22.23.3. Servers bind only to a local ephemeral port and close; file examples own temporary directories. These exercises explain important boundaries, including where a teaching model is not durable storage or production authentication.

What you will learn

  • Trace asynchronous work and assign completion, failure, cancellation, and cleanup to an explicit owner.
  • Design validated and tested application boundaries with bounded memory, concurrency, and persistence semantics.
  • Use diagnostics and operational contracts to release, observe, secure, and stop a Node.js service responsibly.

Your learning path

Three levels

Basic: the Node.js runtime

Build a precise foundation in JavaScript values, explicit modules, asynchronous control flow, files, HTTP, and startup configuration.

  1. Node.js and the JavaScript foundations
  2. Modules, packages, and npm
  3. Promises and the event loop
  4. Files, paths, and JSON
  5. HTTP requests and responses
  6. Configuration and command-line programs
Explore this level

Intermediate: application boundaries

Design validated APIs, owned error paths, meaningful tests, bounded streams, persistence contracts, and resource authorization.

  1. API contracts and validation
  2. Error boundaries and cancellation
  3. Testing behavior with core tools
  4. Streams and backpressure
  5. Persistence, transactions, and idempotency
  6. Authentication and authorization concepts
Explore this level

Advanced: reliable Node.js services

Bound concurrency, interpret runtime diagnostics, test performance claims, and prepare secure observable services for release and shutdown.

  1. Bounded concurrency and worker threads
  2. Event-loop delay and profiling
  3. Performance experiments and memory budgets
  4. Reliability and graceful shutdown
  5. Security boundaries and dependency hygiene
  6. Deployment and observability
Explore this level

Who this is for

  • Learners who want to understand server-side JavaScript and build a sound foundation for backend development.
  • Developers moving from small scripts to tested services with explicit operational and security boundaries.

Before you start

  • Basic familiarity with variables, conditions, functions, and terminal navigation; the first lesson reviews the JavaScript details used later.
  • A currently supported Node.js installation and permission to create temporary local files and local loopback listeners.

Related technical solutions

EADDRINUSE: diagnose the listener and close what you ownFind why a local HTTP bind fails, distinguish a port conflict from a lifecycle leak, and verify a bounded repair without terminating unrelated processes.Module not found and CommonJS–ESM mismatchesSeparate path resolution, module format, and export-contract failures before changing package installation.Unhandled rejections: restore ownership of asynchronous workFind detached promises, place a meaningful error boundary, and verify both failure handling and resource cleanup.