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

});

sync function connect() {

const uri = 'mongodb://localhost:27017/mydatabase';
const client = new MongoClient(uri);

try {

wait client.connect();

console.log('Connected to MongoDB');

const db = client.db('mydatabase');

// Use `db` to query collections

} catch (err) {

console.error(err);

} finally {

wait client.close();

}
}

connect();

• 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.

time per process. Clustering allows you to create multiple Node.js processes (workers)

that share the same server port. This way, your app can utilize multiple CPU cores and

handle more requests concurrently.

📌 Example: Using the built-in cluster module, you can fork multiple workers.

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.

EventEmitter allows objects to emit named events and listen for them.

Example:

const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.on('greet', (name) => {

console.log(`Hello, ${name}!`);

});

emitter.emit('greet', 'Alice');

Output: Hello, Alice!

It’s fundamental for asynchronous communication in Node.js.

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.

Process management means keeping your app running reliably, restarting it if it crashes, and

managing multiple instances.

PM2 is a popular Node.js process manager that:

• Restarts apps on crashes or code changes
• Manages clustering (multi-core usage)
• Offers logs and monitoring dashboards
• Supports zero-downtime reloads

Run your app with PM2 like this:

pm2 start app.js

pm2 monit

Mongoose is an ODM (Object Data Modeling) library for MongoDB in Node.js. It provides:

• Schema-based data modeling
• Validation
• Middleware (hooks)
• Easy querying and relationship management

You define schemas and models to interact with MongoDB more intuitively.

• 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 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.

ge: Number,

createdAt: { type: Date, default: Date.now }

});

const User = mongoose.model('User', userSchema);

// Usage example

sync function createUser() {

const user = new User({ name: 'Alice', email: 'alice@example.com',

ge: 25 });

wait user.save();

console.log('User saved');

}

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.

Answer: nd allows async testing. It does not provide assertions, so it’s often paired with assertion libraries like Chai.

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.

PM2 is a popular production process manager for Node.js applications. It helps you:

• Manage and keep apps alive forever (auto-restart on crashes).
• Run apps in cluster mode easily.
• Monitor resource usage (CPU, memory).
• Handle zero-downtime reloads.

npm install pm2 -g

pm2 start app.js -i max # Runs in cluster mode with max CPU cores

📌 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');

}
}

The V8 engine is a high-performance JavaScript engine developed by Google for Chrome.

Node.js uses it to compile and run JavaScript code on the server side. It converts JS code

into machine code, making it fast and efficient.

📌 Use Case:

When you run a .js file with Node.js, the V8 engine compiles your code into machine code

behind the scenes.

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 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.

Load balancing distributes incoming requests across multiple server instances to:

• Improve performance
• Increase availability and fault tolerance

In Node.js, you can:

• Use the cluster module to spawn workers on multiple CPU cores.
• Use external load balancers like Nginx, HAProxy, or cloud load balancers.
• PM2 also supports clustering with:

pm2 start app.js -i max

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.

ssert style: ssert.equal(result, 5);

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.

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.

• 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.

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.

Supertest is a library for testing HTTP APIs, especially Express apps.

It allows you to simulate HTTP requests and assert on responses.

Example:

const request = require('supertest');
const app = require('../app'); // Your Express app

describe('GET /users', () => {

it('should return 200 and a list of users', (done) => {

request(app)

.get('/users')

.expect(200)

.expect('Content-Type', /json/)

.end((err, res) => {

if (err) return done(err);

done();

});

});

});

• PUT: Replaces the entire resource with the data sent.
• If a field is missing in the request, it may get erased.
• Idempotent (same request repeated yields same result).
• PATCH: Applies partial updates to the resource.
• Only changes the fields specified.
• Not necessarily idempotent.

Example: Updating user email.

• PUT /users/1 with { "name": "Alice" } replaces whole user — email might

get removed.

• PATCH /users/1 with { "email": "new@example.com" } updates just the

email.

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

Sequelize is a popular ORM for relational databases like MySQL, PostgreSQL, SQLite, and

MSSQL.

It allows you to:

• Define models with JavaScript classes
• Handle migrations and schema changes
• Write complex queries using JavaScript instead of raw SQL

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.

Answer: You can access environment variables using process.env. const port = process.env.PORT || 3000; These variables are set outside your app, often in your shell or deployment environment.

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.

Mocking replaces real dependencies with fake versions to isolate the unit you’re testing.

Common tools:

• Sinon: For mocks, spies, and stubs.
• Proxyquire: Replace dependencies when requiring modules.
• Jest: Has built-in mocking capabilities.

Example with Sinon:

const sinon = require('sinon');
const myModule = require('../myModule');
const dependency = require('../dependency');

describe('test with mock', () => {

it('should call dependency once', () => {

const stub = sinon.stub(dependency, 'someMethod').returns(42);
const result = myModule.doSomething();

sinon.assert.calledOnce(stub);

stub.restore();

});

});

synchronous operations in a single thread, constantly checking for events (e.g., incoming

data, timers) and executing associated callbacks.

📌 Example:

setTimeout(() => {

console.log('Executed after 2 seconds');

}, 2000);

This callback is scheduled by the event loop and executed when the time is up.

• Use logging libraries like winston or pino for structured logs.
• Separate logs into levels (info, warn, error).
• Output logs to files or external services (Logstash, Datadog, Splunk).
• Implement log rotation to prevent disk space issues.
• Make logs easy to search and analyze.

• Use try/catch blocks with async/await to catch exceptions.
• Handle errors in callbacks or promise .catch() when using promise-based APIs.
• Log errors for debugging.
• Return meaningful error messages to the client without exposing sensitive info.

Example:

try {

const user = await User.findById(id);
if (!user) throw new Error('User not found');

} catch (error) {

console.error(error);

res.status(500).send('Something went wrong');

}

V8 engine manages memory automatically with garbage collection.

To detect leaks:

• Use tools like Chrome DevTools, node --inspect, or heapdump.
• Monitor memory usage over time.
• Look for increasing memory without release, which signals leaks.

Modules & Package Management

sync/await provides a cleaner syntax for handling asynchronous code, making it look

synchronous and easier to read compared to nested callbacks or promise chains.

sync function fetchData() {

try {

const data = await someAsyncFunction();

console.log(data);

} catch (err) {

console.error(err);

}
}

Backpressure happens when data is produced faster than it can be consumed downstream.

In Node.js streams, it's a built-in mechanism to:

• Pause the readable stream when the writable stream is overwhelmed.
• Prevent memory overload and crashes.

This flow control allows producers and consumers to work in sync.

pp.js — Use the custom module

const math = require('./mathUtils');

console.log(math.add(5, 3)); // Output: 8

console.log(math.subtract(10, 4)); // Output: 6

✅ This pattern helps you break code into organized, testable, and reusable pieces — just

like using built-in or third-party libraries.

dvanced Node.js Concepts

Answer: sync function getUser() { try { const user = await getUserFromDB(); return user; } catch (error) { console.error('Error fetching user:', error); } } Without try/catch, unhandled promise rejections can crash your app.

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: dotenv is a library to load environment variables from a .env file into process.env.

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.

Test coverage shows how much of your code is tested (lines, branches, functions).

Tools to measure:

• Istanbul/nyc: Most popular coverage tool.
• Jest: Has built-in coverage reports.

Run coverage with nyc:

nyc mocha

It outputs stats like:

• % of lines covered
• % of functions covered
• % of branches covered

Security in Node.js

sync queues (e.g., with libraries like async.queue) allow you to:

• Control concurrency (limit how many async tasks run simultaneously).
• Queue tasks and process them in order.

Example with async library:

const async = require('async');

const queue = async.queue(async (task) => {

wait doWork(task);

}, 2); // concurrency = 2

queue.push({ id: 1 });

queue.push({ id: 2 });

Node.js internally uses libuv’s thread pool for async I/O, but the event loop manages task

scheduling on the single main thread.

dditional Important Node.js Questions

& Answers

Core Concepts & Runtime

• Use monitoring tools like New Relic, Datadog, AppDynamics, or open-source tools

like Prometheus + Grafana.

• Track metrics: response time, CPU/memory usage, error rates.
• Use Node.js built-in profilers or clinic.js to analyze performance.
• Set up alerts for anomalies.

nalysis. ESM is the modern standard but Node.js supports both.

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.

wait User.create([{ name: 'Bob' }], { session });

wait Order.create([{ userId: user._id }], { session });

wait session.commitTransaction();

} catch (error) {

wait session.abortTransaction();

} finally {

session.endSession();

}

• In Sequelize (MySQL/PostgreSQL):

const t = await sequelize.transaction();

try {

wait User.create({ name: 'Bob' }, { transaction: t });

wait Order.create({ userId: user.id }, { transaction: t });

wait t.commit();

} catch (error) {

wait t.rollback();

}

Deployment & Production

database) to complete before moving to the next one. Node.js uses callbacks, promises, or

sync/await to handle the results when they're ready.

📌 Example:

const fs = require('fs');

fs.readFile('file.txt', 'utf8', (err, data) => {

if (err) throw err;

console.log(data);

});

console.log('Reading file...');

You’ll see "Reading file..." first, even though the file is being read.

Answer: nodemon is a development tool that automatically restarts your Node.js app when file changes are detected—great for faster development cycles. It’s not recommended for production. Usage: nodemon app.js

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.

Global objects are available in all modules without the need to import them. Examples

include:

• __dirname: Directory name of the current module
• __filename: Full path of the current module
• global: Similar to window in browsers
• process: Provides info about the current Node.js process
• setTimeout, setInterval, etc.

Node.js searches in this order:

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: Sanitize user inputs and outputs. Use libraries like DOMPurify for front-end. Use HTTP headers like Content Security Policy (CSP) via Helmet. Escape data before rendering in HTML.

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.

• Synchronous functions block the execution until they finish.
• Asynchronous functions allow other code to run while waiting for operations (like

I/O) to complete.

// Synchronous (blocks event loop)

const data = fs.readFileSync('file.txt');

// Asynchronous (non-blocking)

fs.readFile('file.txt', (err, data) => {

if (err) throw err;

console.log(data);

});

CI/CD stands for Continuous Integration and Continuous Deployment.

• CI: Automatically build and test your Node.js app every time you push code (e.g.,

GitHub Actions, Jenkins).

• CD: Automatically deploy the app to production or staging after tests pass.

Benefits:

• Catch bugs early
• Fast, repeatable releases
• Automated testing and deployment pipelines

Typical pipeline steps:

process is a global object that provides information and control over the current Node.js

process.

📌 Examples:

console.log(process.pid); // Process ID

console.log(process.platform); // OS platform

You can also handle exit events:

process.on('exit', () => {

console.log('Exiting...');

});

Answer: It specifies the entry point file of a package (default is index.js). When someone imports your package, Node.js loads the file in main.

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: sync function read() { const content = await readFile('file.txt', 'utf8'); console.log(content); }

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.

• __dirname: Returns the directory path of the current module.
• __filename: Returns the full file path of the current module.

📌 Example:

console.log(__dirname); // /Users/yourname/project

console.log(__filename); // /Users/yourname/project/app.js

These are very useful for reading or writing files relative to the script's location.

PM and Module Management

• Always hash passwords before storing (never store plaintext).
• Use strong, slow hashing algorithms like bcrypt, argon2, or scrypt.
• Add a salt to each password (bcrypt does this automatically).
• Use libraries like bcrypt:

const bcrypt = require('bcrypt');
const hash = await bcrypt.hash(password, 10);

• When verifying:

const match = await bcrypt.compare(inputPassword, storedHash);

Database Integration

Both create child processes, but:

• spawn() streams data (good for large outputs)
• exec() buffers data (good for small outputs)

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

// spawn example

const ls = spawn('ls', ['-lh', '/usr']);
ls.stdout.on('data', (data) => console.log(`Output: ${data}`));

// exec example

exec('ls -lh /usr', (error, stdout) => console.log(stdout));

NPM stands for Node Package Manager. It is the default package manager for Node.js and

is used to install, share, and manage reusable packages or libraries.

It comes pre-installed with Node.js and gives you access to a huge ecosystem of

open-source tools.

📌 Example Use:

npm install express

This command downloads the Express.js library into your project.

✅ NPM also:

• Manages package versions
• Handles dependencies
• Supports scripts to automate tasks (npm run build, npm test, etc.)

Answer: Avoid blocking the event loop. Use asynchronous APIs. Use clustering or worker threads. Cache results where possible. Profile and fix bottlenecks. Use load balancers for scaling horizontally.

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: EventEmitter is a core class that allows objects to emit named events and register listeners to respond.

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: Blocking happens when synchronous code takes too long, preventing other events from processing. Detect with tools like: clinic.js — Event Loop Delay tool. Manual timing (setInterval to check delay).

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.

Local Installation (default):

Installs the package into the node_modules folder of your current project.

npm install lodash

• ✅ Used when the package is needed as part of your app's code.

Global Installation:

Installs the package system-wide, making it available in the command line anywhere.

npm install -g nodemon

• ✅ Used for tools/CLI apps like nodemon, eslint, typescript, etc.

Answer: const EventEmitter = require('events'); const emitter = new EventEmitter(); emitter.on('greet', (name) => { console.log(`Hello, ${name}!`); }); emitter.emit('greet', 'Alice'); // Output: Hello, Alice!

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: Clustering runs multiple Node.js instances on different CPU cores sharing the same server port. This spreads load and uses full CPU capacity, increasing concurrency.

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.

• dependencies: These are required for your app to run in production.

📌 Example: express, mongoose

• devDependencies: Only needed during development (testing, building, linting).

📌 Example: nodemon, eslint, jest

📦 These are defined in package.json:

"dependencies": {

"express": "^4.18.0"

},

"devDependencies": {

"nodemon": "^3.0.0"

}

✅ Install a dev dependency with:

npm install nodemon --save-dev

Answer: pp.use((req, res, next) => { console.log('Middleware 1'); next(); }); pp.use((req, res, next) => { console.log('Middleware 2'); res.send('Done'); });

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: llowing it to handle thousands of concurrent connections efficiently without creating threads per connection.

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.

Semantic Versioning (semver) is a versioning system that uses the format:

MAJOR.MINOR.PATCH

Example: 2.5.3

• MAJOR: Breaking changes
• MINOR: New features, no breaking changes
• PATCH: Bug fixes, backwards-compatible

📌 Example:

If a package moves from 1.2.0 to 2.0.0, it likely has breaking changes.

In package.json, you might see:

"express": "^4.17.1"

• ^ means it can auto-update minor and patch versions, but not major ones.

Answer: Deploy multiple instances on different machines or containers. Use a load balancer to distribute traffic. Share state externally (e.g., Redis) since instances are stateless.

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: The cluster module lets you fork your Node.js process to create worker processes that share the same server port, improving CPU utilization. Testing Node.js Applications

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.

To update all packages to their latest safe versions based on semver:

npm update

To update a specific package to its latest version:

npm install express@latest

For a more interactive way:

npx npm-check-updates -u

npm install

✅ The npm-check-updates tool helps update versions in your package.json.

Answer: Global variables holding references. Event listeners not removed. Closures holding onto variables. Caches growing without limits. Security & Best Practices

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: Use rate limiting. Validate and sanitize inputs. Avoid blocking event loop. Use security middleware like helmet. Use a reverse proxy with DDoS protection.

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: pp.js const math = require('./mathUtils'); console.log(math.add(5, 3)); // 8 console.log(math.subtract(9, 4)); // 5 ✅ This is how you break your code into reusable pieces (modules) in Node.js. REST API Development in Node.js

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.

pplications. It uses standard HTTP methods to perform CRUD operations on resources,

which are typically represented as URLs.

✅ A RESTful API allows different systems (like frontend apps or mobile apps) to interact

with your server over HTTP in a stateless manner.

📌 Example:

• GET /users – Get all users
• POST /users – Create a new user
• PUT /users/1 – Update user with ID 1
• DELETE /users/1 – Delete user with ID 1

Answer: Ensuring incoming data matches expected format to avoid injection attacks, crashes, or invalid data storage.

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: Strip out dangerous characters. Use libraries like validator.js. Escape output in HTML contexts.

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: RESTful APIs use the following standard HTTP methods: Method Purpose GET Retrieve data POST Create new data PUT Update existing PATCH Partial update DELETE Remove data

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.

pp.use(cors({ origin: ' }));

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.

HTTP status codes indicate the result of a request:

Code Meaning

200 OK

201 Created

400 Bad Request

401 Unauthorized

403 Forbidden

404 Not Found

500 Internal Server Error

📌 Example:

res.status(201).json({ message: 'User created successfully' });

Answer: pp.use(express.json()); pp.get('/api/users', (req, res) => { res.json([{ id: 1, name: 'Alice' }]); }); pp.listen(3000, () => console.log('Server running'));

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: Validate file types and sizes. Store files outside of the web root. Use libraries like multer. Scan files for malware. REST API & Web Development

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: Use query parameters like ?page=2&limit=10 to return chunks of data instead of all at once.

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: pplications and APIs by handling routing, middleware, requests, responses, and more. ✅ It’s like jQuery for the backend — removes the boilerplate.

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: n operation is idempotent if repeating it has the same effect as doing it once (e.g., PUT). Important for safe retries.

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: pp.get('/users', (req, res) => { res.send('Get all users'); }); pp.post('/users', (req, res) => { res.send('Create user'); });

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 middleware like express-rate-limit to limit the number of requests per IP.

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: pp.get('/users/:id', (req, res) => { const id = req.params.id; res.send(`User ID: ${id}`); }); Request to /users/42 returns: User ID: 42

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: Websockets enable two-way real-time communication over a single TCP connection. Use libraries like socket.io.

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: pp.use(express.json()); This enables the app to read req.body in JSON POST/PUT 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.

Answer: Stateless: Each request is independent; no session stored on server. Stateful: Server keeps session info (like login status). Stateless apps scale easier. Testing & Debugging

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: PIs. ✅ Use the cors middleware: npm install cors const cors = require('cors'); pp.use(cors()); You can also customize it: pp.use(cors({ origin: ' }));

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: pp.use((req, res, next) => { console.log(`${req.method} ${req.url}`); next(); // Move to next middleware or route });

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: Use console.log for quick checks. Use node --inspect and Chrome DevTools. Use debuggers in IDEs (VSCode). Use profiling tools like clinic.js.

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: pp.use () Middleware for all requests pp.get () Handle only GET requests 📌 Example: pp.use(authMiddleware); // Runs on all routes pp.get('/data', handler); // Runs only for GET /data

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: Write tests before code, then develop just enough to pass tests. Use frameworks like Mocha or Jest.

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 libraries like nock to intercept and mock HTTP calls.

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: pp.use((req, res) => { res.status(404).json({ message: 'Route not found' }); });

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: Use tools like Apache JMeter, k6, or Artillery to simulate many users and measure performance. Ecosystem & Tools

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: pp.post('/users', body('email').isEmail(), (req, res) => { const errors = validationResult(req); if (!errors.isEmpty()) return res.status(400).json({ errors: errors.array() }); res.send('User created'); });

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: Node Version Manager lets you install and switch between Node.js versions easily.

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.

ll support schema-based and custom validations.

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: Uses semantic versioning: MAJOR.MINOR.PATCH. New major versions can include breaking changes.

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: uthorization: Bearer <token> The server verifies the token on every request.

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: npm: Default Node package manager. yarn: Faster installs, better caching. pnpm: Efficient disk usage by linking packages.

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: Babel: Transpiles modern JS to compatible versions. TypeScript: Adds static typing and compiles to JS.

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.

JWT (JSON Web Token) is a compact, URL-safe token used for securely transmitting

information.

• Consists of Header, Payload, and Signature
• Used to verify user identity and permissions

📌 Generate:

const jwt = require('jsonwebtoken');

const token = jwt.sign({ id: user.id }, 'secret', { expiresIn: '1h'

});

📌 Verify:

jwt.verify(token, 'secret');

Answer: pp.post('/upload', upload.single('file'), (req, res) => { res.send('File uploaded'); });

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: Use testing frameworks: Jest or Mocha for unit tests Supertest for HTTP API testing 📌 Example with Supertest: const request = require('supertest'); request(app) .get('/api/users') .expect(200) .then(res => { console.log(res.body); });

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.

pp.use(morgan('dev')); Logs every request with method, status, time, etc.

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 plural nouns in endpoints (/users, not /user)
• Use proper HTTP methods
• Send meaningful status codes
• Keep URLs simple and consistent
• Use pagination for large data
• Protect with authentication/authorization
• Use versioning (/api/v1/...)
• Validate and sanitize all inputs

NPM and module-related Node.js

interview questions