🚀 Node.js Comprehensive Guide

🔄 Why Node.js?

• ✅ Asynchronous & Non-blocking – Handles multiple requests efficiently without waiting.
• ✅ Fast Execution – Uses the V8 engine, making JavaScript execution extremely fast.
• ✅ Single Programming Language – JavaScript is used for both frontend and backend.
• ✅ Large Ecosystem – Rich package support via npm (Node Package Manager).
• ✅ Scalability – Suitable for real-time applications and microservices.

🔄 When to Choose Node.js:

• ✅ Real-time applications: Chat applications, online games, streaming services.
• ✅ I/O-bound applications
• ✅ Single-page applications
• ✅ Microservices
• ✅ Applications needing speed and scalability

🔄 How Node.js Handles 10,000 Concurrent Requests Efficiently?

• Node.js handles concurrency using a single-threaded, event-driven, non-blocking I/O model.
  Node.js handles many concurrent requests efficiently by using asynchronous callbacks, event loop, and background I/O operations.
  For truly parallel processing, you can scale with clusters or worker threads.
• ✅ Single-threaded, Event-driven Architecture - Uses one main thread to handle all incoming requests asynchronously using an event loop.
• ✅ Non-blocking I/O Operations - Network, file system, and database calls don't block the event loop. They're offloaded and callbacks are triggered once complete.
• ✅ Event Loop + Callback Queue - Listens for events (like data received, file read complete, etc.) and handle heavy or I/O-bound work to background threads (via libuv) and Picks up the results and executes the appropriate callback when ready., ensuring continuous processing without thread locking.
• ✅ Streaming Data (e.g., file uploads/downloads) - Handles large data using streams rather than loading the entire file into memory.
• ✅ Built-in Worker Threads for CPU-heavy Tasks - Heavy tasks (like image processing or data compression) can be offloaded using the worker_threads module to avoid blocking the main thread.
• ✅ Cluster Module for Multi-core Scaling - Node.js can fork multiple instances (workers) using the cluster module to utilize all CPU cores efficiently.

⚙️ LIBUV

• ✅ Core Node.js Library – Handles asynchronous I/O operations like file, network operations, events, etc.
• ✅ Thread Pool Management – Manages and utilizes a worker thread pool efficiently.
• ✅ Event Dispatcher – Manages and dispatches events to their appropriate callbacks.

🎯 Reactor Pattern

• ✅ The reactor pattern is one implementation technique of event driven architecture. Reactor parrern is used to avoid the blocking of IO operation.
• ✅ It is commonly used in high-performance, scalable applications such as web servers, real-time systems, and messaging platforms.
• ✅ Components:
  • 🔹 Reactor (Event Loop): net.createServer listens for connections.
  • 🔹 Event Demultiplexer: Managed internally by libuv.
  • 🔹 Handlers: socket.on('data') and socket.on('end').
• ✅ Flow of Execution:
  1. The Reactor starts and waits for I/O events (e.g., new client connections).
  2. An event occurs (e.g., client sends request), and the Reactor detects it.
  3. The Reactor dispatches the event to the appropriate handler.
  4. The handler processes the event and optionally sends a response.
• ✅ Node.js Foundation – Built on the Reactor Pattern using libuv.

💻 Code Example

const net = require('net');

const server = net.createServer((socket) => {
    console.log('Client connected');

    socket.on('data', (data) => {
        console.log('Received:', data.toString());
        socket.write('Echo: ' + data);
    });

    socket.on('end', () => {
        console.log('Client disconnected');
    });
});

server.listen(3000, () => {
    console.log('Server listening on port 3000');
});
    

🔄 How to Implement Security in Node.js?

• ✅ Use HTTPS – Encrypt data in transit with SSL/TLS certificates.
• ✅ Validate & Sanitize Input – Prevent SQL injection and XSS attacks.
• ✅ Use Helmet – Set secure HTTP headers in Express with helmet middleware.
• ✅ Limit rate of requests – Prevent brute-force attacks using express-rate-limit.
• ✅ Enable CORS properly – Restrict cross-origin requests using the cors middleware.
• ✅ Use Environment Variables – Store sensitive data securely.
• ✅ Implement Authentication & Authorization – Use JWT or OAuth for secure access.
• ✅ Set Security Headers – Use helmet middleware to protect against vulnerabilities.
• ✅ Use secure cookies – Set httpOnly, secure, and SameSite flags on cookies.
• ✅ Hash passwords securely – Use bcrypt or argon2, not plain text or weak hashes.
• ✅ Keep dependencies updated – Run npm audit or use snyk to fix known vulnerabilities.
• ✅ Limit file uploads – Validate file types and sizes, store in secure folders.
• ✅ Implement role-based access control (RBAC) – Restrict access based on user roles.
• ✅ Log and monitor – Use logging tools (like winston) and monitor suspicious activities.
• ✅ Use Helmet to prevent XSS (Cross Side Scripting)
• ✅ Use CSRF library to prevent Cross Side req forgery

🔄 Node.js Features

• ✅ Event-driven & Non-blocking – Uses an asynchronous model for handling requests efficiently.
• ✅ Cross-platform – Runs on Windows, Linux, and macOS.
• ✅ Built-in Package Manager (npm) – Access to thousands of reusable libraries.
• ✅ Microservices-friendly – Ideal for building scalable and distributed systems.
• ✅ Streaming Support – Efficiently handles large file uploads and downloads.

🔄 How to Increase Node.js Performance

• ✅ Use Asynchronous Code - Avoid blocking methods like fs.readFileSync();
• ✅ Use Streams for Large Files.
• ✅ Use Clustering or PM2 - Run your app on all CPU cores.
• ✅ Implement Caching (Redis/In-memory) - To reduce database load and speed up responses.
• ✅ Use Nginx or Load Balancers - Let reverse proxies handle SSL, compression, and load balancing efficiently.
• ✅ Write Efficient Database Queries - Use indexes, projections, and avoid unnecessary joins or data fetching.
• ✅ Increase libuv Thread Pool - Handle more concurrent I/O tasks by setting: UV_THREADPOOL_SIZE=64 node app.js
• ✅ Optimize Middleware Usage - Use only necessary middleware in Express; avoid global usage unless required.
• ✅ Avoid Memory Leaks - Track memory usage using tools like clinic.js, heapdump, or --inspect.
• ✅ Monitor and Profile Your App - Use tools like PM2, Datadog, Prometheus, or Chrome DevTools to track performance in real time.

🔄 How to track memory leaks?

Memory leaks occur when an application allocates memory but fails to release it when it's no longer needed, leading to a gradual increase in memory usage and potentially crashing the application.

Common Causes:

• ✅ Un-removed event listeners
• ✅ Un-released resources (e.g., file handles, database connections)

Tools for Detection

• ✅ 1. Chrome DevTools (--inspect)
• ✅ 2. heapdump Module
• ✅ 3. clinic.js (by NearForm)
• ✅ 4. pm2 Monitoring
• ✅ 5. memwatch-next (or node-memwatch)
• ✅ 6. node --trace-gc
• ✅ 7. process.memoryUsage()

How to avoid Leakage:

• ✅ 1. Avoid Unused Global Variables
• ✅ 2. Properly Manage Event Listeners
• ✅ 3. Clear Timers and Intervals
• ✅ 4. Use Weak References Where Appropriate
• ✅ 5. Limit and Clear Caches

🔄 How to handle Back Pressure of stream in event loop?

Back pressure occurs when the producer (e.g., a readable stream) sends data faster than the consumer (e.g., a writable stream)

❌ Problem:

A Readable Stream (fast producer)
A Writable Stream (slow consumer)

The producer is pushing data every 10ms, but the consumer is only able to consume every 100ms. This will:

Eventually crash your app if the stream buffer overflows.

✅ How to handle?

1. In Node JS stream, if you use pipe() method, it will automatically automatically manages back pressure — it pauses the readable stream when the writable stream is not ready to receive data.

2. If you're not using pipe(), you should manually do pause when the consumer is full and resume when it's ready again. write() method will return true / false. On drain event - resume when the writable stream is drained.

🔄 Explain Event Loop Phases:

🧰 Node.js util Package

The util module in Node.js is a built-in core module that provides utility functions helpful for working with asynchronous code, debugging, and formatting.

You don’t need to install it — just require it:

const util = require('util');

🛠️ Common use cases include:

• 🔄 util.promisify — Convert callback-based functions to Promise-based ones
• ↩️ util.callbackify — Convert Promise-based functions back to callback-style
• 📝 util.format — Create formatted strings (like printf in C)
• 🔍 util.inspect — Display objects in a readable format (great for debugging)
• ✅ util.types — Perform type checking (e.g., isDate, isRegExp)

📌 Example: Using util.promisify with fs.readFile

const fs = require('fs');
	const util = require('util');
	const readFile = util.promisify(fs.readFile);

	readFile('./file.txt', 'utf8')
	  .then(data => console.log(data))
	  .catch(err => console.error(err));

📌 Example: Using util.callbackify to convert an async function

const util = require('util');

	async function fetchData() {
		return 'Fetched Data';
	}

	const callbackStyle = util.callbackify(fetchData);

	callbackStyle((err, result) => {
		if (err) throw err;
		console.log(result); // Fetched Data
	});

📌 Example: Creating a reusable utility function with util.format

// utils/logger.js
	const util = require('util');

	function logInfo(name, value) {
		const message = util.format('INFO: %s has a value of %d', name, value);
		console.log(message);
	}

	module.exports = { logInfo };

	// usage in another file
	const { logInfo } = require('./utils/logger');
	logInfo('Speed', 80);

🚀 Use the util package when:

• ⚙️ Working with legacy callback code
• 🔧 Debugging or inspecting complex objects
• 🔁 Converting between callback and Promise styles
• 🧹 Creating reusable, consistent logging and debugging helpers

🔄 Microtasks (nextTick, Promises) Are Prioritized Between Phases

The event loop in Node.js runs in multiple phases to handle asynchronous operations. Within these phases, microtasks (such as `process.nextTick()` and Promises) have higher priority over macrotasks (like `setTimeout()` and `setImmediate()`). This means microtasks will be executed before timers and I/O callbacks, even if they were queued after them.

Code Example:

setTimeout(() => console.log('timeout'), 0);
	setImmediate(() => console.log('immediate'));
	Promise.resolve().then(() => console.log('promise'));
	process.nextTick(() => console.log('nextTick'));

Execution Order:

nextTick
	promise
	timeout
	immediate

Explanation:

• process.nextTick() is executed first because it's part of the microtask queue, which has higher priority than timers or I/O callbacks.
• Promise (microtask) is then executed right after the `nextTick`.
• setTimeout() and other timers are queued in the timers queue, which runs after microtasks are completed.
• setImmediate() is queued in the check phase (part of the I/O callbacks), which runs after the timers queue.

✅ Diagram Summary:

	 JS Code
		↓
	┌─────────────┐
	│ Call Stack  │ ← Synchronous code runs here
	└─────────────┘
		↓
	Async functions offloaded to:
	┌────────────────────┐
	│  Node APIs (libuv) │ ← I/O, Timers, etc.
	└────────────────────┘
		↓
	Callback queues:
	┌───────────────┬───────────────┬───────────────┐
	│ Microtasks    │ Timers        │ I/O Callbacks │
	│ (Promises,    │ (setTimeout)  │ (fs, net)     │
	│ nextTick)     │               │               │
	└───────────────┴───────────────┴───────────────┘
		↓
	┌─────────────┐
	│ Event Loop  │ ← Picks & executes tasks
	└─────────────┘
		

🔍 Key Points:

• Microtasks (like `process.nextTick()` and Promises) are executed before any I/O callbacks or timers, even if they were added after them in the event loop.
• Microtasks are processed after the execution of each phase in the event loop.
• Understanding this priority helps in debugging Node.js applications, especially in real-time applications where timing is crucial.

🚀 How is Node.js Most Commonly Used?

Node.js is a powerful JavaScript runtime built on Chrome's V8 engine. It's widely used for building fast, scalable, and real-time applications — especially those that are I/O-intensive.

💼 Common use cases for Node.js include:

• 🌐 Web servers and RESTful APIs — Ideal for building backend services that respond to HTTP requests
• 💬 Real-time applications — Like chat apps, notifications, and live updates using WebSockets (e.g., with Socket.io)
• 🛍️ eCommerce platforms — Handling multiple user requests, carts, checkouts in real-time
• 📦 Microservices architecture — Lightweight services that scale independently
• ⚙️ Command-line tools — Using Node.js for scripts, automation, and dev tooling (e.g., ESLint, Webpack)
• 📡 API Gateway and Proxy servers — Forwarding requests between services and performing edge logic
• 🧠 Streaming applications — Processing data streams (e.g., video, audio, logs) using Node's stream API
• 📈 Server-side rendering (SSR) — Using frameworks like Next.js for SEO-friendly dynamic pages

💡 Why Node.js?

• ⚡ Non-blocking I/O and event-driven architecture
• 🧩 Uses JavaScript on both frontend and backend
• 🧱 Massive ecosystem (npm modules)
• 📊 Great performance for real-time, data-heavy applications

🔚 In short: Node.js is best suited for building fast, scalable network applications — especially those that rely heavily on asynchronous I/O operations.

🔄 What is I/O in Node.js?

In Node.js, I/O (Input/Output) refers to any operation that involves reading from or writing to external resources.

Common I/O operations in Node.js include:

• 📂 Reading from or writing to files (using the fs module)
• 🌐 Handling HTTP requests and responses (e.g., creating web servers)
• 🗄️ Communicating with databases (e.g., MongoDB, MySQL)
• 📨 Sending or receiving data over the network (e.g., WebSockets, TCP/UDP)
• 🖥️ Interacting with the system (stdin, stdout, environment variables)

💡 Node.js is designed around non-blocking asynchronous I/O, which means it can perform I/O operations in the background and continue executing other code without waiting for the I/O to finish.

🚀 This is made possible by the libuv library and the event loop, allowing Node.js to be highly performant and scalable, especially for I/O-heavy applications.

📌 Example: Reading a file asynchronously

const fs = require('fs');

	fs.readFile('example.txt', 'utf8', (err, data) => {
		if (err) throw err;
		console.log(data);
	});

	console.log('File read initiated...');

🔁 The above code starts reading the file, moves on immediately, and logs the content once it's ready — this is non-blocking I/O in action.

🧼 How to Write Clean and Maintainable Node.js Code

Writing clean and maintainable code in Node.js helps teams scale, reduces bugs, and makes your codebase easier to understand and extend.

Here are some best practices to follow:

📁 1. Follow a Clean Project Structure

• Organize your code into folders: routes, controllers, services, middlewares, models
• Use an entry point file like server.js or app.js
• Group related logic (e.g., each feature or module gets its own folder)

🧠 2. Use Meaningful Naming

• Use descriptive variable and function names
• Avoid single-letter names unless in small scopes (e.g., loops)
• Stick to a consistent naming convention (e.g., camelCase for variables and functions)

📦 3. Modularize Your Code

• Break large files into smaller, reusable modules
• Use require or import/export to separate concerns
• Keep your functions small and focused (Single Responsibility Principle)

🛡️ 4. Add Error Handling

• Always handle async errors with try/catch or middleware
• Use centralized error-handling middleware for Express apps
• Don’t expose stack traces in production

✅ 5. Write Unit & Integration Tests

• Use tools like Jest, Mocha, Supertest
• Test controllers, services, and utility functions
• Write meaningful test cases, not just happy paths

📐 6. Follow Linting and Formatting Rules

• Use ESLint with a config like Airbnb or Standard
• Use Prettier for auto-formatting
• Add a .editorconfig to enforce consistent settings across editors

📖 7. Document Your Code

• Use JSDoc-style comments for functions
• Maintain a helpful README.md for every project
• Explain complex logic with inline comments (avoid obvious comments)

🚦 8. Use Environment Variables

• Store config values in a .env file (e.g., port, database URI, API keys)
• Use the dotenv package to load env variables securely

📊 9. Monitor & Log Properly

• Use structured logging (e.g., winston, pino)
• Log meaningful messages, not just console outputs
• Track errors and performance using monitoring tools (e.g., Sentry, New Relic)

🧪 10. Stick to Consistent Code Style

• Choose a style guide (e.g., Airbnb, StandardJS)
• Use code formatters and linters on pre-commit (e.g., via Husky)
• Review code via PRs and ensure style consistency across the team

✅ Bonus Tips:

• Use async/await instead of callbacks
• Cache repeated logic (e.g., use Redis for heavy DB calls)
• Limit code duplication using helper functions or utilities
• Adopt SOLID principles and design patterns

🧠 Clean Node.js code = easier to debug, faster to extend, and loved by your future self (or your team)!

🔗 Inter-Service Communication in Microservices

• ✅ Synchronous Communication (Request-Response)
  • 🔹 One service calls another via HTTP or gRPC and waits for a response.
  • 🔹 Use When: You need an immediate response or services rely on real-time coordination.
• ✅ Asynchronous Communication (Event-Driven)
  • 🔹 One service emits an event; others react to it asynchronously.
  • 🔹 Use When: Loose coupling is preferred or an immediate response isn't required.
  • 🔹 Common Use Cases: Logging, Notifications, Order Processing, etc.
  • 🔹 Message Brokers:
    • 📦 RabbitMQ – Use with amqplib
    • 🌀 Apache Kafka – Use with kafkajs
    • 🚀 Redis Pub/Sub – Use with bullmq

⚖️ Load Balancing & 🚀 Caching in Distributed Node.js Systems

• ✅ Load Balancer
  • 🔹 Distributes user requests across multiple servers to prevent overload.
  • 🔹 Ensures high performance, scalability, and reliability under heavy traffic.
  • 🔹 Automatically redirects traffic to healthy servers if one goes down, improving uptime.
  • 🔹 Strategies include: Round-Robin, Least Connections, IP Hashing.
  • 🔹 Common Tools: NGINX, HAProxy, and cloud options like AWS ELB, GCP Load Balancer.
• ✅ Caching
  • 🔹 Temporarily stores frequently accessed data to avoid repeated expensive operations (e.g., DB queries).
  • 🔹 Boosts response time and reduces backend/database load.
  • 🔹 Popular Tools in Node.js:
    • 🧠 Redis
    • 💾 Memcached
    • ⚡ node-cache, lru-cache
  • 🔹 Data is managed using TTL (Time-To-Live) or manual invalidation.
  • 🔹 Ideal for: API responses, frequent DB queries, and session/token storage.

🛒 Scalable Microservices-based eCommerce Backend (Node.js)

• ✅ DevOps & Deployment
  • 🐳 Containerize all services with Docker.
  • 🧪 Use Kubernetes or Docker Compose for local development and testing.
  • ⚙️ CI/CD with GitHub Actions, GitLab CI, or Jenkins.
  • 📋 Logging: Winston, Elastic Stack, or LogDNA.
  • 📈 Monitoring: Prometheus, Grafana, New Relic, Datadog.
• ✅ Microservices Architecture

  
  ┌─────────────────────┐
  │     API Gateway     │
  │  (Node.js + Express)│
  └────────┬────────────┘
           │
   ┌───────┼────────────────────────────────────────────────────────────┐
   ↓       ↓               ↓               ↓              ↓             ↓
  User   Product        Order           Payment         Cart         Services
  Svc     Svc           Svc              Svc            Svc
  (Node) (Node)        (Node)           (Node)         (Node)
  
   ↑       ↑               ↑               ↑              ↑
  Mongo  Mongo           Mongo         Stripe API     Redis/Mongo
  
           ↘       ↙         ↓               ↓              ↓
          ┌────────────────────────────────────────────────────────────┐
          │       Message Queue / Event Bus (e.g., RabbitMQ, Kafka)     │
          └────────────────────────────────────────────────────────────┘
              

• ✅ 🧱 Monorepo Project Structure

  
  project-root/
  │
  ├── api-gateway/
  │   ├── Dockerfile
  │   ├── package.json
  │   └── src/
  │
  ├── user-service/
  │   ├── Dockerfile
  │   ├── package.json
  │   └── src/
  │
  ├── product-service/
  │   ├── Dockerfile
  │   ├── package.json
  │   └── src/
  │
  ├── cache/
  │   └── redis.conf
  │
  ├── nginx/
  │   └── nginx.conf
  │
  ├── docker-compose.yml
  └── README.md
              

🧪 Testing with Mocha & Chai

• ✅ Mocha
  • 📘 Mocha is a popular JavaScript testing framework for writing and running test cases.
  • 🔄 Supports both synchronous and asynchronous testing.
  • 🧱 Provides test structuring functions: describe(), it(), before(), after()
• ✅ Chai
  • 📗 Chai is a powerful assertion library for JavaScript testing.
  • 🧪 Supports both BDD (Behavior-Driven Development) and TDD (Test-Driven Development).
  • 🧰 Provides three assertion styles:
    • expect → expect(value).to.equal(expectedValue);
    • should → value.should.equal(expectedValue);
    • assert → assert.equal(value, expectedValue);
• ✅ TDD (Test-Driven Development)
  • Test-Driven Development (TDD) is a software development process where you:
  • 🧠 Write tests before writing actual implementation code.
  
  
  • 📉 Follow the Red → Green → Refactor cycle:
    • Write a failing test for a new feature.
    • Write code to make the test pass.
    • Refactor the code while keeping tests green.
  • 🧪 Example with Mocha & Chai:

    // math.test.js
        const { expect } = require('chai');
        const { add } = require('../src/math');
        
        describe('add()', () => {
          it('should return 5 when adding 2 and 3', () => {
            expect(add(2, 3)).to.equal(5);
          });
        });
        

  •                             
        const { expect } = require('chai');
        const { add, isEmail } = require('../src/utils');
        
        describe('Utils Functions', () => {
            describe('add()', () => {
            it('should return 7 for add(3, 4)', () => {
                expect(add(3, 4)).to.equal(7);
            });
        
            it('should return -1 for add(-2, 1)', () => {
                expect(add(-2, 1)).to.equal(-1);
            });
            });
        
            describe('isEmail()', () => {
            it('should return true for a valid email', () => {
                expect(isEmail('prashant@example.com')).to.be.true;
            });
        
            it('should return false for invalid email', () => {
                expect(isEmail('prashant.com')).to.be.false;
            });
            });
        });
                                    
                                
                            

📡 Understanding HTTP Status Codes

• 🟢 2xx – Success – The request was successfully received, understood, and accepted.
• ✅ 200 OK – Standard response for successful requests (GET, PUT, DELETE, etc.).
  Example: Successfully fetched or updated a resource.
• ✅ 201 Created – Indicates that a resource has been successfully created (POST).
  Example: New user, product, or order created.
• ✅ 204 No Content – The request was successful, but there's no content to return.
  Example: Resource successfully deleted.
• 🔴 4xx – Client Errors – Something is wrong with the request.
• ❌ 400 Bad Request – Malformed request or missing data.
  Example: Missing required fields or invalid input.
• 🔐 401 Unauthorized – Authentication is required and either missing or invalid.
  Example: Accessing protected route without a valid token.
• 🚫 403 Forbidden – Authenticated but not permitted to access the resource.
  Example: Non-admin trying to access admin-only route.
• 🔎 404 Not Found – The requested resource doesn't exist.
  Example: Invalid user or product ID.
• ⚠️ 409 Conflict – Conflict with the current state of the resource.
  Example: Duplicate email during registration.
• 🔥 5xx – Server Errors – The server failed to fulfill a valid request.
• 💥 500 Internal Server Error – General server error, something unexpected failed.
  Example: Uncaught exception in backend code.
• 🌐 502 Bad Gateway – Gateway or proxy got an invalid response from the upstream server.
  Example: API gateway forwarding to a broken service.
• 🛠️ 503 Service Unavailable – Server is currently unavailable (maintenance or overload).
  Example: Downtime due to server upgrades.

🚀 How to Handle Performance Bottlenecks in Node.js

• 🔍 Identify the Bottleneck
  • 🔹 Built-in Tools: console.time() / console.timeEnd() for measuring specific code blocks.
  • 🔹 Node.js Profiler: Use --inspect with Chrome DevTools.
  • 🔹 Monitoring Tools: PM2, Datadog, AppDynamics, New Relic.
  • 🔹 Advanced Profilers: clinic.js
• 🛠️ Common Bottlenecks and Fixes
  • 🧵 Blocking the Event Loop
    • 🔹 Node.js is single-threaded, so heavy computations block all requests.
    • 🔹 Fix: Offload tasks using worker_threads or child_process.
  • 📦 Slow Database Queries
    • 🔹 Use proper indexes and optimize queries.
    • 🔹 Use connection pooling to reduce latency.
    • 🔹 Cache frequent results with Redis or in-memory stores.
  • 🌐 Inefficient HTTP Calls or APIs
    • 🔹 Enable HTTP keep-alive for persistent connections.
    • 🔹 Use Promise.all to avoid sequential calls.
    • 🔹 Implement retries, timeouts, and circuit breakers (axios-retry, opossum).
  • 📄 Large Payloads or Memory Leaks
    • 🔹 Compress responses using middleware like compression.
    • 🔹 Avoid storing large data in memory.
    • 🔹 Use heap snapshots with --inspect or heapdump to analyze leaks.
  • 🧩 Too Many Synchronous Operations
    • 🔹 Avoid blocking calls like fs.readFileSync in production.
    • 🔹 Convert to async/promise-based versions.

🛠️ How to Design Scalable RESTful APIs in Node.js

• ✅ Modular Project Structure
  • 🔹 Separate concerns for maintainability and scalability.
  • 🔹 Example structure:

    /project-root
    	│
    	├── /src
    	│   ├── /routes       # Route definitions
    	│   ├── /controllers  # Request handlers
    	│   ├── /services     # Business logic
    	│   ├── /models       # Database models
    	│   ├── /middleware   # Authentication, error handling, logging
    	│   ├── /utils        # Helper functions
    	│   └── /config       # Environment configs
    	│
    	├── app.js            # Express app setup
    	└── server.js         # Server entry point
    						

• ✅ Standard HTTP Methods & Routes
  • 🔹 Use RESTful conventions: GET, POST, PUT, DELETE
  • 🔹 Meaningful endpoints like /api/v1/users/:id
• ✅ Express Framework
  • 🔹 Lightweight, fast, and easy to integrate middleware and routes.
• ✅ Authentication & Authorization
  • 🔐 JWT Tokens – Stateless and secure authentication.
  • 🔐 Role-Based Access – Middleware restricts access for roles like admin, user, etc.
• ✅ Reusable Middleware
  • 🔹 Centralized logic for authentication, logging, error handling, etc.
  • 🔹 Promotes DRY (Don't Repeat Yourself) principle.
• ✅ Input Validation
  • 🔹 Use express-validator to sanitize and validate incoming data.
  • 🔹 Protects against bad/malicious inputs.
• ✅ Logging
  • 🔹 Use winston or morgan for request and error logging.
• ✅ Scalability Techniques
  • 🧵 Use Node.js cluster module to take advantage of multi-core systems.
  • 🌐 Use Nginx or a cloud Load Balancer to distribute incoming requests.
• ✅ API Documentation
  • 📘 Use Swagger (OpenAPI) for documenting and testing APIs.
• ✅ API Versioning
  • 🔹 Maintain backward compatibility with routes like /api/v1/users.
  • 🔹 Helps in gradual evolution of APIs without breaking existing clients.

🌐 What is a REST API?

• ✅ REST stands for Representational State Transfer.
• ✅ It is an architectural style for designing networked applications.
• ✅ RESTful APIs use standard HTTP methods like:
  • 🔹 GET – Retrieve data from the server
  • 🔹 POST – Send new data to the server
  • 🔹 PUT – Update existing data on the server
  • 🔹 DELETE – Remove data from the server
• ✅ REST APIs are stateless – each request contains all the necessary information to complete it.
• ✅ Typically, JSON is used to exchange data between client and server.
• ✅ In Node.js, Express.js is widely used to create REST APIs quickly and efficiently.
• ✅ Each endpoint in the API represents a resource (e.g., /users, /products).
• ✅ Middleware in Express handles authentication, validation, error handling, and more.

⚙️ What is CI/CD?

• ✅ CI/CD stands for Continuous Integration and Continuous Deployment (or Delivery).
• ✅ It is used in modern software development to build, test, and deliver code quickly and reliably.
• 🔄 CI – Continuous Integration
  • 🔹 Developers push code frequently (usually to a shared branch).
  • 🔹 Each push automatically triggers:
    • 🔸 Build process
    • 🔸 Unit & integration tests
    • 🔸 Linting (code quality checks)
  • 🔹 It helps to catch bugs early and ensures code works properly.
  • 🔹 Example tools: GitHub Actions, Jenkins, CircleCI


• 🚀 CD – Continuous Delivery / Deployment
  • 🚚 Continuous Delivery
    • 🔸 After CI, the app is ready to be deployed at any time.
    • 🔸 Deployment is manual, but the app is fully prepared for release.
  • 🚀 Continuous Deployment
    • 🔸 Deployment happens automatically after tests pass.
    • 🔸 No manual approval — code goes live instantly.
• ✅ Benefits of CI/CD
  • 🕒 Faster releases
  • 🐞 Fewer bugs in production
  • 🔁 Easy rollbacks
  • 🧑‍🤝‍🧑 Better collaboration
  • 🤖 Consistent & automated process

☁️ What Cloud Services Have You Used?

• ✅ AWS: EC2, S3, Lambda, RDS, CloudWatch, ECS, API Gateway, IAM
• ✅ Google Cloud Platform (GCP): Compute Engine, Firebase, Firestore, Cloud Functions
• ✅ Azure (basic level): App Service, Azure DevOps

🚀 How Do You Deploy and Monitor Node.js Apps in the Cloud?

Deployment

• ✅ Use Docker containers deployed via AWS ECS, EC2, or GCP Compute Engine
• ✅ Set up reverse proxies using Nginx or AWS ALB
• ✅ Use PM2 or Docker Compose for process management during testing/staging
• ✅ Automate deployments with GitHub Actions, Jenkins, or Cloud Build

Monitoring

• ✅ Use CloudWatch for logs, metrics, and alarms (AWS)
• ✅ PM2 Monitoring for local/staging environments
• ✅ Use Application Performance Monitoring (APM) tools like New Relic, Datadog, or Sentry
• ✅ Set up Health checks via uptime monitoring services or custom /health endpoints

⚙️ What CI/CD Tools Have You Used?

• ✅ GitHub Actions: For build, test, lint, Docker build & push, and deployment
• ✅ Jenkins: For custom pipelines with scripted stages and Jenkinsfiles
• ✅ CircleCI: For fast container-based builds, mainly with microservices
• ✅ GitLab CI (basic experience): For integrated CI/CD pipelines in GitLab-hosted projects

🔐 What is SAML?

SAML (Security Assertion Markup Language) is a standard that allows users to log in once and access multiple websites or services without needing to re-enter credentials.

It works by using an identity provider (IdP) to authenticate the user and then sending a secure "SAML assertion" to the service provider (SP) to confirm the user's identity.

This enables Single Sign-On (SSO), improving security and user convenience.

The process involves the IdP verifying the user, creating a SAML token, and passing it to the SP for access.

🧵 Node.js Cluster Module

• ✅ The cluster module provides a way to create multiple child processes (workers) that can run simultaneously and share the same server port.
• ✅ These child processes are known as worker processes.
• ✅ Communication between the master process and worker processes using IPC (Inter-Process Communication).
• ✅ Workers are created using the cluster.fork() method.
• ✅ In a cluster setup:
  • Master process: Manages workers.
  • Worker processes: Handle incoming requests.

💡 Advantages of Using Cluster Module

• ✅ Fault Tolerance – If one worker crashes, others keep running.
• ✅ Load Balancing – Requests can be distributed among multiple workers.
• ✅ Scalability – Easily utilize multiple CPU cores.
• ✅ Parallel Processing – Workers run independently and handle tasks in parallel.

	const cluster = require('cluster');
	const http = require('http');
	const os = require('os');

	const numCPUs = os.cpus().length;

	if (cluster.isMaster) {
	  console.log(`Master process PID: ${process.pid}`);
	  
	  for (let i = 0; i < numCPUs; i++) {
		cluster.fork();
	  }

	  cluster.on('exit', (worker, code, signal) => {
		console.log(\`Worker \${worker.process.pid} died\`);
		console.log('Starting a new worker...');
		cluster.fork(); // Restart the worker
	  });

	} else {
	  http.createServer((req, res) => {
		res.writeHead(200);
		res.end(\`Handled by worker \${process.pid}\`);
	  }).listen(3000);

	  console.log(\`Worker process PID: \${process.pid} is running\`);
	}
    

🔀 Child Process vs Worker Thread

🌐 API Gateway

An API gateway is a software intermediary that manages interactions between clients and applications.

• It will be single entry point for API calls, routing requests to the appropriate services.
• It manages API requests, including authentication, authorization, and load balancing

Key Functions of an API Gateway:

• Routing: Directs client requests to the appropriate microservice.
• Authentication: Handles authentication and authorization for services.
• Rate Limiting: Controls the number of requests a client can make to prevent abuse.
• Load Balancing: Distributes client requests across multiple instances of a service.
• API Aggregation: Combines responses from multiple services into a single response for the client.
• Request/Response Transformation: Modifies the data sent to/from the client and microservices.
• Caching: Stores frequent requests to reduce load on services and improve response times.
• Logging & Monitoring: Tracks and logs requests for analysis, error tracking, and performance monitoring.

Example Tools for API Gateway:

• Kong
• AWS API Gateway
• Nginx
• Zuul
• Express Gateway

🚧 Challenges Faced in Our Last eCommerce Project & Solutions

🚧 What are difficult situations you faced ?

🤝 How do you resolve conflicts in a team setting?

👨‍🏫 Give an example of a time you mentored a junior developer.

• ✅ We have Onboarded a junior developer, he was new to Node.js and backend development.
• ✅ I have paired with him during code reviews to explain logic and share understandings (like error handling, async flows, modular design).
• ✅ Also assigned small tasks aligned with their learning goals.
• ✅ I have created internal documentation for project.
• ✅ I have noticed, he has improvements in their code quality and delivery speed over time.

🕒 How do you ensure on-time delivery and code quality in a sprint cycle?

• ✅ Clear Sprint Planning: Define well-scoped, prioritized, and achievable tasks.
• 📋 User Story Breakdown: Split stories into small, testable tasks with clear acceptance criteria.
• 👥 Daily Stand-ups: Track progress, remove blockers, and ensure alignment.
• 🧪 Test-Driven Development (TDD): Write tests before code to ensure reliability.
• 🔍 Code Reviews: Enforce peer reviews for quality, consistency, and learning.
• 🛠 CI/CD Pipelines: Automate testing, linting, and deployment to catch issues early.
• 🧹 Refactoring Time: Allocate time to clean up and optimize code.
• 📊 Velocity Tracking: Use sprint metrics to plan realistically and avoid overcommitment.
• 🚨 Definition of Done (DoD): Ensure stories meet quality, test, and documentation standards.
• 🧠 Retrospectives: Reflect and improve process after each sprint.

🤝 What is your approach to code reviews and collaboration?

• 👀 Review for Understanding: Understand the logic and purpose first.
• ✅ Clarity & Simplicity: Keep code clean, readable, and maintainable.
• 🔍 Edge Cases & Bugs: Spot missing validations or tricky flows.
• 🧪 Test Coverage: Ensure proper tests exist and pass.
• 📦 Follow Best Practices: Enforce project standards and naming conventions.
• 💬 Respectful Feedback: Focus on code, not individuals.
• 🤝 Encourage Discussion: Open to alternatives and deeper conversations.
• 📚 Learn Together: Use reviews to share and absorb knowledge.
• 🔄 Continuous Improvement: Evolve with feedback.
• 🧑‍🤝‍🧑 Pair When Needed: Collaborate for tricky or critical tasks.

🔥 How do you manage pressure from stakeholders and tight deadlines?

• 🧭 Prioritize Tasks: Focus on what matters most.
• 🗣 Set Expectations Early: Communicate clearly with stakeholders.
• 📆 Break Work Into Milestones: Show steady progress.
• ⏱ Time Management: Protect deep work time and minimize distractions.
• 🔄 Stay Flexible: Adapt when needed without losing momentum.
• 🆘 Ask for Help: Escalate early and collaborate to unblock.
• 📢 Transparent Communication: Keep stakeholders informed honestly.
• 🔍 Avoid Scope Creep: Document new asks for later.
• 😌 Stay Calm: Breathe, focus, and keep your cool.
• 📈 Continuous Learning: Improve estimation and planning over time.

🌟 How do you keep your team motivated during low-morale phases?

• 💬 Open Communication: Foster trust and space to speak freely.
• 🙌 Recognize Efforts: Celebrate small and big wins.
• 🎯 Refocus on Purpose: Reconnect with the mission.
• 🛠 Remove Roadblocks: Proactively help resolve issues.
• 🤝 Support Each Other: Promote empathy and peer collaboration.
• 🌱 Growth Opportunities: Encourage skill development and ownership.
• 🧘 Balance Workload: Avoid burnout with fair task distribution.
• 🎉 Add Fun: Introduce team games or casual breaks.
• 🔄 Be Transparent: Share progress and updates honestly.
• 🧭 Lead by Example: Show calmness and resilience.

🧠 What is a Generator?

A Generator is a special type of function in JavaScript that you can pause and resume. Unlike normal functions that run from start to end immediately, generators let you produce values one at a time — perfect for handling sequences or large data in chunks.

• function* defines a generator function.
• yield is used to pause the function and return a value.

📦 How to Use It?

	// Define a generator function
	function* greetings() {
	  yield "Hi";
	  yield "How are you?";
	  yield "Bye";
	}

	// Create generator object
	const gen = greetings();

	console.log(gen.next()); // { value: 'Hi', done: false }
	console.log(gen.next()); // { value: 'How are you?', done: false }
	console.log(gen.next()); // { value: 'Bye', done: false }
	console.log(gen.next()); // { value: undefined, done: true }
		

Each time you call gen.next(), it resumes the generator and runs until the next yield.

When there are no more values to yield, done: true is returned.

⏱️ Debouncing & Throttling

🧘 Debouncing

• ✅ Goal: Delay function execution until a certain period has passed since the last call.
• ✅ Use Cases: Search inputs, window resize, preventing button spam.
• ✅ How it works:
  • Clears previous timer each time the function is triggered.
  • Executes only after the specified delay has passed without re-trigger.
• ✅ Example:

function debounce(fn, delay) {
  let timer;
  return function (...args) {
    clearTimeout(timer);
    timer = setTimeout(() => fn.apply(this, args), delay);
  };
}

// Usage
window.addEventListener('resize', debounce(() => {
  console.log('Resized!');
}, 300));
  

🏃 Throttling

• ✅ Goal: Ensure a function is only called once every specified interval.
• ✅ Use Cases: Scroll events, mousemove tracking, infinite scroll.
• ✅ How it works:
  • Executes the function immediately, then blocks further calls for the defined duration.
• ✅ Example:

function throttle(fn, limit) {
  let inThrottle;
  return function (...args) {
    if (!inThrottle) {
      fn.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

// Usage
window.addEventListener('scroll', throttle(() => {
  console.log('Scrolled!');
}, 200));
  

⚖️ Difference: some() vs every()

[1, 2, 3].some(n => n > 2)
// true

[1, 2, 3].every(n => n > 0)
// true

[1, 2, 3].some(n => n > 2)
// true

[1, 2, 3].every(n => n > 0)
// true

✅ Summary

• some() is like "Does **anyone** pass the test?"
• every() is like "Does **everyone** pass the test?"

🔍 Array.find() & Array.findIndex()

✅ Array.prototype.find()

• ✅ Goal: Return the **first element** in the array that satisfies a condition.
• ✅ Returns: The matching element, or undefined if not found.
• ✅ Example:

const numbers = [4, 9, 16, 25];
const found = numbers.find(num => num > 10);
console.log(found); // 16
  

📍 Array.prototype.findIndex()

• ✅ Goal: Return the **index** of the first element that satisfies a condition.
• ✅ Returns: The index, or -1 if not found.
• ✅ Example:

const items = ['apple', 'banana', 'cherry'];
const index = items.findIndex(fruit => fruit.startsWith('b'));
console.log(index); // 1
  

🧠 Use Cases

• ✅ Find specific object in array (e.g., user with ID).
• ✅ Get position of item to update or remove.

🗝️ express-session Overview

✅ What express-session Does:

• ✅ Generates a unique session ID for each client.
• ✅ Saves session data on the server side (e.g., user info, login status).
• ✅ Stores the session ID in a cookie (connect.sid) on the client.
• ✅ Automatically links each incoming request with the stored session data via the cookie.

🔄 Typical Flow in a Login System:

1. Client sends a login request to /login.
2. Server validates user credentials.
3. If login is successful:

// Server-side code
req.session.user = { id: user._id, name: user.name };
  

🧾 Server sends back a response with a cookie:

Set-Cookie: connect.sid=somerandomsessionid
  

• ✅ On future requests, the cookie is automatically sent by the browser.
• ✅ Middleware uses the cookie to restore req.session.
• ✅ You remain authenticated until logout or session expiry.

	const express = require('express');
	const session = require('express-session');

	const app = express();
	const PORT = 3000;

	// Setup session middleware
	app.use(session({
	  secret: 'your_secret_key',            // 🗝️ Secret for signing the session ID cookie
	  resave: false,                         // Don't save session if unmodified
	  saveUninitialized: true,              // Save new sessions
	  cookie: { maxAge: 60000 }             // Session expires in 1 minute
	}));

	// Set a value in session
	app.get('/set', (req, res) => {
	  req.session.username = 'john_doe';
	  res.send('Session value set!');
	});

	// Get the value from session
	app.get('/get', (req, res) => {
	  const username = req.session.username;
	  res.send(`Username in session is: ${username}`);
	});

	// Destroy the session
	app.get('/logout', (req, res) => {
	  req.session.destroy(err => {
		if (err) return res.send('Error logging out.');
		res.send('Logged out and session destroyed!');
	  });
	});

	app.listen(PORT, () => {
	  console.log(`Server is running at http://localhost:${PORT}`);
	});

💡 Bonus Tip:

Always use app.use(session({...})) early in your middleware stack to ensure req.session is available for all routes.

🔄 Control Flow in Node.js

Control flow in Node.js means the order in which your code runs. Because Node.js uses non-blocking and event-based programming, things don’t always run one after the other. So, it's important to manage the flow of your code to make sure things happen in the right order and any errors are handled properly.

🎯 Why It Matters

• ✅ Helps avoid unexpected behavior in asynchronous code
• ✅ Makes it easier to manage tasks that depend on timing (like file reading or API calls)
• ✅ Makes your code easier to read and maintain

🧰 Control Flow Mechanisms

• Callbacks: 👉 Functions passed into other functions to run after something is done
• Promises: 👉 Objects that represent a value that might be available now, later, or never (success or failure of an async task)
• Async/Await: 👉 A cleaner way to write asynchronous code that looks like it's running one step at a time

⚙️ Synchronous vs Asynchronous Flow

// Synchronous Example
console.log('1');
console.log('2');
console.log('3');
// Output: 1, 2, 3

// Asynchronous Example
console.log('Start');

setTimeout(() => {
  console.log('Timeout Finished');
}, 1000);

console.log('End');
// Output: Start, End, Timeout Finished
  

📚 Example of All Three Styles

// Callback style
fs.readFile('file.txt', (err, data) => {
  if (err) throw err;
  console.log(data.toString());
});

// Promise style
fs.promises.readFile('file.txt')
  .then(data => console.log(data.toString()))
  .catch(err => console.error(err));

// Async/Await style
async function readFileAsync() {
  try {
    const data = await fs.promises.readFile('file.txt');
    console.log(data.toString());
  } catch (err) {
    console.error(err);
  }
}
readFileAsync();
  

🔁 Summary

• Callbacks: Traditional way, but can lead to “callback hell”
• Promises: Cleaner chaining, better error handling
• Async/Await: Most readable, recommended for modern codebases

🌐 Ajax vs Node.js

🔹 What is Ajax?

Ajax stands for Asynchronous JavaScript and XML. It is a technique used in web development to make requests to the server without reloading the page. This allows for a smoother, more interactive user experience.