For over a decade, Express.js has been a go-to framework for building web servers in Node.js. However, one persistent pain point in Express 4 was its limited support for async/await in route handlers. If an async function threw an error or rejected a promise, it wouldn't be caught by Express's middleware chain, potentially crashing your server. Developers resorted to manual try/catch blocks, explicit next(err) calls, or third-party libraries like express-async-handler to handle this.

Enter Express 5. Released in October 2024, this major update brings native async/await support, allowing errors from async route handlers to automatically propagate to your error-handling middleware. No more wrappers, no more repetitive boilerplate – just clean, modern JavaScript.

This change aligns Express with contemporary Node.js practices (requiring Node 18+), reduces code clutter, and makes your apps more robust and maintainable.

---

⭐ The Async Struggle in Express 4

To illustrate the issue, let's look at a basic async route handler in Express 4:

app.get('/user', async (req, res) => {
  const user = await getUser(); // What if this throws an error?
  res.json(user);
});

If getUser() rejects a promise or throws an error, Express 4 doesn't catch it. This leads to an unhandled promise rejection, which could crash your entire server in production.

Common workarounds included:

• Wrapping every async handler in try/catch and manually calling next(err):

  app.get('/user', async (req, res, next) => {
    try {
      const user = await getUser();
      res.json(user);
    } catch (err) {
      next(err);
    }
  });
  

• Using libraries like express-async-handler for a cleaner wrapper:

  import asyncHandler from 'express-async-handler';
  
  app.get('/user', asyncHandler(async (req, res) => {
    const user = await getUser();
    res.json(user);
  }));
  

These solutions worked but added unnecessary complexity, extra dependencies, and visual noise to your codebase.

---

🎉 How Express 5 Makes Async Effortless

Express 5 builds in automatic promise rejection handling for route handlers and middleware. Key benefits include:

• Automatic Error Propagation: If an async function throws or rejects, the error is caught and passed to the next error-handling middleware.
• No Wrappers Needed: Forget express-async-handler or manual try/catch for basic error handling.
• Centralized Error Management: Keep your error logic in one place, making debugging and logging simpler.
• Cleaner Code: Focus on business logic without async-specific scaffolding.

Here's the simplified version in Express 5:

app.get('/user', async (req, res) => {
  const user = await getUser(); // Throws? Express handles it automatically.
  res.json(user);
});

That's it – no extras required. This works for both route handlers and middleware functions.

---

🧪 Hands-On Example: A Minimal Express 5 App with Async Handling

Let's build a complete, runnable example to see it in action. First, install Express 5:

npm install express@5

server.js

import express from 'express';

const app = express();
app.use(express.json());

// Async route that might fail
app.get('/data', async (req, res) => {
  const result = await fetchData(); // Simulates an async operation that could error out
  res.json({ result });
});

// Centralized error handler (catches async errors automatically)
app.use((err, req, res, next) => {
  console.error('Error caught:', err.message);
  res.status(500).json({ error: 'Something went wrong.' });
});

app.listen(3000, () => console.log('Server running on http://localhost:3000'));

Helper Function: fetchData.js (for simulation)

export async function fetchData() {
  // Simulate random async failure
  if (Math.random() > 0.5) {
    throw new Error('Random failure occurred');
  }
  return { message: 'Success!' };
}

Run the app with node --experimental-modules server.js (or use ESM support). Hit /data multiple times – when it fails, the error middleware handles it gracefully without crashing the server.

---

🔍 When to Use Try/Catch in Express 5

While Express 5 handles global errors automatically, you might still want local try/catch for specific scenarios, like providing custom responses or recovering from errors:

app.get('/safe', async (req, res) => {
  try {
    const result = await fetchData();
    res.json(result);
  } catch (err) {
    // Custom handling: e.g., bad input vs. server error
    res.status(400).json({ error: 'Invalid request or data issue' });
  }
});

Use this for fine-grained control, not as a default pattern. Let Express manage the rest.

---

🧹 Broader Improvements in Express 5

Beyond async support, Express 5 refines the framework for modern development:

• Removed Deprecated Features: Cleaner API by dropping outdated methods (e.g., app.del alias for delete).
• Improved TypeScript Support: Better typings for easier development.
• Performance Tweaks: Optimized internals for faster routing and middleware.
• Node 18+ Requirement: Leverages recent Node features like built-in fetch.
• Small Footprint Maintained: Still lightweight and unopinionated, but now async-native.

For full details, check the official changelog.

If upgrading from Express 4, review the migration guide to handle breaking changes.

---

🚀 Wrapping Up: Why Upgrade to Express 5?

Express 5 eliminates a major friction point, making async/await feel native and intuitive. Your code becomes:

• More Readable: Fewer wrappers and blocks.
• More Reliable: Automatic error flow prevents crashes.
• More Modern: Aligned with async-heavy Node ecosystems.
• Easier to Maintain: Centralized handling reduces duplication.

Whether you're building new APIs or refactoring legacy ones, Express 5 is a worthwhile upgrade. Dive in and enjoy the simplicity!