Top 30 Nodejs Interview Questions and Answers

30 questions. Pick an answer, or open “Show the answer” to read it.

Answers are graded in your browser. Nothing is saved, and no XP or streak is earned here. The app keeps score.

1. Question 1 of 30

   Which statement best describes how Node.js handles I/O for thousands of concurrent connections?

   • aNetwork sockets are watched by the OS, while blocking tasks like DNS and file reads use a small internal thread pool.
   • bIt spawns a new OS thread for every incoming connection to process requests in parallel.
   • cAll I/O operations, including file reads and DNS lookups, are handled directly by the event loop without blocking.
   • dThe event loop busy-waits in a while loop, polling each file descriptor until data is available.
   Show the answer

   Answer: a · Network sockets are watched by the OS, while blocking tasks like DNS and file reads use a small internal thread pool.

   Node.js relies on the OS kernel to monitor network sockets and notify the event loop when data arrives, while delegating blocking operations like DNS and some file system work to a limited internal thread pool. Distractor D is tempting because Node is famous for non-blocking I/O, but it wrongly assumes every I/O operation can run without thread assistance.

   Read the full bite: How does Node.js handle thousands of connections on one thread?

2. Question 2 of 30

   What is the primary function of the V8 engine within environments like Chrome or Node.js?

   • aTo store and retrieve data efficiently from databases or local storage.
   • bTo manage the graphical user interface and render web page elements.
   • cTo translate JavaScript code into native machine code for fast execution.
   • dTo provide a comprehensive set of APIs for web and server interactions.
   Show the answer

   Answer: c · To translate JavaScript code into native machine code for fast execution.

   V8's core role is to compile JavaScript into native machine code, enabling high-performance execution. While environments like Node.js provide APIs for interactions (option D), V8 itself is solely the engine responsible for processing the JavaScript code.

   Read the full bite: V8: The Engine Powering Chrome and Node.js

3. Question 3 of 30

   In which event loop phase do the majority of completed I/O callbacks, such as a finished network read, actually execute?

   • aThe check phase, alongside setImmediate callbacks
   • bThe close callbacks phase, after the loop drains
   • cThe timers phase, right after expired setTimeout callbacks
   • dThe poll phase, which retrieves and runs I/O completions
   Show the answer

   Answer: d · The poll phase, which retrieves and runs I/O completions

   The poll phase retrieves new I/O events and executes most of their callbacks. The timers phase only handles elapsed setTimeout/setInterval, not I/O completion.

   Read the full bite: Order of the Node.js event loop phases

4. Question 4 of 30

   For which type of task would Node.js's event-driven model, relying on EventEmitter, typically be least effective?

   • aPerforming intensive image manipulation or video encoding.
   • bHandling asynchronous file system operations like reading or writing.
   • cManaging thousands of simultaneous client connections to a web server.
   • dProcessing large data streams from a database query.
   Show the answer

   Answer: a · Performing intensive image manipulation or video encoding.

   The event-driven model is least effective for CPU-bound tasks like image manipulation because they block the single-threaded event loop. It excels at I/O-bound tasks such as network requests, database queries, and file operations.

   Read the full bite: Node.js Events and the EventEmitter

5. Question 5 of 30

   When both are scheduled from inside a completed fs I/O callback, which runs first and why?

   • asetTimeout(fn, 0), because timers always precede check
   • bThey run simultaneously since both mean zero delay
   • csetImmediate, because the check phase follows poll in the same iteration
   • dprocess.nextTick, because it is also a macrotask
   Show the answer

   Answer: c · setImmediate, because the check phase follows poll in the same iteration

   From within an I/O callback the loop is in poll, so the next phase is check, making setImmediate fire before the timers phase comes around again. setTimeout(0) waits for the next iteration.

   Read the full bite: nextTick vs setImmediate vs setTimeout(fn, 0)

6. Question 6 of 30

   Why does wrapping a heavy synchronous computation in an async function fail to keep a Node server responsive?

   • aThe computation is still synchronous and never yields the single JS thread
   • bPromises lower the priority of CPU work in the loop
   • cAsync functions run on a separate OS thread automatically
   • dThe garbage collector preempts long Promises
   Show the answer

   Answer: a · The computation is still synchronous and never yields the single JS thread

   async/await only helps when there is an awaited asynchronous boundary; a synchronous CPU loop still occupies the single thread, blocking the event loop. Worker Threads provide real parallelism.

   Read the full bite: Offloading CPU-bound work with Worker Threads

7. Question 7 of 30

   What is the primary consequence of running a long-running synchronous task in a Node.js application?

   • aThe application's event loop will become blocked, making the server unresponsive.
   • bNode.js will prioritize other I/O operations, delaying the synchronous task's execution.
   • cThe task will be automatically moved to a background thread, preventing blocking.
   • dThe task will cause a memory overflow due to its single-threaded nature.
   Show the answer

   Answer: a · The application's event loop will become blocked, making the server unresponsive.

   The card states that a long-running synchronous computation will 'monopolize the single main thread, blocking the event loop entirely,' leading to an unresponsive application. Synchronous tasks are not automatically offloaded to background threads; they execute directly on the main thread, unlike asynchronous I/O operations.

   Read the full bite: The Node.js Event Loop: Concurrency on a Single Thread

8. Question 8 of 30

   A Node.js API stops responding to every request whenever a user logs in, because the login handler calls crypto.pbkdf2Sync to verify a password. What is the most likely cause?

   • apbkdf2Sync opens a new database connection for every call
   • bThe synchronous call runs on the single main thread and blocks the event loop until it finishes
   • cThe libuv threadpool size is set to zero by default
   • dSynchronous crypto functions are deprecated and throw silently
   Show the answer

   Answer: b · The synchronous call runs on the single main thread and blocks the event loop until it finishes

   pbkdf2Sync executes directly on the same thread that runs the event loop, so nothing else can be processed until it returns; the threadpool default is four, not zero, and the block has nothing to do with database connections.

   Read the full bite: Event Loop vs Crypto Module

9. Question 9 of 30

   Why is it a problem to list a library your source code imports at runtime under devDependencies?

   • adevDependencies are always installed, so it makes no difference
   • bnpm will refuse to install the package at all
   • cIt forces the package to be loaded twice
   • dA production install that skips devDependencies leaves it missing, causing runtime errors
   Show the answer

   Answer: d · A production install that skips devDependencies leaves it missing, causing runtime errors

   Production installs omit devDependencies, so a runtime import placed there will be absent and throw module-not-found. Runtime libraries must live under dependencies.

   Read the full bite: dependencies vs devDependencies in package.json

10. Question 10 of 30

    What does Node do first when it encounters require('fs')?

    • aMatches it against built-in core modules, which take precedence
    • bDownloads it from the npm registry on demand
    • cTreats it as a relative path from the current file
    • dSearches node_modules directories upward for an fs package
    Show the answer

    Answer: a · Matches it against built-in core modules, which take precedence

    Bare specifiers are checked against built-in core modules first; fs is compiled into the binary and resolves without touching node_modules. The package search only runs for non-core bare names.

    Read the full bite: Resolving core vs relative module specifiers

11. Question 11 of 30

    What core problem does committing package-lock.json solve that package.json alone cannot?

    • aIt makes installs faster by caching tarballs in the repo
    • bIt documents which packages are devDependencies
    • cIt guarantees every install resolves to the exact same dependency tree, including transitive packages
    • dIt prevents anyone from adding new dependencies
    Show the answer

    Answer: c · It guarantees every install resolves to the exact same dependency tree, including transitive packages

    package.json uses version ranges, so installs can drift; the lockfile pins exact versions and tree shape for all transitive deps, making installs deterministic. It does not store tarballs or block additions.

    Read the full bite: Why package-lock.json must be committed

12. Question 12 of 30

    Which statement accurately describes how process.nextTick() callbacks are prioritized within the Node.js event loop?

    • aThey execute after all setTimeout(fn, 0) callbacks but before I/O operations.
    • bThey execute immediately after the current JavaScript operation, before any timers or I/O.
    • cThey are queued to run in the next full iteration of the event loop, after all other phases.
    • dThey are processed concurrently with microtasks (like Promises) in the same phase.
    Show the answer

    Answer: b · They execute immediately after the current JavaScript operation, before any timers or I/O.

    process.nextTick() callbacks are processed with the highest precedence, immediately after the current JavaScript operation completes and before the event loop proceeds to microtasks, timers, or I/O. Option D is incorrect because nextTick callbacks are processed *before* the microtask queue.

    Read the full bite: process.nextTick(): Cutting in Line on the Event Loop

13. Question 13 of 30

    Which statement about using ES Modules instead of CommonJS in Node is accurate?

    • aCommonJS supports top-level await but ESM does not
    • bYou can require an ESM-only file directly from a CommonJS module
    • cimport is just an alias for require with identical semantics
    • dESM lacks __dirname by default and is enabled via type module or .mjs
    Show the answer

    Answer: d · ESM lacks __dirname by default and is enabled via type module or .mjs

    ESM omits __dirname and require, and is enabled by type module or the .mjs extension. import is not an alias for require, and only ESM supports top-level await.

    Read the full bite: Choosing between CommonJS and ES Modules

14. Question 14 of 30

    What is the fundamental problem Node.js streams are designed to solve for data handling?

    • aProcessing large datasets without exhausting system memory.
    • bEnsuring data integrity during network transmission.
    • cProviding random access to data within large files.
    • dReducing the complexity of asynchronous I/O operations.
    Show the answer

    Answer: a · Processing large datasets without exhausting system memory.

    The card states streams were created to 'process data piece by piece, keeping memory usage low and constant regardless of the total data size' because loading large files entirely into memory is inefficient or impossible. While streams can simplify I/O (option D), their core purpose is memory efficiency for large data, and they are not ideal for random access (option C).

    Read the full bite: Node.js Streams: Processing Data in Chunks, Not Blobs

15. Question 15 of 30

    What is the primary advantage of using asynchronous child processes in Node.js?

    • aTo simplify the debugging of complex multi-threaded applications.
    • bTo allow multiple Node.js scripts to share memory efficiently.
    • cTo enhance the performance of I/O-bound operations.
    • dTo execute CPU-bound tasks without blocking the main event loop.
    Show the answer

    Answer: d · To execute CPU-bound tasks without blocking the main event loop.

    The card explicitly states that child processes solve the problem of CPU-intensive operations blocking the single-threaded event loop by offloading heavy work. Option B describes the purpose of worker_threads, not child processes.

    Read the full bite: Node.js Child Processes: Escaping the Main Thread

16. Question 16 of 30

    Why should the service layer in a layered Express API avoid referencing the request and response objects?

    • aServices run in a different thread from controllers
    • bExpress forbids accessing them outside route handlers
    • cPassing them is slower than passing plain values
    • dIt keeps business logic framework-agnostic and unit-testable without HTTP
    Show the answer

    Answer: d · It keeps business logic framework-agnostic and unit-testable without HTTP

    Keeping req and res out of services makes the business logic reusable and testable without spinning up HTTP. Express does not forbid it and services are not on a separate thread.

    Read the full bite: Layered structure for a scalable Express API

17. Question 17 of 30

    Given a dependency written as ^1.4.2, which upgrade would npm refuse to install on its own?

    • a1.5.3, a later minor and patch
    • b2.0.0, a major release
    • c1.4.9, a patch release
    • d1.7.0, a minor release
    Show the answer

    Answer: b · 2.0.0, a major release

    The caret allows updates below the next major, so anything under 2.0.0 is permitted, but 2.0.0 itself is excluded. The tilde would be the operator that also blocks 1.7.0.

    Read the full bite: SemVer and the caret vs tilde range operators

18. Question 18 of 30

    How does Libuv ensure non-blocking I/O for operations that lack native asynchronous support from the operating system?

    • aIt queues these operations and processes them sequentially in a separate, single-threaded background process.
    • bIt transforms the synchronous I/O call into a Promise, allowing the JavaScript engine to continue execution.
    • cIt uses a dedicated thread pool to execute these operations, preventing the main JavaScript thread from blocking.
    • dIt directly executes these operations on the main JavaScript thread, relying on the OS to manage concurrency.
    Show the answer

    Answer: c · It uses a dedicated thread pool to execute these operations, preventing the main JavaScript thread from blocking.

    Libuv employs a thread pool for I/O operations that do not have native asynchronous OS APIs, allowing these tasks to run in the background without blocking the main JavaScript event loop. Relying on the main thread or just JavaScript Promises would not achieve true non-blocking I/O at the system level.

    Read the full bite: Libuv: The Engine Behind Node.js Async I/O

19. Question 19 of 30

    When module B requires module A in the middle of A's own loading, what does B receive?

    • aA freshly re-executed copy of A's exports
    • bAn error, since CommonJS forbids cycles
    • cA's exports object as populated so far, possibly incomplete
    • dAn empty object that updates synchronously when A finishes
    Show the answer

    Answer: c · A's exports object as populated so far, possibly incomplete

    CommonJS caches the exports object at load start and returns it as-is, so B gets whatever A has assigned up to that point. It is not re-executed, does not throw, and the reference is not retroactively backfilled.

    Read the full bite: Circular dependencies in CommonJS modules

20. Question 20 of 30

    Why can two installed major versions of the same library cause instanceof checks to fail across packages?

    • aThe older version overwrites the newer version's prototypes
    • bEach copy is a distinct module instance with its own classes, so cross-copy instanceof returns false
    • cinstanceof never works in Node with hoisted dependencies
    • dnpm strips prototype chains during install
    Show the answer

    Answer: b · Each copy is a distinct module instance with its own classes, so cross-copy instanceof returns false

    Two physical copies are separate module instances with separate class identities, so an object from one copy is not an instance of the other copy's class. npm does not strip prototypes.

    Read the full bite: Diamond dependencies and nested node_modules

21. Question 21 of 30

    Why does copying all source before npm install slow down rebuilds after a code change?

    • aThe COPY of changed source invalidates the install layer and everything after it
    • bDocker reinstalls only the changed packages, which is slow
    • cLayer caching only works for compiled languages
    • dnpm install always ignores the Docker cache entirely
    Show the answer

    Answer: a · The COPY of changed source invalidates the install layer and everything after it

    Cache invalidation cascades from the first changed instruction, so copying edited source before install busts the install layer; npm install does respect the cache when its inputs are unchanged.

    Read the full bite: Optimize Dockerfile layer caching for npm install

22. Question 22 of 30

    What is the primary advantage of employing the Node.js cluster module in a multi-core environment?

    • aIt facilitates the distribution of application load across multiple physical servers using an internal load balancer.
    • bIt provides a low-overhead mechanism for inter-process communication, ideal for tasks requiring frequent data exchange.
    • cIt allows a single Node.js application to utilize all available CPU cores for I/O-bound network operations on one machine.
    • dIt enables direct memory sharing between worker processes for CPU-intensive computations.
    Show the answer

    Answer: c · It allows a single Node.js application to utilize all available CPU cores for I/O-bound network operations on one machine.

    The cluster module's core purpose is to enable a single Node.js application to fully utilize all CPU cores on a *single* multi-core machine for I/O-bound tasks like network applications. It is not designed for direct memory sharing (that's worker_threads), distributing across multiple physical servers, or low-overhead IPC for frequent data exchange, as IPC overhead is noted as high.

    Read the full bite: Node.js Cluster: Scaling on a Single Machine

23. Question 23 of 30

    What is a distinctive advantage of monorepo workspaces over consuming shared code as published private packages?

    • aServices can never have conflicting dependency versions
    • bIt eliminates the need for any CI configuration
    • cEach service automatically deploys independently
    • dA breaking change and all consumer updates can land in one atomic commit without a publish step
    Show the answer

    Answer: d · A breaking change and all consumer updates can land in one atomic commit without a publish step

    Workspaces link internal packages locally, so changes to shared code and its consumers ship in a single atomic commit. Published packages instead require a publish-and-bump cycle and risk version drift.

    Read the full bite: Monorepo workspaces vs private npm packages

24. Question 24 of 30

    According to the CommonJS mental model, what is the default state of variables and functions defined within a module file?

    • aThey are shared with other modules unless explicitly marked as private.
    • bThey are private to the module unless explicitly exported.
    • cThey are only accessible after being imported by another module.
    • dThey are globally accessible unless explicitly marked as private.
    Show the answer

    Answer: b · They are private to the module unless explicitly exported.

    The card states, "By default, all tools and materials (variables, functions) inside are private. To share a tool, you place it on a public shelf called exports." This means they are private unless explicitly exported. Options A and B describe the opposite of CommonJS's encapsulation, and D is incorrect because variables are accessible within their own module before any import.

    Read the full bite: CommonJS: Node.js's Original Module System

25. Question 25 of 30

    What is the primary function of the package.json file when a new developer sets up a Node.js project?

    • aIt outlines the project's architectural design and component interactions.
    • bIt specifies the exact Node.js runtime version required for compatibility.
    • cIt serves as the central repository for project documentation and user manuals.
    • dIt lists all external code the project depends on and defines how to run common tasks.
    Show the answer

    Answer: d · It lists all external code the project depends on and defines how to run common tasks.

    The correct answer is B because package.json explicitly lists all external libraries (dependencies) required for the project and defines runnable scripts. This allows a new developer to quickly install everything with 'npm install' and run tasks like 'npm start', making the project self-contained and reproducible. Option B is incorrect because while package.json can suggest a Node.js version, its primary role for initial setup is dependency and script management.

    Read the full bite: package.json: The Blueprint for Your Node.js Project

26. Question 26 of 30

    Which statement about a Promise's state transitions is correct?

    • aOnce settled as fulfilled or rejected, the state is permanent and cannot change
    • bA rejected Promise can later return to pending if retried
    • cthen callbacks execute synchronously the instant resolve is called
    • dA Promise can be both fulfilled and rejected to cover all cases
    Show the answer

    Answer: a · Once settled as fulfilled or rejected, the state is permanent and cannot change

    Settling is one-way and final; a Promise transitions from pending to exactly one of fulfilled or rejected and stays there. then callbacks run later as microtasks, not synchronously.

    Read the full bite: The three states of a JavaScript Promise

27. Question 27 of 30

    What is a key architectural difference between adapter-static and adapter-node?

    • aadapter-static pre-renders pages into HTML files at build time, whereas adapter-node produces a Node server for dynamic requests
    • badapter-static supports dynamic API routes and server hooks by default, whereas adapter-node only serves static files
    • cadapter-static bundles application code with Vite, whereas adapter-node relies on Rollup for bundling
    • dadapter-node generates static HTML for CDN hosts, whereas adapter-static requires a Node server on a VPS
    Show the answer

    Answer: a · adapter-static pre-renders pages into HTML files at build time, whereas adapter-node produces a Node server for dynamic requests

    adapter-static outputs static HTML for CDN deployment while adapter-node creates a running Node server capable of SSR and API routes. A is tempting but wrong because Vite handles bundling; an adapter only repackages the already-bundled output for a specific platform.

    Read the full bite: What is a SvelteKit adapter and how do adapter-static and adapter-node differ?

28. Question 28 of 30

    What is the main reason for differentiating between "dependencies" and "devDependencies" in a Node.js project?

    • aTo simplify the process of updating all project packages simultaneously.
    • bTo allow developers to use different package versions for development and production.
    • cTo reduce the final production bundle size and enhance security.
    • dTo ensure that all development tools are always available in the production environment.
    Show the answer

    Answer: c · To reduce the final production bundle size and enhance security.

    The card states this separation "prevents shipping unnecessary code to production, which saves disk space, reduces installation time, and minimizes the potential security attack surface." Option D is incorrect because the distinction aims to exclude development tools from production, not include them, to avoid bloat and security risks.

    Read the full bite: Dependencies vs. DevDependencies: What's the Difference?

29. Question 29 of 30

    What is the primary mechanism that allows npm scripts to execute project-specific tools (like jest or webpack) without requiring them to be installed globally?

    • anpm temporarily adds the project's node_modules/.bin directory to the system's PATH during script execution.
    • bnpm scripts have a built-in resolver that can locate executables within any node_modules folder.
    • cnpm scripts automatically detect and install any missing global dependencies required by the script.
    • dThe package.json file explicitly lists all executable paths for tools used in scripts.
    Show the answer

    Answer: a · npm temporarily adds the project's node_modules/.bin directory to the system's PATH during script execution.

    The card states that npm temporarily adds the project's node_modules/.bin directory to the system's PATH, allowing local executables to be run by name. Option C is incorrect because npm does not automatically install global dependencies for scripts.

    Read the full bite: npm Scripts: Your Project's Command-Line Shortcuts

30. Question 30 of 30

    When is Vite's low-level SSR API the most appropriate choice for a project?

    • aWhen Vite is intended to serve the entire application, including its own HTML, in production.
    • bWhen building a custom SSR framework or requiring unique server-side rendering control beyond existing plugins.
    • cTo achieve the highest possible performance for a standard web application.
    • dFor any new web application requiring server-side rendering with popular frameworks like React or Vue.
    Show the answer

    Answer: b · When building a custom SSR framework or requiring unique server-side rendering control beyond existing plugins.

    The low-level SSR API is designed for advanced scenarios like framework development or highly custom server environments, offering full control. It is explicitly advised against for standard applications using popular frameworks, which should leverage higher-level SSR plugins.

    Read the full bite: Vite's Low-Level SSR API