Node.js interview questions and answers

const express = require("express");
const app = express();

// Middleware
app.use(express.json());

// GET route
app.get("/", (req, res) => {
  res.send("Hello, World!");
});

// POST route
app.post("/api/users", (req, res) => {
  const user = req.body;
  res.json({ message: "User created", user });
});

// Start server
app.listen(3000, () => {
  console.log("Server running on port 3000");
});

// GET - Retrieve
app.get("/api/users", (req, res) => {
  res.json(users);
});

// POST - Create
app.post("/api/users", (req, res) => {
  users.push(req.body);
  res.json({ message: "User created" });
});

// PUT - Replace
app.put("/api/users/:id", (req, res) => {
  users[id] = req.body;
  res.json({ message: "User replaced" });
});

// PATCH - Update partial
app.patch("/api/users/:id", (req, res) => {
  users[id] = { ...users[id], ...req.body };
  res.json({ message: "User updated" });
});

// DELETE - Remove
app.delete("/api/users/:id", (req, res) => {
  delete users[id];
  res.json({ message: "User deleted" });
});

app.get("/api/users/:id", (req, res) => {
  const id = req.params.id;
  res.json({ id: id, name: "User " + id });
});

const express = require("express");
const app = express();

// Middleware 1: Parse JSON
app.use(express.json());

// Middleware 2: Logging
app.use((req, res, next) => {
  console.log(`${req.method} ${req.path}`);
  next(); // Pass control to next middleware
});

// Middleware 3: Authentication
app.use((req, res, next) => {
  if (!req.headers.authorization) {
    return res.status(401).json({ error: "Unauthorized" });
  }
  next();
});

// Route handler
app.get("/api/users", (req, res) => {
  res.json({ users: [] });
});

const express = require("express");
const app = express();

// Enable JSON parsing middleware
app.use(express.json());

app.post("/api/users", (req, res) => {
  console.log(req.body); // Parsed JSON is automatically available
  
  const user = {
    name: req.body.name,
    email: req.body.email
  };
  
  res.json({ message: "User created", user });
});

app.listen(3000);

let users = []; // In-memory, lost on restart

app.post("/api/users", (req, res) => {
  users.push(req.body); // Stored in memory only
  res.json({ message: "User created" });
});

app.get("/api/users", (req, res) => {
  res.json(users); // Empty after app restarts
});

// Good RESTful URLs
GET /api/users           // Get all users
GET /api/users/5         // Get user 5
POST /api/users          // Create user
PUT /api/users/5         // Update user 5
DELETE /api/users/5      // Delete user 5

// Bad (non-RESTful)
GET /api/getAllUsers
GET /api/getUser/5
GET /api/createUser
GET /api/deleteUser/5

// Each request creates a new connection (expensive)
app.get("/api/users", async (req, res) => {
  const conn = await createDatabaseConnection(); // SLOW
  const users = await conn.query("SELECT * FROM users");
  await conn.close(); // SLOW
  res.json(users);
});

app.post("/api/users", (req, res) => {
  // No validation!
  const user = {
    name: req.body.name, // Could be null, empty, or have SQL injection
    email: req.body.email, // Could be invalid format
    age: req.body.age // Could be negative or "not a number"
  };
  
  db.insertUser(user); // Inserts bad data
  res.json({ message: "User created" });
});

// User sends: { name: "", email: "invalid", age: -5 }
// Bad data enters database

Authentication: Login with username/password → Server verifies identity
Authorization: User ID 5 is accessing /api/admin → Server checks if user 5 is admin

Authentication: "Are you Alice?"
Authorization: "Can Alice access the admin panel?"

app.get("/download/file", (req, res) => {
  // Entire 1GB file loaded into memory!
  const fileContent = fs.readFileSync("large-file.bin");
  res.send(fileContent); // Huge memory spike
});

Frontend at: http://localhost:3000
API at: http://localhost:4000

Browser blocks request (different origins) ❌
Error: "No 'Access-Control-Allow-Origin' header"

CPU 1: 100% (Node.js process)
CPU 2: 0% (unused)
CPU 3: 0% (unused)
CPU 4: 0% (unused)

Performance: 25% of total capacity

┌─────────┐
                  │Load     │
                  │Balancer │
                  └────┬────┘
                  ┌────┴────┐
            ┌─────┴─┐  ┌────┴─────┐
        ┌───┴──┐ ┌──┴──┐ ┌─────┐
        │Server│ │Server│ │Server│
        └──────┘ └──────┘ └─────┘

app.get("/download", (req, res) => {
  const stream = fs.createReadStream("large-file.bin");
  stream.pipe(res);
  // No error handling
});

// Client loses response mid-stream
process.exit(0); // Kills immediately

app.post("/setup-monitor", (req, res) => {
  const userId = req.body.userId;
  
  // Create interval that never stops
  setInterval(() => {
    console.log(`Monitoring user ${userId}`);
  }, 1000);
  
  res.json({ message: "Monitoring started" });
});

Browser requests index.html
Server sends index.html
Browser parses HTML
Browser sees <link href="style.css">
Browser requests style.css
Server sends style.css
Browser renders page

Client → Reverse Proxy (Nginx) → App Server 1
                             → App Server 2
                             → App Server 3

// CPU usage
console.log(process.cpuUsage()); // { user: 12345, system: 6789 }

// Memory usage
console.log(process.memoryUsage()); 
// { rss: 50MB, heapTotal: 40MB, heapUsed: 30MB, external: 1MB }

// Request latency
const start = Date.now();
res.on("finish", () => {
  const duration = Date.now() - start;
  console.log(`Request took ${duration}ms`);
});

// Error rate
app.use((err, req, res, next) => {
  metrics.increment("errors");
});

// Database queries
db.on("query", (query) => {
  metrics.recordQueryTime(query.time);
});

const cache = new Map();

app.get("/api/users/:id", (req, res) => {
  const id = req.params.id;
  
  if (cache.has(id)) {
    return res.json(cache.get(id));
  }
  
  const user = db.getUser(id);
  cache.set(id, user); // Cache for 1 minute
  
  setTimeout(() => cache.delete(id), 60000);
  res.json(user);
});