Your Server Just Died. Again.

No clear stack trace. Just a generic UnhandledPromiseRejectionWarning buried at the bottom of your logs.

It's 2 a.m. Your users are getting 502 Bad Gateway errors. Setup was a pain, the deployment was messy, and now the entire application is hanging. We throw async on a function, slap await in front of a database call, and assume it's bulletproof.

It's not.

I've spent 10 years writing backend code, and I still see the same async/await mistakes bringing down massive infrastructures. Let's look at what's actually breaking your code and how to fix it. No fluff. Just the fixes.

What's Broken in Your Code Right Now

You're probably leaking memory or blocking the event loop without realizing it. Here's where it usually falls apart:

The Swallowed Error

You forgot the try/catch. The database drops the connection, the promise rejects, and Node just... stops. Or worse, the request hangs forever, leaving the user staring at a loading spinner until the browser times out.

The forEach Trap

You used a standard forEach loop with an async callback. It doesn't wait. Your code fires off 10,000 queries at the exact same millisecond. You instantly rate-limit your own API and crash the database.

The Fragile Batch

You used Promise.all for a massive array of tasks. One single image fails to upload, and the entire batch rejects. You lose the successful data just because one minor piece failed.

What Actually Works

Fixing this means playing defensively. Stop trusting the happy path.

1. Fix the Loop

If you need sequential execution, forEach is garbage. It doesn't respect await. Use a for...of loop instead.

Javascript

// Broken. Don't do this.
users.forEach(async (user) => { 
  await processPayment(user); 
});

// Fixed. Actually waits for each task.
for (const user of users) {
  await processPayment(user);
}

2. Ditch Promise.all for Independent Tasks

When handling independent tasks, Promise.all is far too fragile. Use Promise.allSettled. It runs everything and gives you an array of results, telling you exactly what passed and what failed.

Javascript

const results = await Promise.allSettled([
  chargeCard(user1),
  chargeCard(user2)
]);

// You can now filter out the rejected ones and log them
const failed = results.filter(r => r.status === 'rejected');

3. Centralize Your Try/Catch

Wrapping every single line in a try/catch makes your code unreadable. If you're using Express, write an async wrapper for your routes so you only have to handle the error logic in one place. Pass the error directly to your global middleware.

The 2 A.M. War Story

I saw this break horribly during a major database migration.

We were processing a batch of 50,000 legacy payment records. A junior dev used Promise.all. One single invalid credit card format rejected the promise. The whole batch threw an error, but our system had already marked half of them as processed in the database.

A massive data inconsistency mess. We lost hours rolling back the DB and manually verifying transactions.

We fixed it by swapping to Promise.allSettled and writing the exact failure reasons for individual records into a dead-letter queue. The system never crashed again.

The Final Verdict

Here's the breakdown of how to handle multiple promises.

Expect the database to fail. Expect the API to time out. Assume the event loop will block. Write your async code like everything is about to break, and your server won't let you down.