Interview Q&A

• process.nextTick() queues a callback to be invoked immediately after the

current operation completes, before the event loop continues.

• setImmediate() queues a callback to run on the next iteration of the event loop.

Example:

process.nextTick(() => console.log('nextTick'));
setImmediate(() => console.log('setImmediate'));

console.log('sync');

Output:

sync

nextTick

setImmediate

nextTick runs before any I/O or timers; setImmediate runs after I/O callbacks.

If an error (exception) is thrown but not caught, Node.js will:

• Print the error stack trace to the console.
• Immediately terminate the process to avoid unpredictable behavior.

Why? Because an uncaught exception might leave the app in an inconsistent state.

Best practice: Use try/catch for synchronous code, and listen to

'uncaughtException' or 'unhandledRejection' events to log errors and gracefully

shut down:

process.on('uncaughtException', (err) => {

console.error('Uncaught Exception:', err);

process.exit(1); // Exit to avoid unstable state

});

• Injection attacks (SQL, NoSQL)
• Cross-Site Scripting (XSS)
• Cross-Site Request Forgery (CSRF)
• Broken authentication and session management
• Insecure handling of sensitive data (passwords, API keys)
• Unvalidated input data
• Exposed stack traces or error messages
• Security misconfigurations

s expected.

Basic example using Mocha and Chai:

// calculator.js

function add(a, b) {

return a + b;
}
module.exports = add;

// test/calculator.test.js

const add = require('../calculator');
const { expect } = require('chai');

describe('add function', () => {

it('should return the sum of two numbers', () => {

const result = add(2, 3);

expect(result).to.equal(5);

});

});

Run tests with:

mocha

This test suite checks if add(2,3) equals 5 — simple and effective.

Node.js uses a single-threaded event loop to handle concurrency. This design:

• Simplifies programming by avoiding thread-related bugs like race conditions.
• Uses non-blocking I/O so a single thread can handle many connections efficiently.
• Offloads heavy tasks (file I/O, network requests) to background threads in the libuv

thread pool.

So, Node.js can handle many tasks concurrently without spawning multiple OS threads for

each.

• Always use parameterized queries or prepared statements instead of string

concatenation.

Example with MySQL:

connection.query('SELECT * FROM users WHERE id = ?', [userId],

callback);

• Use ORM libraries like Sequelize which handle this automatically.
• Validate and sanitize inputs.

Answer: Mocha: Flexible test runner, widely used. Jest: Full-featured, zero-config, includes mocks and coverage. Jasmine: Behavior-driven development framework. AVA: Minimalistic and fast. Tape: Simple and small footprint.

What interviewers expect

• A clear definition tied to Node.js in Node.js projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Node.js application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Node.js architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• Use clustering or process managers like PM2 to utilize multiple CPU cores.
• Implement caching (in-memory or distributed caches like Redis).
• Use asynchronous I/O properly (avoid blocking the event loop).
• Optimize database queries and use connection pooling.
• Minimize heavy computations in the main thread (offload with worker threads).
• Use gzip compression for responses.
• Properly manage memory leaks.
• Use load balancers in production.

Node.js operates on a single-threaded, event-driven architecture. It uses the event loop

to handle multiple connections concurrently, which means it can perform non-blocking I/O

operations efficiently.

📌 Real-life analogy:

Think of it like a chef (Node.js) who takes multiple orders (requests) but doesn't cook each

dish one at a time. Instead, they prep and send off tasks (e.g., grilling, baking) and move on

to the next customer while waiting.

phases.

Node.js uses the event loop to handle async tasks without blocking.

Main phases:

• Timers: Executes callbacks scheduled by setTimeout and setInterval.
• Pending callbacks: Executes I/O callbacks deferred to next iteration.
• Idle, prepare: Internal operations.
• Poll: Retrieves new I/O events; executes I/O callbacks.
• Check: Executes callbacks scheduled by setImmediate.
• Close callbacks: Handles closed connections.

Tasks are processed in this order each loop iteration.

Node.js is awesome for I/O-heavy, real-time apps, but it’s not ideal for:

• CPU-intensive tasks: Heavy computations block the event loop and slow down all

requests.

• Applications requiring multithreaded parallelism: Though worker threads exist,

Node.js is not designed for parallel CPU-heavy workloads by default.

• When you need mature libraries for complex domains: Some domains (like

machine learning) have better ecosystems in other languages.

• Use real environment variables on the server or container.
• Avoid committing .env files to source control.
• In cloud providers, set environment variables in the dashboard.
• Use tools like dotenv only in development.
• For sensitive secrets, consider secret managers like AWS Secrets Manager or

HashiCorp Vault.

require('dotenv').config(); console.log(process.env.DB_PASSWORD);

What interviewers expect

• A clear definition tied to Node.js in Node.js projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Node.js application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Node.js architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: Avoid directly inserting user input into queries. Use safe query methods (e.g., Mongoose’s query APIs). Validate and sanitize input. For example, don’t allow user input to modify query operators like $gt, $ne.

What interviewers expect

• A clear definition tied to Node.js in Node.js projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Node.js application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Node.js architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

📌 Middleware example:

function auth(req, res, next) {

const token = req.headers.authorization?.split(' ')[1];
if (!token) return res.status(401).send('Unauthorized');

try {

const user = jwt.verify(token, 'secret');
req.user = user;

next();

} catch {

res.status(403).send('Invalid token');

}
}

Answer: Worker threads run JavaScript code in parallel threads — useful for CPU-intensive tasks that block the event loop. Use them when your app needs heavy computation without blocking other requests.

What interviewers expect

• A clear definition tied to Node.js in Node.js projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Node.js application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Node.js architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Node.js uses the V8 JavaScript engine’s garbage collector, which:

• Automatically frees memory that's no longer referenced.
• Uses a generational GC: young generation (short-lived objects) and old generation

(long-lived objects).

• Runs periodically to clean up unused objects.
• Developers usually don’t control it directly, but can monitor memory and tune via flags

if needed.

Answer: sync function connect() { const connection = await mysql.createConnection({ host: 'localhost', user: 'root', database: 'test' }); const [rows] = await connection.execute('SELECT * FROM users'); console.log(rows); }

What interviewers expect

• A clear definition tied to Node.js in Node.js projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Node.js application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Node.js architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Worker threads allow you to run JavaScript code in parallel on multiple threads within the

same process — useful for CPU-intensive tasks like image processing or complex

calculations without blocking the main event loop.

const { Worker } = require('worker_threads');
const worker = new Worker('./worker.js');
worker.on('message', (msg) => console.log('From worker:', msg));

worker.postMessage('start');

• Asynchronous and Event-Driven: Handles multiple requests without blocking.
• Fast Execution: Powered by the V8 engine.
• Single-Threaded but Scalable: Uses event loop and callbacks for handling

concurrency.

• Cross-platform: Runs on Windows, Linux, and macOS.
• NPM (Node Package Manager): Massive ecosystem of reusable packages.

• Callbacks: Functions passed as arguments, executed when async operation

finishes. Can lead to “callback hell.”

• Promises: Objects representing future results; allow chaining with .then().
• Async/await: Syntactic sugar over promises; lets you write async code that looks

synchronous, improving readability.

Docker packages your app and its environment into a container for consistent deployment.

Basic steps:

• Create a Dockerfile:

FROM node:18

WORKDIR /app

COPY package*.json ./

RUN npm install --production

COPY . .

CMD ["node", "app.js"]

• Build and run the container:

docker build -t my-node-app .

docker run -p 3000:3000 my-node-app

Answer: Never hardcode keys in your source code. Store them in environment variables or secure vaults. Use .env files with .gitignore to avoid committing secrets. Rotate keys regularly. Use scopes/permissions to limit key usage.

What interviewers expect

• A clear definition tied to Node.js in Node.js projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Node.js application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Node.js architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Child processes are separate processes spawned by your Node.js app to run shell

commands or other programs, enabling parallel execution.

const { exec } = require('child_process');

exec('ls -la', (err, stdout, stderr) => {

if (err) console.error(err);

console.log(stdout);

});

Useful for running system commands or scripts without blocking your main app.

Feature Node.js Apache

Thread Model Single-threaded event loop Multi-threaded

I/O Non-blocking Blocking by default

Performance Very high for I/O operations Good but resource

intensive

Use Case Real-time apps, APIs Websites, PHP apps

📌 Example:

For a chat application or API server with thousands of concurrent users, Node.js performs

better than Apache.