Inside Node.js Memory: Stack, Heap, and How V8 Thinks About Variables

When people say “JavaScript is simple”, they usually mean the syntax. But ask them where a variable actually lives in memory, and you’ll likely get a blank stare.

Under the hood, Node.js powered by Google’s V8 engine is doing some very non-simple things with memory. Understanding where data lives (stack vs heap) gives you a sharper mental model for performance, bugs, and why certain patterns behave the way they do.

Node.js Memory at a High Level

V8 organizes memory into multiple regions, each designed for a specific responsibility. One of these regions is responsible for tracking execution which function is running, what values it owns, and where control should return next.

That region is the stack.

Understanding the stack gives you clarity on how JavaScript code actually runs, line by line, function by function.

What Is the Stack?

The stack is a fixed-size, ordered region of memory. It stores data that is:

• Short-lived (exists only during function execution)
• Fixed in size (known at compile time)
• Automatically managed (no manual cleanup needed)

What the Stack Stores

The stack typically contains:

• Primitive values
• Function call frames
• Local variables (primitives and references)
• Return addresses

Every time a function is called, a stack frame is created. When the function returns, that frame is popped off the stack.

This makes stack allocation:

• Very fast
• Automatically cleaned up
• Strictly ordered (Last In, First Out)

Primitive Values and the Stack

Primitive values have a fixed and predictable size, which makes them ideal for stack storage.

JavaScript primitives include:

• number
• boolean
• undefined
• null
• symbol
• bigint

Example:

let count = 10;
let isActive = false;
let score = 42;

All of these values live directly inside the stack frame of the function in which they are declared.

No delayed cleanup. No lifecycle management. No complexity. When the function ends, they disappear.

But how does the stack know when a function ends? That’s where stack frames come in.

Stack Frames: The Core Unit

Each function invocation creates a stack frame.

A stack frame contains:

• Function parameters
• Local variables
• Temporary values
• The return address (where execution resumes afterward)

Example:

function multiply(a, b) {
  let result = a * b;
  return result;
}

multiply(3, 4);

Execution flow:

1. multiply is called
2. A stack frame is pushed
3. a, b, and result live inside that frame
4. The function returns
5. The frame is popped off the stack

Once removed, that frame is gone completely.

References on the Stack

When you declare a variable that points to something larger or dynamic, the stack stores only a reference.

let user = { id: 1 };

Here:

• user lives in the stack frame
• The stack stores an address, not the actual structure

This distinction becomes critical later when talking about mutations, closures, and memory retention, but for now, remember this rule:

The stack stores values directly if they’re simple (like primitives or small, fixed-size data), and stores references (addresses) if they’re not (like objects or arrays).

Function Calls and Nested Execution

Consider nested calls:

function a() {
  b();
}

function b() {
  c();
}

function c() {
  // work
}

a();

Stack behavior:

• a() → frame pushed
• b() → frame pushed
• c() → frame pushed
• c() returns → frame popped
• b() returns → frame popped
• a() returns → frame popped

This strict ordering is why JavaScript execution is deterministic and traceable.

Why Stack Overflow Happens

The stack is limited in size.

When too many frames are pushed without returning, usually due to deep or infinite recursion, you get:

RangeError: Maximum call stack size exceeded

Each function call consumes stack space. If frames accumulate faster than they unwind, the stack runs out of room.

This is not a memory leak. It’s a structural limit.

Why the Stack Is So Fast

Compared to other memory regions, the stack is blazingly fast. Here’s why:

• Memory layout is contiguous
• Allocation is just pointer movement
• Deallocation is automatic
• No garbage collection is involved

This is why execution-heavy logic, arithmetic, and tight loops feel instantaneous in Node.js.

---

Think of the stack as the conductor of execution. It doesn’t care about long-term storage or persistence. It cares about now, the current function, the current values, the next instruction.

But we’ve been dancing around a question: if primitives live on the stack, where do those references actually point? Where do objects, arrays, and strings live? How long do they survive? And who cleans them up?

That’s the heap’s job—and that’s exactly what we cover in Inside the Heap: Where JavaScript Stores Everything That Matters.