[ 01 ]
Free reader
Read online
The full book stays free online. No account, no paywall, no drip-feed.
Start readingMASTER THE
NODE.JS
INTERNALS
Volume I is complete. The Digital Bundle includes the EPUB, light PDF, dark PDF, slides, and cheatsheets. NodeBook is completely free to read online!
Author: Ishtmeet Singh
NodeBook overview
NodeBook curriculum
Advanced Node.js internals
_
[ Study System ]
READ. STUDY. BUILD.
[ 02 ]
Digital Bundle
Study offline
Get the EPUB, light/dark PDFs, visual slides, and cheatsheets.
Get Digital Bundle[ 03 ]
Node 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
Ch 01: Node.js Architecture
Ch 02: Buffers & Binary Data
Ch 03: Streams
Ch 04: File System
Ch 05: Process & Operating System
Ch 06: The Module System
Ch 07: Async Patterns & Control Flow
Ch 08: Runtime Platform APIs & Tooling
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.
Free online access
Knowledge should be free.
NodeBook is free to read online. Paid options add the Volume I offline bundle or Node Runtime Labs.
Free online access
Live Reader
The entire book, available online forever. No paywalls, no ads, no trackers.
$0
- Full access to every published chapter
- Interactive code examples
- Dark and light reading modes
- Global search
- Reader discussion
Available now
Downloadable study files
Digital Bundle
Own the offline files for Volume I: Runtime Foundations, plus the slides and cheatsheets.
$19.99$49.99
- Volume I EPUB
- Light PDF
- Dark PDF
- Visual slides
- Cheatsheets
- Future updates
- Lifetime access
Does not include Node Runtime Labs.
Labs bundle
NodeBook Labs
Node Runtime Labs
Build runtime concepts through paid phase-based Markdown labs with checkpoints, hints, debugging notes, and expected output.
$39.99$79.99
- Seven included runtime lab projects
- Three more labs upcoming
- Phase-by-phase build instructions
- Checkpoints, hints, and rubrics
- Debugging notes and expected output
- Future lab updates
- Lifetime access to purchased files
Does not include EPUB, PDFs, slides, or cheatsheets.
Volume I is complete online. Paid products are available from /get.
Resources
and downloads
Volume I EPUB, light and dark PDFs, slides, and cheatsheets are included in the paid Digital Bundle.
Get Digital BundleVolume 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
70,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.