Middleware ordering matters in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this middleware setup?

Consider this Express.js app with two middleware functions. What will be the console output and response?

Node.js

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

app.use((req, res, next) => {
  console.log('First middleware');
  next();
});

app.use((req, res, next) => {
  console.log('Second middleware');
  res.send('Hello from second');
});

app.listen(3000);

A Console logs: 'First middleware' then 'Second middleware', response: 'Hello from second'

B Console logs: 'Second middleware' then 'First middleware', response: 'Hello from second'

C Console logs: 'First middleware' only, response: no response (timeout)

D Console logs: 'Second middleware' only, response: 'Hello from first'

💡 Hint

Middleware runs in the order they are added. The first calls next(), so the second runs next.

Middleware functions run in the order they are added. The first middleware logs and calls next(), so the second middleware runs next and sends the response.

❓ state_output

intermediate

What is the value of req.processed after middleware chain?

Given this Express.js middleware chain, what is the final value of req.processed when the response is sent?

Node.js

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

app.use((req, res, next) => {
  req.processed = 1;
  next();
});

app.use((req, res, next) => {
  req.processed += 2;
  next();
});

app.use((req, res) => {
  res.send(`Processed: ${req.processed}`);
});

app.listen(3000);

A Processed: undefined

B Processed: 2

C Processed: 3

D Processed: 1

💡 Hint

Each middleware modifies req.processed and calls next() to continue.

The first middleware sets req.processed = 1. The second adds 2, making it 3. The last sends the value.

🔧 Debug

advanced

Why does the response never send in this middleware setup?

Look at this Express.js code. Why does the client never receive a response?

Node.js

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

app.use((req, res, next) => {
  console.log('Middleware 1');
  // missing next() call
});

app.use((req, res) => {
  res.send('Hello');
});

app.listen(3000);

A The first middleware throws an error, stopping the chain.

B The first middleware never calls next(), so the second middleware never runs, causing no response.

C The second middleware is never registered due to syntax error.

D The server crashes because res.send is called twice.

💡 Hint

Middleware must call next() to continue to the next middleware.

The first middleware does not call next(), so the request stops there and no response is sent.

📝 Syntax

advanced

Which middleware setup causes a syntax error?

Which of these Express.js middleware declarations will cause a syntax error?

A app.use((req, res, next) => { console.log('A'); next(); });

B app.use(function(req, res, next) { console.log('C'); next(); });

C app.use((req, res, next) => { console.log('D'); next(); });

D app.use((req, res next) => { console.log('B'); next(); });

💡 Hint

Check the function parameter list syntax carefully.

Option D is missing a comma between res and next, causing a syntax error.

🧠 Conceptual

expert

Which middleware order ensures error handling works correctly?

You have three middleware: logger, errorHandler, and router. Which order ensures that errors from router are caught by errorHandler?

A app.use(logger); app.use(router); app.use(errorHandler);

B app.use(errorHandler); app.use(logger); app.use(router);

C app.use(router); app.use(logger); app.use(errorHandler);

D app.use(router); app.use(errorHandler); app.use(logger);

💡 Hint

Error handling middleware must come after the middleware that might cause errors.

The error handler must be last so it can catch errors from previous middleware like the router.