Free reader
Read online
The full book stays free online. No account, no paywall, no drip-feed.
Start readingNodeBookFree Node.js internals book
Read the full online guide for free. Get EPUB, PDFs, slides, cheatsheets, and Node Runtime Labs when you want offline study or hands-on builds.
NodeBook companionReading workspace
Current pathPick up where the runtime gets tricky.Chapter context, practice, and review material stay one click away.
ContinueRuntime architecture
Return to the next unread subchapter.
PracticeMatching lab
Open the runnable exercise when the concept clicks.
[ Study System ]
READ. STUDY. BUILD.
Digital Bundle
Study offline
Get the EPUB, light/dark PDFs, visual slides, and cheatsheets.
Get Digital BundleNode Runtime Labs
Build the labs
Work through paid phase-based labs that turn Node internals into working tools.
View study optionsWhy NodeBook
Understand Node.js
at runtime.
NodeBook explains what happens inside the runtime when your application handles I/O, schedules work, allocates memory, and serves traffic.
01
Libuv & Event Loop Internals
Understand poll/check/idle phases, threadpool queueing, and platform differences across epoll, kqueue, and IOCP.
02
V8 Compilation Pipeline
Debug deoptimizations, hidden class transitions, and polymorphic inline cache misses with practical examples.
03
Zero-Copy Stream Architecture
Implement binary protocols with backpressure-aware transforms, scatter/gather I/O, and external memory management.
04
Native Addon Development
Build thread-safe N-API modules, move work through uv_queue_work, and handle memory across JavaScript and C++ boundaries.
05
Production Observability
Propagate trace context with AsyncLocalStorage, control metrics cardinality, and analyze latency with flamegraphs.
06
Production Memory Management
Tune generational GC flags, track retainers in heap snapshots, handle external memory pressure and OOM mitigation.
Understand
the mechanism.
Most Node.js tutorials stop at syntax. NodeBook focuses on runtime behavior. This example shows how backpressure changes memory use under load.
The problem: unbounded buffering
Buffering an entire file before sending it can exhaust the V8 heap under concurrent traffic.
The fix: stream backpressure
Read in chunks, respect `highWaterMark`, and pause the readable stream when the writable side applies pressure.
const fs = require('fs');const http = require('http'); http.createServer((req, res) => { // Problem: // fs.readFile buffers the entire file content into V8 heap. // If 'big_data.csv' is 2GB and you have 50 concurrent requests, // your process crashes immediately with heap out of memory. fs.readFile('./big_data.csv', (err, data) => { if (err) throw err; res.end(data); }); }).listen(3000); // Status: Process terminated.// Reason: JavaScript heap out of memoryHeap pressureLn 14, Col 22
Curriculum overview
Table of
Contents
35 chapters planned
205 subchapters across 7 volumes
205 subchapters across 7 volumes
Included Material
- [x]205 Subchapters
- [x]Volume I complete online
- [x]Volume I Digital Bundle available now
- [x]Networking chapter ready
For experienced developers
This curriculum assumes you already write JavaScript regularly. It focuses on runtime behavior, operational tradeoffs, and the details that matter when Node.js runs in production.
Audience fit
Who this
is for
NodeBook is written for developers who already build with Node.js and want a deeper operating model.
Current focus
Application developer
Common gaps
- [-]Uses frameworks well, but has limited runtime visibility
- [-]Finds memory leaks late, often after production symptoms
- [-]Handles large payloads without always measuring allocation cost
- [-]Needs clearer tools for profiling, backpressure, and shutdown behavior
Intended outcome
Runtime-focused engineer
Production practice
- [+]Profiles V8 heap snapshots and allocation paths
- [+]Implements backpressure with streams
- [+]Moves CPU-bound work to Worker Threads when needed
- [+]Operates Node.js services with clear deployment and scaling tradeoffs
New chapters and release notes, sent when they are published.
Phase 2 in progress
Publication
roadmap
Updated as chapters are published
Online chapters remain free
Volume I bundle available now
Complete
VOL I: Runtime Foundations
- Architecture Done
- Buffers Done
- Streams Done
- File System Done
- Process & OS Done
- Modules Done
- Async Patterns Done
- Runtime Platform Done
Complete online. Digital Bundle available now.
In progress
VOL II: Networked APIs
- Networking Ready
- HTTP Next
- TLS / HTTP/2 Pending
- API Design Pending
- Realtime APIs Pending
Available now
VOL I DIGITAL BUNDLE
Volume I EPUB, light PDF, dark PDF, slides, and cheatsheets are available through /get.
Paid download through Polar
Planned
LATER VOLUMES
Work execution, data, security, production engineering, and platform architecture follow the networked APIs volume.
Schedule to be announced
Current progress
Volume I is complete online.
Examples and diagrams are included with relevant chapters.
Digital Bundle is available through /get.
Volume II starts with the ready networking chapter.
Phase 2 is now focused on HTTP, TLS, APIs, and realtime systems.
Dates may move as chapters are revised and fact-checked.
Subscribe to get release emails when new material is published.
Choose your NodeBook package.
Switch between one-reader pricing and team licenses for up to 25 team members.
Individual pricing is for one reader and one personal purchase record.TEAM LICENSES INCLUDE UP TO 25 MEMBERS. DOWNLOADED CONTENT MAY BE
SHARED INTERNALLY WITH UP TO 30 PEOPLE TOTAL.
SHARED INTERNALLY WITH UP TO 30 PEOPLE TOTAL.
Downloadable book bundle
Digital Bundle
Volume I as EPUB, light/dark PDFs, slides, cheatsheets, and future updates.
$19.99$49.99
One-time purchase- Volume I EPUB for offline reading
- Light and dark PDF editions
- Slide decks for chapter review
- Cheatsheets for quick lookup
- Future Digital Bundle updates
- Lifetime access to the files
This is the downloadable Volume I study bundle. It does not include Node Runtime Labs.
Best value
Everything together
NodeBook Pro
All Labs plus the downloadable Volume I bundle in one purchase. Save $9.99 vs buying separately.
$49.99$99.99
One-time purchaseNode Runtime Labs+Digital Bundle
- Everything in Node Runtime Labs
- Everything in the Digital Bundle
- Seven included lab projects
- Three upcoming labs when released
- Future updates for both products
- Lifetime access to purchased files
This includes both paid products: Node Runtime Labs and the Digital Bundle.
Premium labs
Complex runtime projects
Node Runtime Labs
Seven long-form builds: recorder, binary store, stream workbench, resolver, watcher, task runtime, and protocol gateway.
$39.99$79.99
One-time purchase- Node Runtime Flight Recorder
- Binary File Store / Append-Only Log Database
- Stream Processing Workbench
- Module Resolution Inspector
- Atomic File Watcher + Incremental Build Cache
- Async Task Runtime / Local Job Orchestrator
- Custom Binary Protocol Gateway
- Three more labs upcoming
This is the paid labs bundle. It does not include EPUB, PDFs, slides, or cheatsheets.
Team downloadable files
Digital Bundle Team
Volume I files, slides, cheatsheets, and updates for a small engineering team.
$59.99
One-time team license- Everything in the Digital Bundle
- Supports up to 25 team members
- Share internally with up to 30 people
- Single purchase for the team
- Future Digital Bundle updates
- Lifetime access to purchased files
Covers up to 25 team members and internal sharing with up to 30 people.
Team value
Everything for the team
NodeBook Pro Team
Node Runtime Labs plus the downloadable Volume I bundle in one team license.
$149.99
One-time team licenseNode Runtime Labs+Digital Bundle
- Everything in NodeBook Pro
- Supports up to 25 team members
- Share internally with up to 30 people
- One receipt and license record
- Future updates for both products
- Save $29.99 vs team products separately.
Covers up to 25 team members and internal sharing with up to 30 people.
Team labs
Runtime training projects
Node Runtime Labs Team
Seven long-form builds for onboarding, study groups, and internal training.
$119.99
One-time team license- Node Runtime Flight Recorder
- Binary File Store / Append-Only Log Database
- Stream Processing Workbench
- Module Resolution Inspector
- Supports up to 25 team members
- Share internally with up to 30 people
- Three more labs upcoming
Covers up to 25 team members and internal sharing with up to 30 people.
Resources
and downloads
Volume I includes 46 subchapters across 9 chapters. Formats: EPUB, light PDF, dark PDF, slides, cheatsheets.
Volume I EPUB
.epub · Volume I
Light PDF
.pdf · light theme
Dark PDF
.pdf · dark theme
Visual slides
.pdf · .html
Cheatsheets
.pdf · 32 sheets
Reader feedback
Early notes
Confirmed testimonials will be added as the project grows.
To: Ishtmeet
Recent
From: Early reader
Subject: Thanks for making this free
Just wanted to say thank you for keeping this resource free and accessible. Not everyone can afford expensive courses, and this really helps people like me who are trying to learn on a budget.
To: Ishtmeet
Yesterday
From: Backend developer
Subject: Re: Node internals
I've been looking for something that actually explains how Node works under the hood, not just how to use it. This is exactly what I needed. Appreciate you putting this together and sharing it with everyone.
To: Ishtmeet
Recent
From: JavaScript developer
Subject: Quick thanks
Finally a resource that doesn't assume I already know everything. The explanations are clear and the examples actually make sense. Thanks for taking the time to write this up.
Ishtmeet SinghAuthor
Consulting
Ishtmeet Singh
Node.js Developer Since 2014
10+ Years Node Experience
79,000+ Readers
Open Source Contributor
About the author
I've worked with Node.js since 2014, building real-time applications, backend services, and performance-sensitive systems that need clear operational behavior.
Many developers use Node.js every day, then get stuck when performance bottlenecks, memory growth, or scaling issues show up in production. My work in Rust and C++ changed how I read Node.js internals, and that systems perspective shapes this guide.
NodeBook comes from years of reading runtime behavior, debugging production issues, and documenting the details that usually stay scattered across source code, docs, talks, and incident notes.
[i]
I've always believed that knowledge should be accessible, which is why NodeBook is completely free to read online.