Why 404 Not Found handler in Express? - Purpose & Use Cases

The Big Idea

What if your website could gently catch every wrong turn visitors take?

The Scenario

Imagine you build a website with many pages, but when someone types a wrong address, nothing happens or the server crashes.

The Problem

Without a proper 404 handler, users get confused or see ugly errors. Manually checking every URL is slow and messy.

The Solution

A 404 Not Found handler in Express catches all unknown requests and shows a friendly message automatically.

Before vs After

✗ Before

app.get('/home', (req, res) => { res.send('Home'); }); // no catch for wrong URLs

✓ After

app.use((req, res) => { res.status(404).send('Page not found'); });

What It Enables

This lets your app gracefully handle missing pages and guide users back on track.

Real Life Example

When you mistype a URL on a shopping site, a 404 page helps you find your way instead of showing a blank screen.

Key Takeaways

Manual URL checks are hard and error-prone.

Express 404 handler catches all unknown routes automatically.

Users get clear feedback and better experience.

Practice

1. What is the main purpose of a 404 Not Found handler in an Express app?

easy

A. To catch requests for routes that do not exist and respond with a message

B. To handle database connection errors

C. To log all incoming requests

D. To serve static files like images and CSS

Solution

1. Step 1: Understand what a 404 error means

   A 404 error means the requested page or route was not found on the server.

2. Step 2: Role of the 404 handler in Express

   The 404 handler catches these unknown routes and sends a clear message to the user.

3. Final Answer:

   To catch requests for routes that do not exist and respond with a message -> Option A

4. Quick Check:

   404 handler = catch unknown routes [OK]

Hint: 404 handler catches unknown routes last in middleware [OK]

Common Mistakes:

• Confusing 404 handler with error handler for server errors
• Placing 404 handler before route definitions
• Using 404 handler to serve static files

2. Which of the following is the correct syntax to add a 404 handler in Express?

easy

A. app.route('*').get((req, res) => { res.status(404).send('Not Found'); });

B. app.get('/404', (req, res) => { res.send('Not Found'); });

C. app.use((req, res) => { res.status(404).send('Not Found'); });

D. app.use((err, req, res, next) => { res.status(404).send('Not Found'); });

Solution

1. Step 1: Identify the middleware signature for 404 handler

   A 404 handler uses app.use with (req, res) parameters, no error parameter.

2. Step 2: Check each option's correctness

   app.use((req, res) => { res.status(404).send('Not Found'); }); correctly uses app.use with (req, res) and sets status 404. app.get('/404', (req, res) => { res.send('Not Found'); }); is a route, not a catch-all. app.use((err, req, res, next) => { res.status(404).send('Not Found'); }); is an error handler (has err param). app.route('*').get((req, res) => { res.status(404).send('Not Found'); }); uses app.route('*') which is not standard for 404.

3. Final Answer:

   app.use((req, res) => { res.status(404).send('Not Found'); }); -> Option C

4. Quick Check:

   404 handler = app.use with (req, res) [OK]

Hint: 404 handler uses app.use with (req, res), no error param [OK]

Common Mistakes:

• Using error handler signature (err, req, res, next) for 404
• Defining 404 as a specific route like '/404'
• Using app.route('*') incorrectly for 404

3. Given this Express code snippet, what will the server respond with when a user visits /unknown?

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

app.get('/home', (req, res) => {
  res.send('Welcome Home');
});

app.use((req, res) => {
  res.status(404).send('Page Not Found');
});

app.listen(3000);

medium

A. No response, request hangs

B. 'Welcome Home'

C. Server error 500

D. 'Page Not Found' with status 404

Solution

1. Step 1: Check defined routes

   The only defined route is '/home'. The request is for '/unknown', which is not defined.

2. Step 2: Check 404 handler behavior

   The app.use middleware catches all unmatched routes and sends 'Page Not Found' with status 404.

3. Final Answer:

   'Page Not Found' with status 404 -> Option D

4. Quick Check:

   Unknown route triggers 404 handler [OK]

Hint: Unknown routes trigger 404 handler last middleware [OK]

Common Mistakes:

• Assuming default 200 status for unknown routes
• Expecting server error instead of 404
• Thinking the request will hang without response

4. Identify the error in this Express 404 handler code:

app.use((req, res, next) => {
  res.send('404 Not Found');
  res.status(404);
});

medium

A. The status should be set before sending the response

B. The handler should have four parameters (err, req, res, next)

C. The handler should use res.redirect instead of res.send

D. The middleware should be app.get, not app.use

Solution

1. Step 1: Check order of response methods

   Calling res.send sends the response immediately. Setting status after sending has no effect.

2. Step 2: Correct order for setting status and sending

   Status must be set before res.send to apply correctly.

3. Final Answer:

   The status should be set before sending the response -> Option A

4. Quick Check:

   Set status before send [OK]

Hint: Always set status before sending response [OK]

Common Mistakes:

• Setting status after res.send (ignored)
• Using error handler signature for 404
• Using app.get instead of app.use for 404

5. You want to add a 404 handler that returns JSON with a message and logs the missing URL. Which code correctly implements this in Express?

hard

A. app.use((err, req, res, next) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); });

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

C. app.get('*', (req, res) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); });

D. app.use((req, res, next) => { res.json({ error: 'Not Found' }); console.log('Missing:', req.url); res.status(404); });

Solution

1. Step 1: Choose correct middleware signature for 404 handler

   404 handler uses app.use with (req, res), no error parameter.

2. Step 2: Ensure status is set before sending JSON and logging happens before response

   app.use((req, res) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); }); logs the URL, sets status 404, and sends JSON correctly. app.use((err, req, res, next) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); }); uses error handler signature incorrectly. app.get('*', (req, res) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); }); uses app.get('*') which is less common and may miss some requests. app.use((req, res, next) => { res.json({ error: 'Not Found' }); console.log('Missing:', req.url); res.status(404); }); sets status after sending response and logs after response, which is wrong.

3. Final Answer:

   app.use((req, res) => { console.log('Missing:', req.url); res.status(404).json({ error: 'Not Found' }); }); -> Option B

4. Quick Check:

   404 handler logs then sends JSON with status 404 [OK]

Hint: Use app.use with (req, res), set status before json, log before response [OK]

Common Mistakes:

• Using error handler signature for 404
• Setting status after sending response
• Logging after sending response
• Using app.get('*') instead of app.use