Mastering the Node.js Event Loop: How We Scaled to Higher RPS

The Breaking Point

Our real-time analytics dashboard was buckling under pressure. At 10,000 requests per second (RPS), API response times spiked from 20ms to over 1 second. The server wasn’t CPU-bound—it was event-loop congestion.

Node.js was starving under its own single-threaded nature. Here’s how we fixed it.

Understanding the Bottleneck

The event loop is Node.js’s heartbeat. When blocked, everything slows down. Common culprits:

1. Sync I/O (e.g., fs.readFileSync)
2. CPU-heavy tasks (e.g., JSON parsing, large computations)
3. Uncontrolled microtasks (e.g., runaway Promise.resolve() chains)

Optimization #1: Liberating the Event Loop

Problem:

A legacy synchronous config loader:

const config = JSON.parse(fs.readFileSync('config.json')); // Blocking!

Fix:

• Switched to async fs.promises:

  const config = await fs.promises.readFile('config.json', 'utf-8');

• Cached results to avoid repeated I/O.

Impact: Reduced event-loop lag by 35%.

Optimization #2: Taming Promises

Problem:

A flood of unbatched Promise.all calls:

await Promise.all(users.map(user => sendEmail(user))); // 10K emails at once!

Fix:

• Limited concurrency with p-limit:

  const limit = require('p-limit');
  const batch = limit(100); // Max 100 concurrent emails
  await Promise.all(users.map(user => batch(() => sendEmail(user))));

Impact: Cut event-loop delay from 200ms to <10ms.

Optimization #3: Offloading Heavy Work

Problem:

A CPU-intensive report generator:

app.get('/report', () => generatePDFReport()); // 2-second block!

Fix:

• Moved to Worker Threads:

  const { Worker } = require('worker_threads');
  app.get('/report', async (req, res) => {
    const worker = new Worker('./pdf-worker.js');
    worker.postMessage(req.query);
    worker.on('message', (pdf) => res.send(pdf));
  });

Impact: Zero event-loop disruption during PDF generation.

Key Takeaways

✔ Avoid sync operations—they’re event-loop poison.
✔ Batch async tasks—uncontrolled Promises are silent killers.
✔ Offload CPU work—Worker Threads are your ally.

Our dashboard now handles 50K RPS with consistent <50ms latency.

What’s your event-loop war story? Let’s discuss below.