DEVPREP CODEX · #14

Node.js Interview Questions

171 curated questions graded from Foundations (Easy) to Practical Patterns (Medium) and Internals & Architecture (Hard).

TOTAL QUESTIONS

171

THEORY QUESTIONS

150

IMPLEMENTATION FOLIOS

FREE QUESTIONS

5 / Level

Easy Level·57 Questions Total

Foundations & Core Concepts

Open Full Easy List

Q1What is Node.js and what is its primary use case?

Definition: Node.js is an open-source, cross-platform JavaScript runtime environment built on Google Chrome's V8 engine.
Primary Use Case: Building fast, scalable network applications, real-time communication tools (WebSockets, chat), REST APIs, and microservices.
Architecture: Uses a single-threaded, event-driven, and non-blocking I/O model to achieve high concurrency without the overhead of thread context-switching.

Q2How does Node.js handle concurrency if it runs on a single thread?

Single Thread: JavaScript code executes on a single main thread (the call stack).
Asynchronous Delegation: When an asynchronous, blocking operation (e.g., file system access, network requests, database queries) is encountered, Node.js delegates it to the OS kernel or the Libuv thread pool.
Callbacks/Events: Once the delegated operation completes, the result is queued as a callback in the Event Loop, which executes it when the call stack becomes empty.

Q3What is the V8 engine and how does Node.js leverage it?

Definition: V8 is Google's high-performance, open-source JavaScript engine written in C++.
JIT Compilation: V8 compiles JavaScript directly to native machine code before executing it, bypassing intermediate bytecode interpretation.
Role in Node: V8 manages memory allocation, provides call stack execution, and performs garbage collection. Node.js adds binding APIs (C++ bindings) to allow JavaScript to interact with OS-level components like files and networks.

Q4What is Libuv and why is it crucial to Node.js?

Definition: Libuv is a multi-platform support library written in C, specifically designed for Node.js to handle asynchronous I/O.
Core Responsibilities:
- Implements the Event Loop.
- Manages the internal Thread Pool (usually 4 threads by default) for blocking tasks.
- Abstracts OS-specific asynchronous mechanisms like epoll (Linux), kqueue (macOS), and IOCP (Windows).

Q5What is the Event Loop in Node.js?

Purpose: The event loop is the mechanism that allows Node.js to perform non-blocking I/O operations despite being single-threaded.
Mechanism: It continuously polls the operating system and task queues, pushing completed asynchronous callbacks onto the call stack for execution.
Loop Cycle: If there are no active connections, timers, or pending operations, the event loop terminates.

52 More Easy Questions Locked

Unlock the complete Node.js Easy question bank

Get instant access to all 57 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Medium Level·57 Questions Total

Mechanisms & Practical Patterns

Open Full Medium List

Q1Compare Node's Event-Driven architecture with standard multi-threaded architectures.

Multi-threaded (e.g., Tomcat/Java): Allocates a dedicated OS thread per incoming connection. If the thread blocks on database I/O, OS context switches occur, consuming substantial memory (1MB+ per stack) and CPU cycles.
Event-Driven (Node.js): Runs on a single main thread using non-blocking system calls. A single process can handle tens of thousands of idle/active connections concurrently because it only executes memory/CPU resources when events occur.

Q2What is the V8 engine's Heap memory structure?

Young Generation (New Space): Short-lived objects. Divided into two semi-spaces: To and From. Garbage collection (GC) here is extremely fast (Scavenger).
Old Generation (Old Space): Long-lived objects that survived multiple GC runs in the Young Space. Managed by Mark-Sweep-Compact GC algorithm.
Large Object Space: Objects exceeding memory limits of other spaces.
Code Space: JIT-compiled native code vectors.
Map Space: Contains "hidden classes" (shapes) of objects.

Q3How do you configure and debug V8 heap size limits?

Argument: Use --max-old-space-size to specify heap limit in megabytes.
Example: node --max-old-space-size=4096 app.js (allocates 4GB instead of V8's default 1.4GB on 64-bit systems).
Usage: Critical when processing large files, in-memory caches, or running on resource-constrained containers (Docker).

Q4Distinguish between CPU-bound and I/O-bound operations.

I/O-bound: Spend most of the execution time waiting for input/output resources (network sockets, database queries, disk reads). Highly optimized in Node.js via non-blocking delegation.
CPU-bound: Spend most of the time executing instructions on the processor (cryptographic hashing, video processing, heavy calculations). These block Node's single-threaded event loop.

Q5How do Worker Threads solve the CPU-bound task bottleneck?

Concept: The worker_threads module allows running CPU-intensive JavaScript execution in separate OS threads.
Heap Structure: Each worker has its own isolated V8 engine instance and call stack, but they can share memory directly using SharedArrayBuffer (unlike child processes).
Communication: Workers communicate with the parent thread via message channels (MessagePort).

52 More Medium Questions Locked

Unlock the complete Node.js Medium question bank

Get instant access to all 57 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Hard Level·57 Questions Total

Internals & System Architecture

Open Full Hard List

Q1Detail the internal C++ architecture of Node.js and its binding integration.

Architecture Layers: JavaScript Application $\rightarrow$ Node.js C++ Standard Library Bindings $\rightarrow$ V8 Engine $\rightarrow$ Libuv Platform Library.
Bindings: Node.js uses node-addon-api or internal C++ macros (e.g., NODE_MODULE) to bind C++ classes to JavaScript objects.
Execution Flow: JavaScript calls a native method (e.g., fs.open). V8 maps this to a registered C++ binding function. The C++ binding invokes Libuv's non-blocking API, which executes the request and posts the callback when finished.

Q2Explain the V8 compiler pipeline (Ignition, Sparkplug, Maglev, Turbofan).

Ignition: The interpreter. It compiles JavaScript code into bytecode and profiles it to identify "hot" (frequently executed) functions.
Sparkplug: A non-optimizing, fast compiler that converts bytecode directly into native machine code.
Maglev: A mid-tier optimizing compiler that creates a medium-level SSA representation of hot code.
Turbofan: The high-level optimizing compiler. It takes hot bytecode and compile-time profiling data, makes aggressive optimizations (like inlining and loop peeling), and produces highly optimized machine code. If assumptions fail, it deoptimizes back to Ignition.

Q3Deep dive into the Libuv event loop integration with V8.

State Machine: Libuv runs inside a blocking loop uv_run(). It relies on system calls like epoll/kqueue to wait for descriptors to become active.
V8 Integration: When a descriptor becomes ready, Libuv calls the associated C++ callback. The C++ binding transitions context into V8, sets up a V8 execution context, and executes the compiled JavaScript callback on the V8 call stack.

Q4Explain the differences and priority between Microtasks and Macrotasks.

Microtask Queue: Contains promises (resolved .then()) and callbacks scheduled by queueMicrotask() or process.nextTick().
Macrotask Queue: Contains callbacks from timers (setTimeout, setImmediate) and I/O handlers.
Priority Rule: Microtasks run with absolute priority. Between each stage of the event loop and after every individual macrotask callback, the event loop must fully drain the entire microtask queue before continuing.

Q5How does memory allocation work in V8, especially for Buffers?

V8 Heap Memory: Limited in size (configured via --max-old-space-size). Contains execution structures, JS objects, and strings.
External Allocations (Buffers): Modern Node.js allocates Buffer payloads directly in raw system memory outside the V8 heap (C++ heap) using malloc(). This avoids V8 garbage collection overhead and allows swapping blocks without heap context copying.

52 More Hard Questions Locked