Skip to content
Tutorials Center
My learning

Topics

Node.js Tutorial

Learn Node.js 24 from your first script to modules, streams, HTTP servers, testing and production. 133 lessons with Node.js that runs in your browser, quizzes and projects.

Start learning →

of lessons completed

Getting Started

  1. 1 Getting Started with Node.js Learn what Node.js is, what it is used for, and run your first program. Meet Node 24 LTS, ES modules, fetch, the test runner and built-in SQLite.
  2. 2 How Node.js Works Understand how Node.js works inside - V8, libuv, the single-threaded event loop, the thread pool, non-blocking I/O, native addons and why Node suits I/O work.
  3. 3 Running Node: Files, REPL and Flags Learn every way to run Node.js code - node file.js, the REPL, node -e and -p, shebang scripts, --watch, --env-file, --run, loadEnvFile and exit codes.
  4. 4 Globals and the console Tour of Node.js globals - globalThis, process, Buffer, structuredClone, fetch, URL, AbortController, navigator, import.meta - and every console method.
  5. 5 Node.js vs the Browser Compare Node.js and browser JavaScript - what is the same, what differs (DOM, modules, globals, security, APIs) and how to write isomorphic code for both.
  6. 6 Modern JavaScript You Need The modern JavaScript features Node.js code relies on - destructuring, spread, optional chaining, classes with private fields, iterators, groupBy, toSorted and using.
  7. 7 this Binding and Module-Level State in Node Understand what this means in Node.js modules, functions, methods and event listeners, fix lost this with bind, call and arrow functions, and avoid shared module state leaking between requests.

Modules and Packages

  1. 8 ES Modules Learn ES modules in Node.js - import and export syntax, default vs named exports, live bindings, top-level await, dynamic import(), import.meta and circular imports.
  2. 9 CommonJS Modules Understand CommonJS in Node.js - require, module.exports vs exports, the module wrapper, require.cache, require.resolve, JSON files, circular requires and when to still use it.
  3. 10 Mixing ESM and CommonJS How ES modules and CommonJS work together in Node.js 24 - importing CJS from ESM, require(esm), createRequire, dual packages, the exports field, default-export pitfalls and JSON imports.
  4. 11 package.json and the npm Registry Learn package.json for Node.js - name, version, type, exports, imports, scripts, dependencies, semver ranges, lockfiles, npm install and ci, npx and workspaces, with runnable stand-ins.
  5. 12 Creating and Publishing Packages Build a Node.js package step by step - library layout, the exports map, bin commands, files, versioning and changelogs, npm pack and link, provenance and private registries.
  6. 13 TypeScript in Node.js Run .ts files directly in Node.js 24 with built-in type stripping - erasable syntax only, import type, file extensions, tsconfig for Node, type-checking with tsc and tsx or ts-node alternatives.
  7. 14 Module Design Patterns Design Node.js modules well - singleton modules, factory functions, dependency injection by parameter, barrel file costs, circular dependency traps and project layout.

The Runtime

  1. 15 The Event Loop Understand the Node.js event loop - phases, microtasks versus macrotasks, nextTick, setImmediate and setTimeout order, starving the loop and measuring lag.
  2. 16 Timers Master Node.js timers - setTimeout, setInterval, setImmediate, clearing, unref and ref, the promise-based timers module, scheduler.wait, drift and AbortSignal.timeout.
  3. 17 The process Object Learn the Node.js process object - argv, env, cwd, exit codes, exit and beforeExit events, signals like SIGTERM, stdin and stdout streams, hrtime and memory usage.
  4. 18 Events and EventEmitter Learn Node.js events - EventEmitter on, once, off and emit, listener order, the special error event, events.once and on, captureRejections, EventTarget and memory leak warnings.
  5. 19 Errors and Error Handling Handle errors in Node.js properly - Error classes, error.cause, AggregateError, system error codes like ENOENT, error-first callbacks, uncaughtException, unhandledRejection and exit strategies.
  6. 20 The util Module Learn the Node.js util module - promisify and callbackify, inspect and custom inspect, format, types, parseArgs, styleText, deprecate, isDeepStrictEqual and debuglog, with runnable examples.
  7. 21 The os and path Modules Learn the Node.js path module (join, resolve, relative, parse, posix vs win32, traversal safety), the os module basics and how to convert between file paths and file URLs.
  8. 22 URLs, URLSearchParams and URLPattern Learn the WHATWG URL class in Node.js, URLSearchParams, percent-encoding, building URLs safely, URL parsing pitfalls, the legacy url.parse and the global URLPattern for matching routes.
  9. 23 The vm Module: Running Code in Separate Contexts Learn how node:vm compiles and runs JavaScript in separate contexts, how globals, timeouts and errors behave, why vm is not a security sandbox, and what to use instead for untrusted code.
  10. 24 WebAssembly in Node.js: Modules, Memory, Imports and Traps Learn what WebAssembly is, how Node.js loads and runs .wasm modules with the global WebAssembly API, how memory, imports and traps work, and run hand-built modules in the editor.

Buffers and Binary Data

  1. 25 Buffers Learn Node.js Buffers - creating them with from, alloc and allocUnsafe, hex and base64 encodings, subarray memory sharing, concat, compare, reading and writing integers, and Buffer versus Uint8Array.
  2. 26 Typed Arrays, ArrayBuffer and DataView Learn typed arrays, ArrayBuffer and DataView in Node.js - element types, views and shared memory, endianness, resizable and transferable buffers, SharedArrayBuffer and parsing binary file formats.
  3. 27 Text, Encodings and Unicode Understand Unicode in Node.js - UTF-8 versus UTF-16, string length versus byte length, TextEncoder and TextDecoder, streaming decoding, normalization, Intl.Segmenter, atob/btoa and Buffer base64.
  4. 28 Working with Binary Protocols Learn to design and parse binary protocols in Node.js - length-prefixed framing, a streaming frame parser, bitfields, zlib.crc32 checksums, packing and unpacking, and endianness bugs, with a TCP demo.

File System

  1. 29 Reading and Writing Files Learn to read and write files in Node.js with fs/promises - readFile, writeFile, appendFile, encodings, flags, FileHandle, error codes such as ENOENT and EEXIST, and atomic writes that never leave half a file.
  2. 30 Sync, Callback and Promise APIs Compare the three Node.js fs API styles - synchronous, callback and promise - learn when readFileSync is fine, how promisify bridges them, and why fs.existsSync followed by an action is a race condition.
  3. 31 Directories, Stats and Watching Work with folders in Node.js - mkdir recursive, readdir with withFileTypes, stat and lstat, rm, cp, rename, fs.glob, fs.watch caveats, and walking a directory tree with async iteration.
  4. 32 File Streams Process big files in Node.js without loading them into memory - createReadStream and createWriteStream, highWaterMark, byte ranges, reading lines with readline, copying with pipeline and tail-like reading.
  5. 33 Paths, Permissions and Safe File Handling Handle files safely in Node.js - file modes and chmod, symlinks, path traversal attacks and how to block them, os.tmpdir and mkdtemp, cleanup with finally, sanitizing filenames and the permission model.

Streams

  1. 34 Streams Fundamentals Learn Node.js streams from scratch - why they exist, the four stream types, chunks, flowing and paused modes, events, encodings, Readable.from and async iteration.
  2. 35 Readable Streams Create and control Node.js readable streams - Readable.from, subclassing with _read and push, objectMode, highWaterMark, the readable event, destroy and error handling.
  3. 36 Writable Streams Master Node.js writable streams - write() and end(), the return value and drain event, building a custom sink with _write and _final, writev, cork, errors and finished().
  4. 37 Transform and Duplex Streams Build Node.js Transform and Duplex streams - transform() and flush(), a line splitter, a JSON-lines parser, objectMode on each side, PassThrough and pipelines of transforms.
  5. 38 pipeline and Backpressure Connect Node.js streams safely with stream.pipeline - error propagation, cleanup, backpressure explained with counters, the pitfalls of pipe(), and cancelling with AbortSignal.
  6. 39 Web Streams in Node.js Use the standard Web Streams API in Node.js - ReadableStream, WritableStream, TransformStream, CompressionStream, TextDecoderStream, fetch bodies and conversion to and from Node streams.
  7. 40 Stream Patterns and Recipes Practical Node.js stream recipes - async generators as transforms, stream.compose, batching, throttling, merging, splitting and processing a huge CSV with flat memory.

Asynchronous Programming

  1. 41 Callbacks and Error-First Style Understand Node.js callbacks and the error-first convention, escape callback hell, avoid the sync-or-async trap, and convert callback APIs with util.promisify and callbackify.
  2. 42 Promises in Depth Learn Node.js promises in depth - states, chaining, microtask timing, Promise.all, allSettled, race, any, withResolvers, unhandled rejections and promise-based core APIs.
  3. 43 async/await Patterns Master async/await in Node.js - sequential versus parallel awaits, try/catch, loops and forEach traps, top-level await, async stack traces and the mistakes that cause silent bugs.
  4. 44 Concurrency Control and Queues Control async concurrency in Node.js - limit parallel tasks with a semaphore or p-limit style pool, build a task queue, rate limit, retry with backoff and add timeouts with AbortSignal.timeout.
  5. 45 AbortController and Cancellation Cancel async work in Node.js with AbortController and AbortSignal - fetch, timers, fs, events and streams, AbortSignal.timeout and any, cancellable functions, cleanup and error names.
  6. 46 Async Iterators and Generators Learn async iterators in Node.js - for await...of, async generators, Symbol.asyncIterator, early exit and cleanup, events.on, readline lines and a paginated iterator.
  7. 47 AsyncLocalStorage and Context Learn AsyncLocalStorage in Node.js - run and getStore, request-scoped context, correlation IDs in logs, nested stores, snapshot and bind, pitfalls and a diagnostics_channel preview.

Networking and HTTP

  1. 48 TCP Servers and Clients with net Build TCP servers and clients with the Node.js net module - sockets as duplex streams, echo and chat servers, message framing, half-close, idle timeouts, keep-alive and error handling.
  2. 49 The http Module: Servers Build HTTP servers with the Node.js http module - createServer, request and response objects as streams, status codes, headers, reading bodies, streaming replies, timeouts and graceful shutdown.
  3. 50 HTTP Clients: fetch and http.request Make HTTP requests in Node.js with fetch and http.request - headers, JSON and form bodies, error handling, timeouts with AbortSignal, redirects, streaming, retries and keep-alive agents.
  4. 51 Building a Router from Scratch Build an HTTP router in Node.js with URLPattern - path parameters, query strings, method matching, 404 and 405 responses, route groups, composed handlers and error handling.
  5. 52 Request Bodies, JSON and Forms Learn how Node.js servers read request bodies - collecting stream chunks, size limits, JSON parse errors, URL-encoded forms, a hand-written multipart parser and content negotiation.
  6. 53 Headers, Cookies and Caching Use HTTP headers in Node.js - Set-Cookie attributes, parsing cookies, signed cookie sessions with crypto, CORS and preflight, ETag and 304 responses, Cache-Control and compression negotiation.
  7. 54 Middleware Pattern Understand the middleware pattern in Node.js - the next() chain, error-handling middleware, async handlers, the onion model - and build a working mini Express in about 60 lines.
  8. 55 Designing REST APIs Design clean REST APIs in Node.js - resources and verbs, status codes, validation, pagination, filtering, idempotency, versioning and RFC 9457 error responses, with a full in-memory CRUD example.
  9. 56 Server-Sent Events and Streaming Responses Stream data from a Node.js server with chunked responses and Server-Sent Events - the text/event-stream format, a fetch-based client, reconnection with Last-Event-ID, heartbeats and backpressure.
  10. 57 WebSockets Learn WebSockets in Node.js - the HTTP upgrade handshake and Sec-WebSocket-Accept, frame format, the built-in WebSocket client, a hand-written server, ping/pong, close codes, plus the ws library and Socket.IO.
  11. 58 UDP, DNS and Other Protocols Learn UDP datagrams with node:dgram, how DNS lookups really work in Node.js, IP address helpers, and when to use HTTP/2, TLS and HTTP/3, with runnable loopback examples.
  12. 59 File Uploads and Multipart Parsing Accept file uploads in Node.js safely - parse multipart bodies as a stream, enforce size and count limits, write to disk with backpressure, sanitize filenames and check file signatures.
  13. 60 OpenAPI and API Documentation Describe a REST API with an OpenAPI 3.1 document, reuse schemas with $ref, validate requests from the spec and serve interactive documentation from Node.js.

Processes and Threads

  1. 61 Child Processes Run other programs from Node.js with child_process. Learn spawn, exec, execFile and fork, stdio streams, exit codes, killing children, IPC messages and avoiding shell injection.
  2. 62 Worker Threads Use Node.js worker_threads to run CPU-heavy JavaScript in parallel. Learn Worker, workerData, messages, transferables, SharedArrayBuffer, Atomics, worker pools and when to choose them.
  3. 63 Cluster, Scaling and Load Balancing Scale Node.js beyond one CPU core. Learn the cluster module, round-robin balancing, sticky sessions, PM2, containers and why stateless, shared-nothing design makes horizontal scaling work.
  4. 64 Measuring Performance Measure Node.js performance with perf_hooks - performance.now, mark and measure, PerformanceObserver, timerify, event loop delay and utilization, plus benchmarking pitfalls and profilers.

Data and Storage

  1. 65 JSON and Data Handling Master JSON in Node.js - JSON.parse and stringify with reviver and replacer, BigInt and Date, structuredClone, JSON Lines, streaming large data, hand-written validation and common traps like NaN and undefined.
  2. 66 SQLite with node:sqlite Use the built-in node:sqlite module in Node.js 24 - DatabaseSync, prepared statements, parameters, transactions, custom functions, migrations and in-memory vs file databases.
  3. 67 CSV, Logs and Text Processing Parse CSV by hand with quotes and escapes, read big inputs with readline, extract data with regular expressions, aggregate logs and print aligned reports using Intl in Node.js.
  4. 68 Caching in Memory Build in-memory caches in Node.js - Map-based caches, TTL and LRU by hand, memoization, invalidation, stampede protection with shared promises, and WeakMap, WeakRef and FinalizationRegistry.
  5. 69 Databases from Node.js How Node.js talks to PostgreSQL, MySQL, MongoDB and Redis - drivers, connection pools, query builders and ORMs, transactions and migrations, with runnable SQLite equivalents.
  6. 70 MongoDB and Redis from Node.js Use MongoDB and Redis from Node.js - official driver patterns, one client per process, caching with TTL and cache-aside, stampede control, key design, and runnable stand-ins for the core ideas.
  7. 71 MongoDB with Mongoose: Schemas, Models, Queries and Populate Learn Mongoose, the Node.js ODM for MongoDB. Define schemas and models, validate data, query and populate references, use hooks and virtuals, and run a mini-Mongoose in the editor.
  8. 72 ORMs: Prisma and Sequelize Understand ORMs in Node.js - Prisma schemas and migrations, Sequelize models and associations, queries and relations, the N+1 trap, raw SQL and the trade-offs, with runnable stand-ins.

Security and Cryptography

  1. 73 Hashing and HMAC Learn hashing in Node.js with node:crypto - createHash, SHA-256 and SHA-3, digest encodings, HMAC signatures, timingSafeEqual, hashing files with streams and content addressing.
  2. 74 Randomness and Identifiers Generate secure randomness in Node.js with crypto.randomBytes, randomInt and randomUUID, know when Math.random is fine, seed repeatable generators, and build ULID and nanoid-style IDs.
  3. 75 Encryption: AES, RSA and Keys Learn Node.js encryption with the crypto module - AES-256-GCM authenticated encryption, nonces, key derivation, RSA and Ed25519 key pairs, signatures and the Web Crypto subtle API.
  4. 76 Passwords, scrypt and Tokens Store passwords safely in Node.js with scrypt, salts and timingSafeEqual, then build and verify a signed HS256 token by hand, with expiry, refresh tokens and session safety rules.
  5. 77 Web Application Security Learn the most common web vulnerabilities in Node.js apps - SQL injection, XSS, CSRF, SSRF, path traversal, prototype pollution and ReDoS - with runnable vulnerable and fixed code.
  6. 78 Configuration, Secrets and Environment Manage Node.js configuration the 12-factor way - process.env, --env-file, process.loadEnvFile and util.parseEnv, validation at startup, secret handling, redaction and feature flags.
  7. 79 Authentication: Sessions and JWT Build login in Node.js two ways - server-side cookie sessions and signed JWTs with node:crypto - then add refresh token rotation with reuse detection, and learn when to choose which.
  8. 80 Rate Limiting and API Protection Protect a Node.js API with a token bucket rate limiter, per-client limits, 429 and Retry-After responses, CORS rules and security headers, all built with plain node:http.

Compression, CLI and Tooling

  1. 81 Compression with zlib Learn Node.js compression with zlib - gzip, deflate and brotli in sync, async and streaming form, compression levels, CompressionStream, HTTP compression and protecting against zip bombs.
  2. 82 Interactive CLIs with readline Build interactive Node.js command-line programs with readline and readline/promises - prompts, reading stdin line by line, piped input, history, closing correctly and writing a small REPL.
  3. 83 Building Command-Line Tools Build command-line tools with Node.js - parseArgs, subcommands, help text, exit codes, stdout vs stderr, colors with styleText, shebang bin entries and testing a CLI by spawning node.
  4. 84 Intl, Dates and Formatting Format numbers, currencies, dates, plurals, lists and relative times in Node.js with Intl, choose locales and time zones explicitly, sort text correctly and avoid common Date pitfalls.
  5. 85 V8, Memory and Garbage Collection Understand how Node.js uses memory - V8 stack and heap, generational garbage collection, memoryUsage, common leaks, WeakRef and WeakMap, heap limits, snapshots and out-of-memory crashes.
  6. 86 Debugging and Diagnostics Debug Node.js programs - read stack traces and error.cause chains, use --inspect and debugger, util.debuglog, diagnostics_channel, process reports, source maps and async stack traces.
  7. 87 npm Workspaces and Monorepos Organize several Node.js packages in one repository with npm workspaces - layout, linking, running scripts, shared code, semver ranges, release planning and when to add Turborepo or Nx.

Frameworks and Ecosystem

  1. 88 Express and Minimal Frameworks Learn Express routing, middleware and error handling, run the same app on a hand-written mini-Express, compare Koa, Fastify and Hono, and choose a Node.js web framework with confidence.
  2. 89 Everyday Middleware - cors, helmet, morgan, compression and Body Parsers Learn what the five middleware packages almost every Express app installs actually do, run hand-written equivalents of each, and see why their order in the chain matters.
  3. 90 Template Engines: EJS and Server-Rendered Views Learn how template engines such as EJS turn data into HTML, what res.render does, how escaping prevents XSS, and run a 25-line EJS-style engine with includes and layouts.
  4. 91 Passport.js: Authentication Strategies for Express Learn how Passport.js separates authentication strategies from your routes, how serializeUser and sessions fit in, and run a mini-Passport with local and bearer-token strategies.
  5. 92 Validating Input Validate untrusted input in Node.js - hand-written checks, a small schema library, JSON Schema, zod and ajv, sanitizing, helpful error messages and checking environment config at startup.
  6. 93 Logging and Observability Learn Node.js logging and observability - structured JSON logs, levels, child loggers, correlation IDs with AsyncLocalStorage, metrics, health checks and tracing basics.
  7. 94 Project Structure and Architecture Learn how to structure a Node.js project - layers, feature folders, dependency injection, config, keeping HTTP separate from domain code, testing seams and monorepos.
  8. 95 Building and Bundling Learn when a Node.js project needs a build step - type stripping, tsc, esbuild, swc, tsup, how bundlers work, source maps, minification trade-offs and single executable apps.
  9. 96 Deploying Node.js Applications Learn how to deploy Node.js apps - twelve-factor config, Docker multi-stage builds, systemd and PM2, health checks, graceful shutdown, reverse proxies, serverless and zero-downtime releases.
  10. 97 Real-Time, Queues and the Wider Ecosystem Tour the wider Node.js ecosystem - job queues like BullMQ, message brokers, cron scheduling, WebSocket frameworks, GraphQL, gRPC, server-side rendering and Deno and Bun compared.
  11. 98 Sending Email with Nodemailer: SMTP, HTML Mail and Attachments Learn how Nodemailer sends email from Node.js, how SMTP and MIME work underneath, how to send HTML, attachments and retries safely, and watch a mail travel over a local SMTP server.
  12. 99 GraphQL Servers Learn how a GraphQL server works in Node.js - schema, queries, mutations, resolvers, partial errors, the N+1 problem and the DataLoader batching pattern, with a runnable hand-written mini server.

Testing

  1. 100 The Built-in Test Runner Learn the built-in Node.js test runner - test, describe and it, hooks, subtests, skip and todo, timeouts, reporters, running tests programmatically, coverage and watch mode.
  2. 101 The assert Module Learn the Node.js assert module - assert/strict, strictEqual, deepStrictEqual, throws, rejects, match, custom messages and how to read an AssertionError diff.
  3. 102 Mocks, Spies and Fake Timers Learn mocking in Node.js with node:test - mock.fn, mock.method, spies, fake timers with mock.timers, dependency injection and hand-written fakes.
  4. 103 Testing HTTP Servers and CLIs Learn to test Node.js HTTP servers on port 0 with fetch, test middleware in isolation, test command-line tools with child processes, and use fixtures and data builders.
  5. 104 Test-Driven Development Workshop Practice test-driven development in Node.js. Build a rate limiter with red-green-refactor cycles, injected clocks, edge cases and seeded property-style tests.
  6. 105 Testing with Jest, Mocha and Chai Learn how Jest and Mocha with Chai structure tests, what describe, it, expect, hooks and mock functions do, and map them to node:test with a runnable mini test framework.
  7. 106 Supertest and Sinon: Testing HTTP Routes and Stubbing Dependencies Learn how Supertest tests an HTTP app without opening a port by hand, how Sinon spies, stubs and fake timers isolate code, and run mini versions of both in the editor.

Production Node.js

  1. 107 Error Handling in Production Learn production error handling in Node.js - operational vs programmer errors, central handlers, uncaughtException policy, retries, circuit breakers and dead letter queues.
  2. 108 Graceful Shutdown and Health Checks Learn graceful shutdown in Node.js - handle SIGTERM, drain HTTP connections, close resources in order, set shutdown timeouts, and design liveness and readiness checks.
  3. 109 Processing Large Data Efficiently Process big files and datasets in Node.js without running out of memory - streaming vs buffering, backpressure, batching database writes, worker pools and resumable jobs.
  4. 110 Scalability and Reliability Patterns Build Node.js services that scale and survive failure - stateless design, caching with single-flight, token bucket rate limiting, idempotency keys, timeouts, load shedding and queues.
  5. 111 Performance Tuning Make Node.js code faster the right way - keep the event loop free, avoid sync I/O and JSON waste, stop regex ReDoS, benchmark honestly, avoid V8 traps and profile with real tools.
  6. 112 Microservices and Message Queues Learn service boundaries, message queues, at-least-once delivery, retries with backoff, dead-letter queues and idempotent consumers, with runnable Node.js examples.
  7. 113 Node.js in Docker and CI Package a Node.js app in a small, secure Docker image with multi-stage builds, add a health endpoint, and run tests and builds in a CI pipeline with caching.

Projects

  1. 114 Project: Command-Line To-Do App Build a complete command-line to-do app in Node.js step by step - parse arguments with util.parseArgs, store tasks in a JSON file, add commands, handle errors and test it with node:test.
  2. 115 Project: URL Shortener Build a URL shortener in Node.js with the built-in http server and node:sqlite - base62 ids, URL validation, redirects, click counts, error handling and tests against a loopback server.
  3. 116 Project: A REST API from Scratch Build a complete REST API in Node.js without a framework - a router with URLPattern, middleware, validation, pagination, error handling and a repository you can swap from memory to SQLite.
  4. 117 Project: Real-Time Chat Server Build a multi-room chat server in Node.js with the net module. Line protocol, nicknames, rooms, history, slow-client protection and loopback clients, built in stages and tested.
  5. 118 Project: Streaming Log Processor Build a log analyzer in Node.js that reads huge files with streams in constant memory. Parse, aggregate, report, handle bad lines and errors, add gzip, tested with a seeded generator.
  6. 119 Project: Background Job Queue Build a persistent job queue in Node.js with node:sqlite and worker threads. Atomic claims, retries with backoff, dead jobs, crash recovery with leases and graceful shutdown.
  7. 120 Project: Directory Snapshot and Diff Tool Build a tool that snapshots a folder with SHA-256 hashes, finds added, changed, moved and deleted files, speeds up rescans with a quick check, and syncs a mirror safely.
  8. 121 Project: URL Monitoring Service Build an uptime monitor in Node.js. Scheduled HTTP checks with timeouts, status history, uptime percentages and alerts that fire on state changes without flapping.
  9. 122 Project: Real-Time Polling and Auction Build live polls and a bidding auction in Node.js. Pure rule classes, a WebSocket hub that broadcasts every change to all viewers, anti-sniping time extension and clean validation.
  10. 123 Project: Blog and Social API with Auth Build a blog and social API in Node.js with node:sqlite. Registration with scrypt, JWT login, posts, follows, a personal feed and cursor pagination, tested end to end with fetch.
  11. 124 Project: Payment Integration with Webhooks Build a payment flow in Node.js with a stand-in provider. Checkout sessions, signed webhooks verified against the raw body, replay protection, retries and idempotent order updates.
  12. 125 Project: Email and Notification Service Build a notification service in Node.js. Safe templates with HTML escaping, user preferences, multiple channels, a delivery queue with exponential backoff, dead letters and de-duplication.
  13. 126 Project: Cron-Style Task Scheduler Build a cron-style scheduler in Node.js. Parse five-field cron expressions, compute the next run, chain timers past the 24-day limit, prevent overlap and recover missed runs after a restart.
  14. 127 Project: File Sharing Platform Build a file sharing service in Node.js. Stream uploads to disk with size limits and hashing, issue unguessable expiring links, limit downloads and stream files back with Range support.
  15. 128 Project: Online Code Runner with child_process Build a code runner in Node.js with child_process. Run untrusted code with timeouts, output caps, the permission model and a job queue, and learn honestly where child processes stop being a sandbox.
  16. 129 Project: Document and Report Generator Build a report generator in Node.js. Parse CSV, summarize data, render HTML with an SVG chart, export safe CSV, write a valid PDF by hand and stream huge reports with constant memory.

Practice and Review

  1. 130 Node.js Cheat Sheet A practical Node.js 24 cheat sheet with runnable recipes for core modules, the event loop order, files and streams, HTTP, async patterns, error codes and common commands.
  2. 131 Practice Problems: Core Node 16 graded Node.js exercises with hints and verified solutions on paths, URLs, modules, files, events, buffers and timers. Run each one in your browser and compare.
  3. 132 Practice Problems: Streams, HTTP and Concurrency Fifteen graded Node.js problems on streams, HTTP servers and clients, and concurrency, each with a hint and a complete solution you can run and change in your browser.
  4. 133 Node.js Interview Questions and Answers 49 Node.js interview questions with short answers and code: event loop, streams, modules, async, scaling, security and performance, plus code-reading puzzles.