1. Introduction 👋

Understanding how Node.js works under the hood — its architecture, event loop, memory model, and module system — turns you from someone who writes Node.js code into someone who can reason about its behavior under load, debug subtle bugs, and make informed performance decisions. This tutorial goes deep into the internals that power every Node.js application.

2. Node.js Architecture 🏛️

Node.js combines several distinct components into a single runtime, each with a specific responsibility.

3. V8 JavaScript Engine 🔧

V8, developed by Google, compiles and executes JavaScript. It handles parsing, just-in-time (JIT) compilation, and memory management for JS objects.

4. libuv 🌀

libuv is the C library that gives Node.js its cross-platform, asynchronous I/O capabilities — including the event loop itself, file system access, networking, and the thread pool.

5. Event Loop Internals 🔁

The event loop is the mechanism that lets Node.js perform non-blocking I/O despite JavaScript being single-threaded. It cycles through distinct phases, each with its own callback queue.

6. Call Stack 📚

The call stack tracks function execution — each function call pushes a new frame, and returning pops it off. JavaScript's single-threaded nature means only one frame executes at a time.

function a() { b(); }
function b() { c(); }
function c() { console.log("deepest frame"); }

a(); // Stack: a → b → c → (pop c) → (pop b) → (pop a)

7. Microtask Queue ⚡

Microtasks — Promise callbacks and process.nextTick — run before the event loop proceeds to its next phase, giving them higher priority than macrotasks.

console.log("1: sync");

process.nextTick(() => console.log("2: nextTick"));
Promise.resolve().then(() => console.log("3: promise"));

console.log("4: sync");

// Output order: 1, 4, 2, 3
// nextTick queue is always drained before the Promise microtask queue

8. Macrotask Queue 🕒

Macrotasks include timers (setTimeout, setInterval), I/O callbacks, and setImmediate — each tied to a specific event loop phase.

setTimeout(() => console.log("timeout"), 0);
setImmediate(() => console.log("immediate"));

// Order is NOT guaranteed at the top level — depends on process startup timing.
// Inside an I/O callback, "immediate" always fires before "timeout".

9. Thread Pool 🧵

Certain operations — file system access, DNS lookups, some crypto functions — are offloaded to a background thread pool managed by libuv, since the OS can't always make them async natively.

UV_THREADPOOL_SIZE=8 node index.js

10. Non-Blocking I/O 🌊

Non-blocking I/O means the process issues an I/O request and immediately continues executing other code, receiving a callback (or resolved Promise) once the operation completes.

11. Module Loading System 📦

Node.js supports two module systems — CommonJS and ES Modules — each with a distinct loading algorithm.

12. CommonJS Loader ⚙️

When require() is called, Node wraps the module's code in a function, executes it synchronously, and caches the resulting exports object.

(function (exports, require, module, __filename, __dirname) {
  // your module code runs here
  module.exports = { hello: () => "hi" };
});

13. ES Module Loader 📥

ESM resolves and loads all imports before executing any module code, enabling static analysis, tree-shaking, and top-level await.

import { readFile } from "node:fs/promises";

// ✅ Top-level await is valid in ES Modules
const config = JSON.parse(await readFile("./config.json", "utf-8"));

14. Package Resolution 🔎

When resolving a bare specifier like import "lodash", Node walks up the directory tree looking for a matching node_modules folder.

15. Memory Management 💾

V8 divides memory into distinct regions, each managed differently for efficiency.

16. Garbage Collection 🗑️

V8 uses a generational garbage collector, based on the observation that most objects die young.

17. Buffers Internals 🧵

Buffer objects represent raw binary data, allocated outside V8's JS heap in a fixed-size memory pool for efficiency.

const buf = Buffer.from("hello", "utf-8");
console.log(buf); // <Buffer 68 65 6c 6c 6f>
console.log(buf.byteLength); // 5, raw byte length, not string length

18. Streams Internals 🌊

Streams process data incrementally using internal buffering and backpressure to avoid overwhelming slower consumers.

const readable = createReadStream("big-file.log");
const writable = createWriteStream("output.log");

readable.on("data", (chunk) => {
  const canContinue = writable.write(chunk);
  if (!canContinue) {
    readable.pause(); // backpressure: writable's buffer is full
    writable.once("drain", () => readable.resume());
  }
});

19. Networking Internals 🌐

Node's networking stack relies on the operating system's native async I/O facilities (epoll, kqueue, IOCP) rather than the thread pool, making it highly scalable for concurrent connections.

20. Worker Threads Internals 🧵

Worker threads run genuinely parallel JavaScript execution contexts, each with its own V8 isolate, event loop, and memory space.

import { Worker, isMainThread, parentPort } from "node:worker_threads";

if (isMainThread) {
  const worker = new Worker(__filename);
  worker.on("message", (msg) => console.log("From worker:", msg));
} else {
  parentPort?.postMessage("Hello from a separate V8 isolate!");
}

21. Child Process Internals ⚙️

Unlike worker threads, child processes are entirely separate OS processes with their own memory space, communicating via IPC (Inter-Process Communication) channels.

import { fork } from "node:child_process";

const child = fork("./worker-script.js");
child.send({ task: "process-data" });
child.on("message", (result) => console.log("Result:", result));

22. Runtime Lifecycle 🔄

A Node.js process moves through distinct lifecycle stages from launch to exit, each with hooks you can tap into.

23. Startup Process 🌱

On startup, Node.js initializes its internal bindings before your application code runs a single line.

24. Shutdown Process 🚪

A process exits naturally once the event loop has no more pending timers, I/O, or callbacks — or it can be terminated explicitly via a signal.

process.on("beforeExit", (code) => {
  console.log("Event loop empty, about to exit with code:", code);
});

process.on("exit", (code) => {
  console.log("Process exiting synchronously with code:", code);
  // No async operations can be scheduled here
});

25. Performance Internals ⚡

Several internal V8 and Node behaviors directly affect measured performance in subtle ways.

26. Debugging Internals 🐞

Node exposes a built-in inspector protocol compatible with Chrome DevTools, letting you debug internals directly.

node --inspect-brk src/index.js

27. Best Practices ✅

28. Common Misconceptions ❌

29. Frequently Asked Questions ❓

30. Summary 📋

Node.js internals combine V8 for JavaScript execution, libuv for asynchronous I/O and the event loop, and a thin C++ binding layer connecting them to JavaScript APIs. Understanding the event loop's phases, the microtask/macrotask distinction, memory management, and module loading gives you the tools to write faster, more predictable Node.js applications.