Node.js Quiz ( Advance ) - All Questions

This advanced Node.js quiz is designed for senior developers and backend engineers who want to test deep, real-world knowledge. It covers event loop internals, memory management, performance bottlenecks, scaling strategies, security, and production-grade architecture commonly asked in advanced interviews.

Question 1: Why can CPU-intensive tasks severely degrade Node.js performance?

They consume too much memory
They block the event loop
They crash the V8 engine
They disable async I/O

Explanation: CPU-heavy tasks block the single-threaded event loop.

Question 2: Which Node.js feature enables true parallel execution of JavaScript?

cluster
child_process
worker_threads
event loop

Explanation: worker_threads enable multi-threaded JavaScript execution.

Question 3: What is the primary difference between cluster and worker_threads?

cluster uses threads, workers use processes
cluster uses processes, workers use threads
Both behave identically
Workers cannot share memory

Explanation: cluster creates processes, worker_threads create threads.

Question 4: Which event loop phase executes setImmediate callbacks?

Timers
Poll
Check
Close callbacks

Explanation: setImmediate runs in the check phase.

Question 5: What risk does excessive use of process.nextTick introduce?

Memory leak
Starvation of I/O callbacks
Thread deadlock
Process crash

Explanation: process.nextTick can starve the event loop.

Question 6: What is the main benefit of backpressure handling in streams?

Improved SEO
Reduced latency
Preventing memory overload
Faster CPU execution

Explanation: Backpressure prevents overwhelming memory.

Question 7: Which stream type can both read and write data?

Readable
Writable
Duplex
File

Explanation: Duplex streams support both reading and writing.

Question 8: Why are streams preferred for large file uploads?

They block the event loop
They buffer entire files
They process data incrementally
They simplify syntax

Explanation: Streams handle data in chunks.

Question 9: What does libuv primarily manage in Node.js?

JavaScript execution
HTTP routing
Event loop and async I/O
Garbage collection

Explanation: libuv powers the event loop and async operations.

Question 10: Which scenario can cause a memory leak in Node.js?

Uncleared timers
Using async/await
Using streams
Using promises

Explanation: Uncleared timers retain memory references.

Question 11: Why should large objects not be stored on the global scope?

They reduce performance
They increase CPU usage
They prevent garbage collection
They block I/O

Explanation: Global references prevent garbage collection.

Question 12: Which tool is best for profiling Node.js memory usage?

nodemon
PM2
Chrome DevTools
eslint

Explanation: Chrome DevTools can profile Node.js memory.

Question 13: What does heap out of memory error indicate?

Stack overflow
Exceeded V8 heap limit
Event loop failure
Thread exhaustion

Explanation: It means V8 heap memory is exhausted.

Question 14: Which flag increases Node.js memory limit?

--max-memory
--heap-size
--max-old-space-size
--memory-limit

Explanation: This flag increases the V8 heap size.

Question 15: Why is JSON.parse on very large payloads risky?

Security vulnerability
Blocking the event loop
Data corruption
Memory fragmentation

Explanation: Parsing large JSON blocks the event loop.

Question 16: Which HTTP header helps protect against request smuggling?

Authorization
Content-Type
Content-Length
Accept

Explanation: Content-Length helps validate request size.

Question 17: What is the main risk of synchronous fs methods in production?

Memory leaks
Blocking the event loop
Security flaws
Thread starvation

Explanation: Synchronous fs blocks the event loop.

Question 18: Which attack exploits blocking behavior in Node.js?

SQL injection
DDoS via slow requests
XSS
CSRF

Explanation: Slow requests can block the event loop.

Question 19: Why is rate limiting important in Node.js APIs?

Improve SEO
Prevent abuse and overload
Reduce memory
Optimize routing

Explanation: Rate limiting prevents abuse.

Question 20: Which approach best scales Node.js horizontally?

Increasing heap size
Clustering with load balancer
Using synchronous code
Single process optimization

Explanation: Clustering with load balancing enables scaling.

Question 21: What does sticky session mean in clustering?

Sessions stored in memory
Requests always go to same worker
Sessions cached on client
Workers share memory

Explanation: Sticky sessions route users to the same worker.

Question 22: Why is shared memory risky between workers?

Performance issues
Race conditions
Security vulnerabilities
Garbage collection failure

Explanation: Shared memory can cause race conditions.

Question 23: Which pattern best handles graceful shutdown?

process.exit immediately
Ignoring SIGTERM
Closing server and resources on signals
Restarting server

Explanation: Graceful shutdown closes resources properly.

Question 24: Which signal is commonly used for graceful shutdown?

SIGKILL
SIGSTOP
SIGTERM
SIGUSR2

Explanation: SIGTERM allows cleanup before exit.

Question 25: Why should secrets never be committed to package.json?

Performance loss
Security risk
Deployment issues
Version conflicts

Explanation: Secrets in code can be leaked.

Question 26: Which mechanism isolates untrusted code execution?

eval
vm module
require
child_process.exec

Explanation: The vm module isolates execution contexts.

Question 27: What does event loop lag indicate?

Memory usage
CPU saturation or blocking tasks
Network latency
Disk I/O speed

Explanation: Lag indicates blocking or heavy CPU usage.

Question 28: Which metric best reflects Node.js responsiveness?

Heap size
Event loop latency
CPU count
Thread pool size

Explanation: Event loop latency measures responsiveness.

Question 29: Why should bcrypt hashing run outside the main thread?

SEO reasons
It is CPU intensive
It uses network I/O
It blocks disk access

Explanation: bcrypt is CPU-heavy.

Question 30: Which Node.js feature uses a thread pool internally?

HTTP server
Timers
fs and crypto
EventEmitter

Explanation: fs and crypto use the libuv thread pool.

Question 31: What happens if the libuv thread pool is exhausted?

Process crashes
Async tasks are delayed
Memory leak occurs
Event loop stops

Explanation: Tasks wait until threads are free.

Question 32: Which environment variable controls libuv thread pool size?

NODE_THREADS
UV_THREADPOOL_SIZE
THREAD_POOL_LIMIT
NODE_POOL_SIZE

Explanation: UV_THREADPOOL_SIZE configures the pool.

Question 33: Why is object pooling rarely recommended in Node.js?

More GC pressure
Manual memory management complexity
Security risk
Slower execution

Explanation: V8 GC handles objects efficiently.

Question 34: Which Node.js design principle improves fault tolerance?

Monolithic architecture
Fail-fast and restart
Global state
Synchronous logic

Explanation: Fail-fast allows recovery via restarts.

Question 35: Why are uncaught exceptions dangerous?

They reduce performance
They corrupt memory state
They slow the event loop
They block I/O

Explanation: They can leave the process in an inconsistent state.

Question 36: Which strategy is recommended after an uncaught exception?

Ignore it
Continue execution
Log and restart process
Retry the request

Explanation: Restart ensures clean state.

Question 37: Why is stateless design preferred in Node.js services?

Simpler routing
Better horizontal scalability
Lower memory usage
Faster development

Explanation: Stateless services scale easily.

Question 38: Which approach best secures Node.js APIs?

Client-side validation only
Input validation and sanitization
Hidden routes
Obscure URLs

Explanation: Proper validation prevents attacks.

Question 39: What is the main advantage of using a reverse proxy like Nginx?

Faster JavaScript execution
Load balancing and SSL termination
Memory optimization
Garbage collection

Explanation: Nginx offloads networking concerns.

Question 40: Why should compression be handled carefully?

It breaks APIs
It can increase CPU usage
It reduces security
It blocks routing

Explanation: Compression is CPU-intensive.

Question 41: Which logging strategy scales best in production?

console.log everywhere
Synchronous file logging
Structured async logging
No logging

Explanation: Async structured logging scales well.

Question 42: Why is idempotency important for APIs?

Improves performance
Prevents duplicate side effects
Simplifies UI
Improves SEO

Explanation: Idempotency avoids duplicate operations.

Question 43: Which HTTP method must be idempotent by design?

POST
PATCH
PUT
CONNECT

Explanation: PUT is idempotent.

Question 44: What is the primary goal of Node.js in system design?

High CPU throughput
Efficient I/O handling at scale
Complex threading models
Low-level memory control

Explanation: Node.js excels at scalable I/O.

Question 45: Which practice best prepares Node.js apps for production?

Hardcoding configs
Graceful shutdown and monitoring
Using sync APIs
Single process deployment

Explanation: Monitoring and graceful shutdown are essential.

Back to programming Quizzes

Node.js Quiz ( Advance )

Questions

Minutes

Min Limit