Why production setup matters in Express - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start an Express server listening on port 3000.

Express

const express = require('express');
const app = express();
app.listen([1], () => {
  console.log('Server running');
});

Drag options to blanks, or click blank then click option'

A3000

Bapp

C'3000'

Dexpress

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string instead of a number for the port.

Passing the app or express object instead of a port number.

The listen method needs a number for the port. Using 3000 starts the server on port 3000.

2fill in blank

medium

Complete the code to add a middleware that parses JSON bodies in requests.

Express

const express = require('express');
const app = express();
app.use([1]());

Drag options to blanks, or click blank then click option'

AbodyParser.json

Bexpress.json

CjsonParser

Dexpress.body

Attempts:

3 left

💡 Hint

Common Mistakes

Using bodyParser.json without importing body-parser.

Using incorrect method names like express.body.

Express has a built-in middleware called express.json() to parse JSON request bodies.

3fill in blank

hard

Fix the error in the code to properly handle errors in Express.

Express

app.use((err, req, res, [1]) => {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

Drag options to blanks, or click blank then click option'

Anext

Berror

Cresponse

Drequest

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong parameter names like 'error' or 'response' instead of 'next'.

Missing the fourth parameter entirely.

The error-handling middleware in Express must have four arguments: err, req, res, next. The last one is next.

4fill in blank

hard

Fill both blanks to create a route that responds with JSON and sets a custom header.

Express

app.get('/info', (req, res) => {
  res.set('[1]', '[2]').json({ message: 'Hello' });
});

Drag options to blanks, or click blank then click option'

AX-Custom-Header

BContent-Type

CCustomValue

Dapplication/json

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Content-Type' header incorrectly here.

Not chaining the methods properly.

To add a custom header, use res.set('X-Custom-Header', 'CustomValue'). The JSON response is sent after setting the header.

5fill in blank

hard

Fill all three blanks to create a middleware that logs request method, URL, and then calls next.

Express

app.use(([1], [2], [3]) => {
  console.log(`$[1].method} $[2].url}`);
  [3]();
});

Drag options to blanks, or click blank then click option'

Areq

Bres

Cnext

Drequest

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'request' instead of 'req'.

Forgetting to call next() causing the request to hang.

Middleware functions receive req, res, and next. We log req.method and req.url, then call next() to continue.

Practice

1. Why is it important to run an Express app in production mode instead of development mode when deploying to users?

easy

A. Because production mode enables debugging tools for developers

B. Because development mode automatically updates the app without restarting

C. Because development mode disables all middleware

D. Because production mode hides detailed error messages and improves performance

Solution

1. Step 1: Understand the difference between modes

   Development mode shows detailed errors and is slower for debugging. Production mode hides errors and optimizes speed.

2. Step 2: Identify why production mode is preferred for users

   Hiding error details prevents exposing sensitive info and improves app speed for users.

3. Final Answer:

   Because production mode hides detailed error messages and improves performance -> Option D

4. Quick Check:

   Production mode = hides errors + faster [OK]

Hint: Production mode hides errors and speeds app [OK]

Common Mistakes:

• Thinking development mode is faster
• Believing production mode shows more errors
• Confusing middleware behavior between modes

2. Which of the following is the correct way to set Express to production mode in your code?

easy

A. app.set('env', 'production');

B. app.env = 'production';

C. app.production = true;

D. app.mode('production');

Solution

1. Step 1: Recall Express environment setting syntax

   Express uses app.set('env', value) to set environment mode.

2. Step 2: Match correct syntax

   Only app.set('env', 'production'); is valid syntax to set production mode.

3. Final Answer:

   app.set('env', 'production'); -> Option A

4. Quick Check:

   Use app.set('env', 'production') [OK]

Hint: Use app.set('env', 'production') to set mode [OK]

Common Mistakes:

• Assigning directly to app.env
• Using non-existent app.mode method
• Setting app.production property

3. Consider this Express code snippet:

app.set('env', 'production');
app.use((err, req, res, next) => {
  res.status(500).send(err.stack);
});

app.get('/', (req, res) => {
  throw new Error('Oops!');
});

What will the user see when visiting '/' in production mode?

medium

A. The app crashes and shows no response

B. A generic 500 Internal Server Error without details

C. The error message 'Oops!' only

D. The full error stack trace is shown

Solution

1. Step 1: Analyze middleware order

   The custom error handler is placed BEFORE the route. Error-handling middleware (4 args) catches errors from routes and middleware defined BEFORE it in the stack.

2. Step 2: Understand error handler behavior

   Since the error handler is registered before the route, it will not catch errors thrown in the route. Express will use its default error handler, which in production mode hides stack traces.

3. Step 3: Realize the code order is incorrect

   However, in this snippet, the error handler is registered before the route, so it won't catch the error thrown in the route. Therefore, Express default error handler runs, which in production mode sends a generic 500 error without stack trace.

4. Final Answer:

   A generic 500 Internal Server Error without details -> Option B

5. Quick Check:

   Error handler before route = default production handler [OK]

Hint: Error handlers must be AFTER routes to catch errors [OK]

Common Mistakes:

• Placing error handler before routes
• Assuming custom handler catches regardless of position
• Thinking production always shows stack trace

4. You set your Express app to production mode but still see detailed error messages in the browser. What is the most likely cause?

medium

A. You forgot to remove the custom error handler that sends error details

B. You did not restart the server after changing the mode

C. Production mode is not supported in Express

D. You set NODE_ENV to 'development' instead of 'production'

Solution

1. Step 1: Understand error handling in production

   Express hides errors only if default error handler is used. Custom handlers can override this.

2. Step 2: Identify why detailed errors still show

   If a custom error handler sends error details, production mode won't hide them.

3. Final Answer:

   You forgot to remove the custom error handler that sends error details -> Option A

4. Quick Check:

   Custom error handler shows details despite production [OK]

Hint: Check custom error handlers when errors show in production [OK]

Common Mistakes:

• Assuming production mode disables custom handlers
• Not restarting server after changes
• Confusing NODE_ENV variable with app.set('env')

5. You want to optimize your Express app for production by enabling caching and disabling verbose logging. Which setup is best practice?

hard

A. Use app.set('env', 'development') and enable all middleware for debugging

B. Set NODE_ENV to 'development', enable verbose logging, and disable caching

C. Set NODE_ENV to 'production', use compression middleware, and disable detailed error logging

D. Remove all middleware to speed up the app

Solution

1. Step 1: Identify production best practices

   Production mode should enable caching and compression, and reduce logging verbosity.

2. Step 2: Match options to best practices

   Set NODE_ENV to 'production', use compression middleware, and disable detailed error logging sets NODE_ENV to 'production', uses compression, and disables verbose logs, which is correct.

3. Final Answer:

   Set NODE_ENV to 'production', use compression middleware, and disable detailed error logging -> Option C

4. Quick Check:

   Production = caching + compression + less logging [OK]

Hint: Production mode = caching + compression + less logs [OK]

Common Mistakes:

• Using development mode in production
• Disabling all middleware breaks app
• Ignoring compression and caching