Outline updated November 2026

Intermediate21 hours delivered over 3-5 daysLive, online or on-site

Request this course

Node.js for Professionals: Building Reliable Back-End Services

Class Duration

21 hours of live training delivered over 3-5 days to accommodate your scheduling needs

Student Prerequisites

  • Good understanding of programming concepts including asynchronous programming
  • Experience with JavaScript programming

Target Audience

Software engineers, tech leads, and architects who build back-end services, APIs, and internal tools with Node.js. Teams with older CommonJS codebases will also learn how to move them forward. New to modern JavaScript? Start with JavaScript Essentials. Advanced JavaScript is helpful background but not required.

Description

This course teaches developers to build and run back-end services with modern Node.js. It is ES modules first, with CommonJS interop covered as one focused topic for older code. Students use the built-in tools that replace common dependencies: --watch, --env-file, node --run, type stripping, and node:test. They build REST APIs with node:http and Express, call services with fetch, and store data with node:sqlite. The last modules cover the permission model, container images, graceful shutdown, and observability with OpenTelemetry.

Learning Outcomes

  • Choose a Node.js release line and plan upgrades.
  • Set up watch mode, environment files, and the inspector.
  • Structure applications with ES modules and package exports.
  • Interoperate with CommonJS code, including require(esm).
  • Run TypeScript directly with type stripping.
  • Write non-blocking, cancellable I/O with promises, streams, and AbortController.
  • Manage dependencies with npm lockfiles, workspaces, and npm ci.
  • Build REST APIs with node:http and Express.
  • Persist data with node:sqlite.
  • Test services with node:test and node:assert.
  • Restrict a process with the permission model.
  • Package and operate services in containers.

Training Materials

All students receive comprehensive courseware covering all topics in the course. Courseware is distributed via GitHub in the form of documentation and extensive code samples. Students practice the topics covered through challenging hands-on lab exercises.

Software Requirements

Students will need a free, personal GitHub account to access the courseware. No local student setup is required, this course is delivered with GitHub Codespaces. The free allotment of Codespaces hours from GitHub is sufficient to complete the course.

Versions covered: Node.js 26 LTS with npm 11 and Express 5, with notes where the Node.js 24 and 22 maintenance lines differ.

Training Topics

Getting Started

  • V8, libuv, and the runtime model
  • Release lines and LTS windows
  • Planning upgrades
  • Switching versions with a version manager
  • Debugging with the inspector in VS Code
  • Git basics for the course repository

Running and Iterating

  • Scripts, the REPL, and node --run
  • Restarting on change with --watch
  • Configuration with --env-file
  • process.loadEnvFile()
  • Running TypeScript with type stripping
  • Erasable syntax only
  • When to keep a build step

ES Modules

  • "type": "module", .mjs, and .cjs
  • import and export
  • Dynamic import() and top-level await
  • node: prefixed core modules
  • import.meta.dirname and import.meta.filename
  • import.meta.resolve
  • Package exports and subpath imports
  • Import attributes and JSON modules

CommonJS Interop

  • Reading require and module.exports
  • Importing CommonJS from ES modules
  • Loading ES modules with require(esm)
  • Dual packages
  • Incremental migration to ESM

Event Loop and Async Patterns

  • Event loop phases
  • Microtasks and process.nextTick
  • node:fs/promises and node:timers/promises
  • EventEmitter, events.once, and events.on
  • Cancellation with AbortController
  • Worker threads for CPU-bound work

Using the Node Package Manager (npm)

  • package.json and semver ranges
  • Dependencies and dev dependencies
  • npm ci and reproducible installs
  • Lockfiles
  • Global vs. local installs and npx
  • npm scripts
  • Workspaces
  • npm audit and provenance
  • Reviewing dependency changes

Filesystem, Streams, and Buffers

  • node:fs/promises and node:path
  • Watching files and directories
  • Readable, writable, and transform streams
  • pipeline() from node:stream/promises
  • Web Streams interop
  • Buffers for binary data

HTTP, fetch, and WebSocket

  • HTTP methods and status codes
  • A basic server with node:http
  • Built-in fetch, Request, and Response
  • Timeouts with AbortSignal.timeout()
  • Retries
  • The built-in WebSocket client
  • WebSocket servers with a library

Building REST APIs with Express

  • Express and promise-aware routing
  • Routes for each HTTP method
  • Built-in, third-party, and custom middleware
  • Path parameters and query strings
  • Request validation
  • 404 routes
  • Centralized error handling
  • Designing a REST API

Database Access with node:sqlite

  • node:sqlite and its stability status
  • Creating databases and tables
  • Prepared statements and CRUD
  • Transactions
  • Database migrations
  • When to use a driver or ORM

Testing with node:test

  • node --test, describe, and it
  • Hooks and subtests
  • Assertions with node:assert
  • Mocking functions and timers
  • Module mocking status
  • Snapshot testing
  • Code coverage
  • Testing HTTP APIs

Security and the Permission Model

  • --permission and --allow-fs-read
  • File system write permissions
  • Child process and worker permissions
  • Network access with --allow-net
  • Secrets and configuration hygiene
  • Input validation and safe errors
  • Security releases and upgrades

Deployment and Operations

  • Validating configuration at startup
  • Multi-stage container builds
  • Slim, non-root images
  • Signals and graceful shutdown
  • Health checks
  • Platform restarts and scaling
  • Where cluster or a process manager fits
  • Structured logging with pino
  • Metrics and OpenTelemetry tracing
  • Diagnostic reports and heap snapshots
  • CPU profiles

Private team training

Bring this course to your team

Tell us about your team and we will tailor this outline to your tools, stack, and schedule. Courses can also be combined into a longer program.

  1. Tell us what you needYour tools, stack, team size, and timeline.
  2. We send a proposalA course or program, an outline adjusted to your team, and possible dates.
  3. Your team trains liveOnline or on-site, with courseware for every student.

Prefer to talk? Call +1 434-509-6890 or email help@cloudcontraptions.com.

We reply within 1 business day.

Training partner?