es throughput under 10k concurrent requests, preventing database connection exhaustion.
Core Solution
Pattern 1: EventEmitter for Internal Pub/Sub
import { EventEmitter } from 'events';
const orderEvents = new EventEmitter();
async function createOrder(userId, items) {
const order = await db.orders.create({ userId, items });
orderEvents.emit('order:created', order);
return order;
}
orderEvents.on('order:created', async (order) => {
await sendConfirmationEmail(order).catch(err => logger.error('Email failed', err));
});
orderEvents.on('order:created', async (order) => {
await logAnalytics('order_created', order).catch(err => logger.error('Analytics failed', err));
});
Enter fullscreen mode Exit fullscreen mode
Result: Order creation returns in 50ms. Side effects async. If email fails, order still succeeded.
Pattern 2: Worker Threads for CPU-Bound Tasks
import { Worker } from 'worker_threads';
const workers = Array(os.cpus().length).fill(null).map(() => new Worker('./worker.js'));
let currentWorker = 0;
function processImage(imageBuffer) {
return new Promise((resolve, reject) => {
const worker = workers[currentWorker];
currentWorker = (currentWorker + 1) % workers.length;
const timer = setTimeout(() => reject(new Error('Worker timeout')), 30000);
worker.once('message', (result) => { clearTimeout(timer); resolve(result); });
worker.once('error', reject);
worker.postMessage({ imageBuffer });
});
}
Enter fullscreen mode Exit fullscreen mode
Result: Heavy computation doesn't block the main thread.
Pattern 3: Domain-Specific Error Classes
class AppError extends Error {
constructor(message, statusCode, code) {
super(message);
this.statusCode = statusCode;
this.code = code;
}
}
class NotFoundError extends AppError {
constructor(message) { super(message, 404, 'NOT_FOUND'); }
}
class ValidationError extends AppError {
constructor(message) { super(message, 400, 'VALIDATION_ERROR'); }
}
app.get('/users/:id', async (req, res, next) => {
try {
const user = await getUser(req.params.id);
res.json(user);
} catch (err) {
if (err instanceof AppError) {
res.status(err.statusCode).json({ error: err.message });
} else {
res.status(500).json({ error: 'Internal server error' });
}
}
});
Enter fullscreen mode Exit fullscreen mode
Pattern 4: Connection Pooling
const pool = new pg.Pool({
max: 20,
idleTimeoutMillis: 30000,
connectionTimeoutMillis: 2000,
});
async function getUser(id) {
const result = await pool.query('SELECT * FROM users WHERE id = $1', [id]);
return result.rows[0];
}
Enter fullscreen mode Exit fullscreen mode
Pattern 5: Circuit Breaker
class CircuitBreaker {
constructor(fn, options = {}) {
this.fn = fn;
this.failureThreshold = options.failureThreshold || 5;
this.resetTimeout = options.resetTimeout || 60000;
this.state = 'CLOSED';
this.failureCount = 0;
this.lastFailureTime = null;
}
async call(...args) {
if (this.state === 'OPEN') {
if (Date.now() - this.lastFailureTime > this.resetTimeout) {
this.state = 'HALF_OPEN';
} else {
throw new Error('Circuit breaker is OPEN');
}
}
try {
const result = await this.fn(...args);
this.failureCount = 0;
this.state = 'CLOSED';
return result;
} catch (err) {
this.failureCount++;
this.lastFailureTime = Date.now();
if (this.failureCount >= this.failureThreshold) this.state = 'OPEN';
throw err;
}
}
}
Enter fullscreen mode Exit fullscreen mode
Pattern 6: Graceful Shutdown
async function gracefulShutdown() {
server.close(async () => {
logger.info('Server closed');
});
const forceShutdown = setTimeout(() => process.exit(1), 30000);
try {
await db.close();
await redis.quit();
clearTimeout(forceShutdown);
process.exit(0);
} catch (err) {
process.exit(1);
}
}
process.on('SIGTERM', gracefulShutdown);
process.on('SIGINT', gracefulShutdown);
Enter fullscreen mode Exit fullscreen mode
function asyncHandler(fn) {
return (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);
}
app.get('/users/:id', asyncHandler(async (req, res) => {
const user = await db.getUser(req.params.id);
res.json(user);
}));
app.use((err, req, res, next) => {
logger.error('Unhandled error', err);
res.status(500).json({ error: 'Internal server error' });
});
Enter fullscreen mode Exit fullscreen mode
These aren't fancy patterns. They're the ones that keep systems running at 3am without pages.
Pitfall Guide
- Event Loop Starvation: Offloading CPU-bound work to the main thread causes request queuing and timeout cascades. Always delegate heavy computation to Worker Threads or external message queues to preserve event loop responsiveness.
- Silent Promise Rejections: Unhandled async errors bypass Express error middleware and crash the Node process. Wrap all route handlers with async error boundaries (
asyncHandler) to ensure centralized routing and prevent unhandled rejection crashes.
- Connection Pool Misconfiguration: Setting
max too low causes request queuing; setting it too high exhausts database memory and OS file descriptors. Tune max, idleTimeoutMillis, and connectionTimeoutMillis based on your DB instance specs, network latency, and expected concurrency.
- Circuit Breaker State Blindness: Failing to monitor
HALF_OPEN transitions or configure appropriate resetTimeout values causes premature failure recovery or prolonged service degradation. Implement health checks, metrics export, and alerting on state transitions.
- Tight Coupling in Pub/Sub: Emitting events without isolated error handling (
try/catch or .catch()) causes one failing side-effect (e.g., email service) to crash the entire request lifecycle. Always isolate event listeners and handle failures independently to maintain core transaction integrity.
- Abrupt Process Termination: Ignoring
SIGTERM/SIGINT signals drops in-flight requests and leaves database connections in TIME_WAIT state. Implement graceful shutdown sequences with forced termination fallbacks to ensure clean resource release and zero-downtime deployments.
Deliverables
- Node.js Resilience Blueprint: Architecture diagram mapping the request lifecycle through async boundaries, worker thread pools, circuit breaker state machines, and graceful shutdown hooks.
- Production Readiness Checklist: 24-point validation covering error boundary implementation, connection pool tuning parameters, event isolation verification, and signal handling compliance.
- Configuration Templates: Pre-tuned
pg.Pool configurations, worker_threads pool manager scripts, and CircuitBreaker parameter files with environment-variable overrides for staging/production environments.
