The Node.js Patterns I Wish I Knew 3 Years Ago

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));
});

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

### The Meta Pattern: Async Error Handling

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
1. **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.
2. **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.
3. **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.
4. **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.
5. **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.
6. **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.