Status code usage patterns in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

HTTP Status Code for Successful Resource Creation

What status code will this Node.js Express handler send when a new user is successfully created?

Node.js

app.post('/users', (req, res) => {
  // Assume user creation logic here
  res.status(201).send({ message: 'User created' });
});

A 200

B 400

C 201

D 500

💡 Hint

201 is the standard status code for resource creation success.

The handler uses res.status(201), which means the server successfully created a new resource. 201 is the standard HTTP status code for this.

❓ Predict Output

intermediate

Status Code for Unauthorized Access

What status code will this Express middleware send if the user is not authenticated?

Node.js

function authMiddleware(req, res, next) {
  if (!req.user) {
    return res.status(401).send('Unauthorized');
  }
  next();
}

A 403

B 401

C 404

D 200

💡 Hint

401 means the user must authenticate first.

The middleware sends status 401 when req.user is missing, indicating the user is not authenticated.

❓ component_behavior

advanced

Correct Status Code for Invalid Input

Which status code should be sent when the client sends invalid data in a POST request?

Node.js

app.post('/submit', (req, res) => {
  if (!req.body.name) {
    res.status(400).send('Name is required');
  } else {
    res.status(200).send('Success');
  }
});

A 400

B 404

C 500

D 201

💡 Hint

400 means the client sent bad data.

400 Bad Request is the correct status code when the client sends invalid or missing data.

❓ Predict Output

advanced

Status Code for Server Error

What status code will this Express error handler send when an unexpected error occurs?

Node.js

app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).send('Internal Server Error');
});

A 500

B 404

C 400

D 200

💡 Hint

500 means the server failed unexpectedly.

The error handler sends status 500 to indicate an internal server error.

❓ component_behavior

expert

Correct Status Code for Not Found

Which option correctly sends the status code for a 'Not Found' resource?

Node.js

app.get('/item/:id', (req, res) => {
  const item = database.find(req.params.id);
  if (!item) {
    res.status(404).send('Item not found');
  } else {
    res.status(200).json(item);
  }
});

A res.status(400).send('Item not found');

B res.status(200).send('Item not found');

C res.status(500).send('Item not found');

D res.status(404).send('Item not found');

💡 Hint

404 means resource not found.

Only option D correctly uses 404 for a missing resource. Other options send wrong status codes.

Practice

1. What does the HTTP status code 200 generally indicate in a Node.js response?

easy

A. The client made a bad request with invalid syntax.

B. The request was successful and the server returned the requested data.

C. The requested resource was not found on the server.

D. The server encountered an internal error.

Solution

1. Step 1: Understand HTTP status codes

   HTTP status codes communicate the result of a client's request to the server.

2. Step 2: Identify the meaning of 200

   Status code 200 means the request succeeded and the server sent back the expected data.

3. Final Answer:

   The request was successful and the server returned the requested data. -> Option B

4. Quick Check:

   200 = Success [OK]

Hint: 200 means success, data sent back properly [OK]

Common Mistakes:

• Confusing 200 with error codes like 400 or 500
• Thinking 200 means resource not found
• Mixing up client and server error codes

2. Which of the following is the correct way to set a 404 status code in a Node.js Express response?

easy

A. res.status(404).send('Not Found');

B. res.sendStatus(404, 'Not Found');

C. res.code(404).send('Not Found');

D. res.setStatus(404).send('Not Found');

Solution

1. Step 1: Recall Express response methods

   Express uses res.status(code) to set status codes before sending a response.

2. Step 2: Check method correctness

   res.status(404).send('Not Found'); correctly sets status 404 and sends the message.

3. Final Answer:

   res.status(404).send('Not Found'); -> Option A

4. Quick Check:

   Use res.status(code) to set status [OK]

Hint: Use res.status(code) before sending response [OK]

Common Mistakes:

• Using non-existent methods like res.code or res.setStatus
• Passing status code as second argument to send
• Confusing sendStatus with status

3. Consider this Express code snippet:

app.get('/data', (req, res) => {
  if (!req.query.id) {
    return res.status(400).send('Missing id');
  }
  res.status(200).send('Data for ' + req.query.id);
});

What status code will the server respond with if the client calls /data without an id query parameter?

medium

A. 400

B. 404

C. 200

D. 500

Solution

1. Step 1: Analyze the condition for missing id

   The code checks if req.query.id is missing and returns status 400 with message 'Missing id'.

2. Step 2: Determine response when id is missing

   If id is absent, the server responds immediately with status 400 (bad request).

3. Final Answer:

   400 -> Option A

4. Quick Check:

   Missing required data = 400 [OK]

Hint: Missing required input usually means 400 Bad Request [OK]

Common Mistakes:

• Assuming 404 means missing query parameter
• Thinking 200 is always returned
• Confusing 500 server error with client error

4. You have this Express route:

app.post('/submit', (req, res) => {
  if (!req.body.name) {
    res.sendStatus(422);
  }
  res.status(201).send('Created');
});

What is the problem with this code?

medium

A. It should use res.status(400) instead of 422.

B. The status code 422 is not valid in HTTP.

C. The res.status(201) should come before the if block.

D. It sends two responses if name is missing, causing an error.

Solution

1. Step 1: Check response flow when name is missing

   If !req.body.name is true, res.sendStatus(422) sends a response but code continues.

2. Step 2: Identify double response issue

   After sending 422, the code still calls res.status(201).send('Created'), causing an error because response was already sent.

3. Final Answer:

   It sends two responses if name is missing, causing an error. -> Option D

4. Quick Check:

   Send response once per request [OK]

Hint: Return after sending response to avoid double sends [OK]

Common Mistakes:

• Not returning after sending a response
• Confusing 422 with invalid status code
• Thinking order of status calls matters without return

5. You want to create an Express route that returns a JSON error with status 403 if the user is not authorized, and status 200 with data if authorized. Which code snippet correctly implements this pattern?

hard

A. app.get('/secret', (req, res) => {
if (!req.user) {
res.status(403).json({ error: 'Forbidden' });
}
res.status(200).json({ data: 'Secret info' });
});

B. app.get('/secret', (req, res) => {
if (!req.user) {
res.sendStatus(403);
} else {
res.sendStatus(200).json({ data: 'Secret info' });
}
});

C. app.get('/secret', (req, res) => {
if (!req.user) {
return res.status(403).json({ error: 'Forbidden' });
}
res.status(200).json({ data: 'Secret info' });
});

D. app.get('/secret', (req, res) => {
if (!req.user) {
res.status(403).send('Forbidden');
}
res.status(200).send('Secret info');
});

Solution

1. Step 1: Check response flow for unauthorized user

   app.get('/secret', (req, res) => { if (!req.user) { return res.status(403).json({ error: 'Forbidden' }); } res.status(200).json({ data: 'Secret info' }); }); uses return after sending 403 JSON error, preventing further code execution.

2. Step 2: Confirm authorized user response

   It sends status 200 with JSON data correctly if user exists.

3. Final Answer:

   app.get('/secret', (req, res) => { if (!req.user) { return res.status(403).json({ error: 'Forbidden' }); } res.status(200).json({ data: 'Secret info' }); }); -> Option C

4. Quick Check:

   Return after error response to avoid double sends [OK]

Hint: Use return after error response to stop execution [OK]

Common Mistakes:

• Not returning after sending error response
• Using sendStatus with json chaining incorrectly
• Sending plain text instead of JSON for API