Express JS Basics
Interview Questions with Answers

21. What is the purpose of express.json() middleware?

It parses incoming requests with a Content-Type: application/json body and populates the parsed object on req.body. Without it, req.body would be undefined for JSON payloads. You can tune size and parsing behavior with options like limit, strict, and reviver.

app.use(express.json({ limit: '1mb', strict: true }));
app.post('/api/users', (req, res) => {
  // req.body is a JS object parsed from JSON
  res.json({ received: req.body });
});

22. What is the purpose of express.urlencoded() middleware?

It parses URL-encoded form submissions (e.g., from HTML <form method=”post”>) and puts the result on req.body. The extended option controls which parser is used.

• extended: false uses the Node.js querystring parser (simple key–value).
• extended: true uses qs (supports nested objects and arrays).

app.use(express.urlencoded({ extended: true }));
app.post('/submit', (req, res) => {
  // e.g., name=Ana&tags=js&tags=node -> { name: 'Ana', tags: ['js','node'] }
  res.json(req.body);
});

23. How do you serve static files with express.static()?

Mount the static middleware pointing to a directory. Express maps file paths under that directory to URLs.

app.use(express.static('public'));           // GET /logo.png -> public/logo.png
app.use('/assets', express.static('public')); // GET /assets/app.css -> public/app.css

For caching, set response headers via a small wrapper or reverse proxy (see Q24).

24. How do you set response headers in Express?

Use res.set() (alias res.header()) to set one or multiple headers before sending the body.

app.get('/report', (req, res) => {
  res
    .set('Cache-Control', 'no-store')
    .set('X-Frame-Options', 'DENY')
    .type('application/json')
    .status(200)
    .send(JSON.stringify({ ok: true }));
});

For headers applied to many routes, use middleware:

app.use((req, res, next) => {
  res.set('X-Powered-By', 'none');
  next();
});

25. How do you handle file downloads in Express?

Use res.download() to set proper headers and stream a file as an attachment, or res.attachment() plus res.sendFile() for finer control.

const path = require('path');
app.get('/download/invoice', (req, res, next) => {
  const filePath = path.join(__dirname, 'files', 'invoice.pdf');
  res.download(filePath, 'Invoice-2025.pdf', err => {
    if (err) next(err);
  });
});

res.download() automatically sets Content-Disposition: attachment; filename=… and streams efficiently.

26. What is express.Router() used for?

It creates a mini, modular router instance that you can attach routes and middleware to. This lets you group related endpoints and mount them under a path, improving structure, testability, and maintainability in larger apps.

27. How do you create modular route files with express.Router()?

Create a file per resource, build routes on a Router, export it, and mount in your main app.

// routes/users.js
const { Router } = require('express');
const router = Router();
router.get('/', (req, res) => res.json([{ id: 1, name: 'Ana' }]));
router.post('/', (req, res) => res.status(201).json(req.body));
module.exports = router;
// app.js
const usersRouter = require('./routes/users');
app.use('/users', usersRouter);

28. How do you mount a router on a path in Express?

Use app.use(<basePath>, <router>). All routes defined in the router are now reachable under that base path.

app.use('/api/v1/users', usersRouter);

29. Can you apply middleware only to a specific router?

Yes. Use router.use(mw) to attach middleware that runs only for routes inside that router, or pass middleware to specific routes.

const { Router } = require('express');
const router = Router();
function auth(req, res, next) { /* check token */ next(); }
router.use(auth);                // applies to all routes below
router.get('/me', (req, res) => res.json({ me: true }));
module.exports = router;

30. How do you organize routes in a large Express app?

Split by domain/resource using routers, keep controllers/services separate from routing, centralize error handling and validation, and use a layered directory structure. One common pattern:

src/
  app.js
  routes/
    users.routes.js
    auth.routes.js
    products.routes.js
  controllers/
    users.controller.js
    auth.controller.js
  services/
    users.service.js
  middlewares/
    auth.js
    error.js
    validate.js
  validations/
    users.schema.js
  utils/
    logger.js

Routers should be thin: only route definitions and wiring. Business logic lives in controllers/services. Validation and auth are reusable middlewares.

31. How do you parse JSON data from a request body?

Enable express.json() before your routes and access req.body.

app.use(express.json());
app.post('/api/items', (req, res) => {
  // e.g., { "name": "Pen", "price": 10 }
  res.status(201).json({ saved: req.body });
});

32. How do you parse URL-encoded form data in Express?

Use express.urlencoded({ extended: true }) and read req.body.

app.use(express.urlencoded({ extended: true }));
app.post('/signup', (req, res) => {
  const { username, password } = req.body;
  res.json({ username });
});

33. How do you handle form submissions in Express?

Enable parsing middleware, then read fields from req.body. For file uploads, add Multer (see Q34).

app.use(express.urlencoded({ extended: true }));
app.post('/contact', (req, res) => {
  const { name, email, message } = req.body;
  // save or process
  res.status(200).send('Thanks, we received your message.');
});

34. How do you handle file uploads with Express and Multer?

Install Multer, configure storage (memory or disk), and attach it to routes. Then access uploaded files on req.file or req.files.

// npm i multer
const multer = require('multer');
const upload = multer({ dest: 'uploads/' }); // disk; or multer({ storage: multer.memoryStorage() })
app.post('/avatar', upload.single('avatar'), (req, res) => {
  // req.file: { fieldname, originalname, mimetype, path, size, ... }
  res.json({ stored: req.file.originalname, path: req.file.path });
});
// For multiple files:
// app.post('/photos', upload.array('photos', 5), (req, res) => res.json({ count: req.files.length }));

Always validate file type/size and consider scanning and access-control. For cloud storage, stream to S3, GCS, etc., rather than keeping large files on your server.

35. How do you validate user input in Express?

Use a validation library and a small wrapper middleware. Popular choices are joi, zod, or express-validator.

Example with zod:

// npm i zod
const { z } = require('zod');
const userSchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
  age: z.number().int().min(0).optional()
});
function validate(schema) {
  return (req, res, next) => {
    const result = schema.safeParse(req.body);
    if (!result.success) {
      return res.status(400).json({ errors: result.error.issues });
    }
    req.validated = result.data;
    next();
  };
}
app.post('/users', express.json(), validate(userSchema), (req, res) => {
  res.status(201).json({ user: req.validated });
});

This keeps controllers clean and prevents bad data from reaching your logic or database.

36. How do you handle errors in Express routes?

Wrap async logic and pass errors to Express’s error pipeline using next(err), or rely on a small async helper. Then centralize responses in an error-handling middleware.

// helper
const asyncH = fn => (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);
app.get('/may-fail', asyncH(async (req, res) => {
  // if something throws, asyncH sends it to next(err)
  const data = await riskyCall();
  res.json(data);
}));

37. What is the role of the error-handling middleware in Express?

It is a special middleware with the signature (err, req, res, next) that handles all errors forwarded via next(err) or thrown in async handlers. Put it after all routes to send consistent error responses and hide stack traces in production.

app.use((err, req, res, next) => {
  const status = err.status || 500;
  const msg = process.env.NODE_ENV === 'production' ? 'Internal Server Error' : err.message;
  res.status(status).json({ error: msg });
});

38. How do you return a 404 response in Express?

Add a “not found” handler after all defined routes. If no route matched, this middleware runs.

app.use((req, res) => {
  res.status(404).json({ error: 'Not Found' });
});

39. How do you handle invalid JSON payloads in Express?

express.json() throws a SyntaxError for malformed JSON. Write an error handler that checks for this case and returns 400 Bad Request.

app.use(express.json());
app.use((err, req, res, next) => {
  if (err instanceof SyntaxError && 'body' in err) {
    return res.status(400).json({ error: 'Invalid JSON' });
  }
  next(err);
});

Place this before your general error handler (or handle both in one, checking the error type).

40. How do you log errors in an Express application?

Use an error-logging middleware or a logger library (e.g., winston, pino) inside the error handler, including request metadata for traceability.

const pino = require('pino');
const logger = pino();
app.use((err, req, res, next) => {
  logger.error({
    msg: err.message,
    stack: err.stack,
    method: req.method,
    url: req.originalUrl,
    ip: req.ip
  });
  res.status(500).json({ error: 'Internal Server Error' });
});

For production, prefer structured JSON logs, avoid leaking internals to clients, and ship logs to a central system (e.g., CloudWatch, ELK, Loki) with correlation IDs.