Free through lesson 3

Node.js for Beginners

From setting up your environment through modules, async code, file I/O, HTTP and Express, SQLite, testing and running in production. Fifty lessons that take you to the point where you can assemble a notes API and a CLI yourself and keep them running. Every piece of code and result shown was produced by actually running Node.js v26.7.0.

Start from lesson 1 Unlock every course

Curriculum

The 50 lessons are grouped into seven chapters. Working through them in order is the best way, but you are welcome to dip into whatever interests you. Note: this cannot run inside the browser, so try it with your own node (version 22 or later).

Chapter 1 — Getting started (lessons 1–5)

You get to grips with how Node.js runs and set up your environment with a version manager. You cover the different console methods, command line arguments, environment variables and .env, so values can come in from outside.

1

What Node.js is (V8 and libuv)

How JavaScript runs outside the browser. Why there is no window but there is a process, and confirming that it does not wait on I/O by watching the order of the output.

Free
2

Setting up and version management

Installing through a version manager rather than the official installer. Switching Node.js per project and recording the version in the repository.

Free
3

Running scripts and the different console methods

Why log and error go to different places. Turning a list into a table with console.table, and seeing all of a collapsed [Object] with console.dir.

Free
4

process and command-line arguments

Receiving values from outside with process.argv and parsing options with parseArgs. Including signalling success or failure through the exit code.

🔒 Basic
5

Environment variables and .env

Everything in process.env is a string. Reading .env with --env-file instead of installing dotenv, and gathering config validation into config.js.

🔒 Basic

Chapter 2 — Modules and packages (lessons 6–10)

You split code across files and pull in other people's. You pin down the difference between CommonJS and ES Modules along with the rules that decide which is which, then go on to package.json and semantic versioning in npm.

6

CommonJS modules (require and module.exports)

Splitting files and deciding what is public. The require cache, and why reassigning exports has no effect.

🔒 Basic
7

ES Modules (import and export)

The language's own module system. How imports are evaluated first, why relative paths need the extension, and import.meta and top-level await.

🔒 Basic
8

Choosing between CommonJS and ESM

The rules that decide how a .js file is read. CJS from ESM goes through default; ESM from CJS needs require from 22.12 or a dynamic import.

🔒 Basic
9

How to read package.json

The fields for identity, entry point, dependencies and scripts. Why exports is also a declaration of what is public, and what private true does.

🔒 Basic
10

npm and semantic versioning

Why writing ^1.11.13 installs 1.11.23. What committing package-lock.json means, and when to use npm install versus npm ci.

🔒 Basic

Chapter 3 — Async code (lessons 11–17)

The high point of the course. You feel the problem with synchronous code by actually freezing the process, then work up through callbacks, promises and async/await. The chapter closes with the event loop and error handling.

11

Synchronous and asynchronous work

What it means to run on a single thread. Actually freezing the process, to confirm that async is a mechanism for not stopping rather than for going faster.

🔒 Basic
12

Callbacks and error-first

The convention that the first argument is the error. Why try/catch does not work with a callback, and what callback hell actually breaks.

🔒 Basic
13

Promise basics

A box that will hold a result later. The three states, the four rules of chaining, and the most common bug of all: forgetting to return inside then.

🔒 Basic
14

async and await

Writing it so it looks like synchronous code. Why try/catch starts working again, and how an await inside a loop makes things three times slower.

🔒 Basic
15

Running in parallel and the static Promise methods

When to use all, allSettled, race and any. Implementing a timeout, and thirty lines that cap the concurrency.

🔒 Basic
16

The event loop and timers

Why setTimeout(0) does not run in 0ms. nextTick, microtasks, the priority of each phase, and the ordering that is not guaranteed.

🔒 Basic
17

Error handling in async code

An unhandled rejection takes the process down. Keeping the cause with cause, cleaning up in finally, and always pairing a retry with a limit and backoff.

🔒 Basic

Chapter 4 — Files and I/O (lessons 18–26)

From building paths through reading and writing files, working with directories and handling JSON. The second half — streams, EventEmitter, Buffer and readline — lets you push large amounts of data through at constant memory.

18

The path module and building paths

The difference between join and resolve, mixing up __dirname and process.cwd(), and validating before joining user input onto a path.

🔒 Basic
19

Reading files

Why fs/promises is the default. That omitting utf8 gives you a Buffer, that you branch on the error code, and that large files go line by line.

🔒 Basic
20

Writing files

writeFile empties the file the instant it opens it. Making writes unbreakable with a temporary file plus rename, and using a stream for large output.

🔒 Basic
21

Working with directories

Make recursive the default for mkdir. Since readdir's recursive cannot exclude node_modules, write your own walk or use fs.glob.

🔒 Basic
22

Reading and writing JSON files

How require('./config.json') gets cached. What stringify loses, the round-trip problem of Date becoming a string, and adding the filename to a SyntaxError.

🔒 Basic
23

Streams

The mechanism that turns 620MB of memory into 69MB. Why you use pipeline rather than pipe, and the standard form for backpressure.

🔒 Basic
24

EventEmitter

How on and emit work. That emit is synchronous, that only 'error' throws when nobody is listening, and forgetting to remove a listener.

🔒 Basic
25

Buffers and character encodings

Moving between bytes and strings. That subarray is not a copy, why text breaks at a chunk boundary, and three ways to fix it.

🔒 Basic
26

Interactive programs with readline

Asking one question at a time with readline/promises. How forgetting rl.close() hangs everything, and supporting both interactive and piped input.

🔒 Basic

Chapter 5 — HTTP and Express (lessons 27–34)

You write the server, the router and body parsing yourself with the raw http module before moving to Express. Knowing exactly what Express is doing for you, you go on to REST APIs and error design.

27

Building a server with the http module

req is a Readable, res is a Writable. The difference between setHeader and writeHead, specifying a charset, and serving files with pipeline.

🔒 Basic
28

Writing your own router

A fifty-line router. Extracting path parameters with URLPattern, distinguishing 404 from 405, and catching exceptions in one place.

🔒 Basic
29

Request bodies and a JSON API

Why there is no req.body. How body += chunk breaks non-ASCII text, and a body reader with a size limit.

🔒 Basic
30

An HTTP client with fetch

fetch does not throw on a 404. That the real cause is in err.cause, that you always add a timeout, and what makes a request worth retrying.

🔒 Basic
31

Getting started with Express

A mapping table against the raw http module. The difference between res.send and res.json, the one line of express.static, and why you place your own 404 handler.

🔒 Basic
32

Express middleware

Forget to call next() and the request just stops. The four levels of scope, and the fact that express.json() does the same job as your own code from lesson 29.

🔒 Basic
33

A REST API in Express

URLs are nouns, actions are methods. What PUT loses that PATCH does not, and designing a single shape for error responses.

🔒 Basic
34

Error handling and status codes

Separating the expected from the unexpected. Designing so no stack trace reaches production, and the problem of a failure mid-stream looking like a success.

🔒 Basic

Chapter 6 — Storing data and keeping it correct (lessons 35–42)

You move storage from a JSON file to SQLite, separate out configuration, and add validation with zod. The second half gathers the tools that keep your code correct: debugging, testing and linting.

35

Using a JSON file as a data store

Moving to storage that survives a restart. The lost update where 200 concurrent increments give you 1, and a ten-line mutex.

🔒 Basic
36

Persisting data with SQLite

node:sqlite is built in, so there is nothing to npm install. Placeholders, converting types at the boundary, and a bulk INSERT made a thousand times faster by a transaction.

🔒 Basic
37

Separating configuration and switching environments

Measuring the precedence of --env-file. Splitting files per environment, confining loading to config.js, and failing at start-up.

🔒 Basic
38

Input validation (zod)

Thirty hand-written lines become twelve. safeParse and .strict(), converting query strings with z.coerce, and localised messages in one line.

🔒 Basic
39

How to debug

console.log gives up at depth two. util.inspect and debuglog, reading a stack trace, and the --trace-* flags.

🔒 Basic
40

Writing tests with node:test

Tests run with zero config files and zero dependencies. When to use assert/strict, and how to read the diff on a failure.

🔒 Basic
41

Async tests and mocking

Solving it in the design, through dependency injection. mock.fn and mock.method, retry tests with zero waiting, and testing HTTP with listen(0) and fetch.

🔒 Basic
42

ESLint and Prettier

ESLint finds bugs; Prettier makes things look consistent. Writing a flat config, and the point that what --fix cannot fix is the part that matters.

🔒 Basic

Chapter 7 — Professional tooling and wrapping up (lessons 43–50)

TypeScript, logging, CLIs, child processes, worker_threads, measurement and graceful shutdown. You finish by assembling a notes API and CLI that pull all of it together.

43

Using TypeScript

node src/main.ts runs as it is. But it does no type checking, so tsc --noEmit takes that half of the job, and syntax that cannot be erased is off limits.

🔒 Basic
44

Logging and handling exceptions in production

Eighty lines of structured logging. Redacting secrets mechanically, serialising an Error, and carrying a request ID around with AsyncLocalStorage.

🔒 Basic
45

Building a CLI tool

The shebang and the bin field. Since parseArgs cannot handle subcommands in one pass, you slice argv yourself. Exit codes and detecting a TTY.

🔒 Basic
46

External commands with child_process

When to use exec, execFile, spawn and fork. How passing user input to exec executes commands, and the 1MB maxBuffer.

🔒 Basic
47

Heavy work with worker_threads

Getting CPU-bound work off the main thread. A worker pool and SharedArrayBuffer, and the fact that none of it helps with I/O.

🔒 Basic
48

Measuring performance

Do not guess, measure. Why one measurement is never enough, and mark/measure, event loop delay and CPU profiles.

🔒 Basic
49

Running in production and graceful shutdown

The five stages between receiving SIGTERM and exiting. How /health and /ready differ, and whether you should write cluster yourself.

🔒 Basic
50

[Project] Wrapping up with a notes API and CLI

Express and zod are the only third-party packages. Integrating the tools from 49 lessons into one app, from configuration and the database through validation, logging and shutdown.

🔒 Basic

Once you have finished all 50 lessons, add types with TypeScript for Beginners, or connect to the frontend with Next.js for Beginners. Membership unlocks every course.