Node.js Advanced FAQ & Answers

Worker Threads and Clustering both enable multi-core utilization but serve different purposes (Node.js official documentation v25.2.0). Clustering: creates multiple Node.js processes via child_process.fork(), each with independent event loop, memory, and V8 instance. All processes share same server port. Use cases: horizontal scaling across cores, handling concurrent HTTP requests. Implementation: const cluster = require('cluster'); if (cluster.isPrimary) { for (let i = 0; i < numCPUs; i++) cluster.fork(); } else { app.listen(3000); }. Benefits: 20% higher performance under heavy load, automatic request distribution, process isolation (crash doesn't affect others). Drawbacks: high memory overhead (full Node.js per process), inter-process communication (IPC) required for shared state. Worker Threads: runs JavaScript in multiple threads within same process, shares memory via SharedArrayBuffer and can transfer ArrayBuffer instances. Official recommendation: when process isolation is not needed, use worker_threads module instead of child_process or cluster for running multiple application threads within single Node.js instance. Use cases: CPU-intensive tasks (image processing, cryptography, data compression) without blocking event loop. Implementation: const { Worker } = require('worker_threads'); const worker = new Worker('./task.js'); worker.postMessage(data);. Benefits: 70% faster for CPU-bound tasks, lower memory overhead than clustering, shared memory possible, two-way inter-thread message passing. Drawbacks: no separate event loop per thread (blocking operations still block). Recommendation: use Clustering for I/O-bound web servers (APIs, HTTP services), use Worker Threads for CPU-intensive operations within those servers. Combine both: clustered web server where each process uses Worker Threads for heavy tasks. Best practice: PM2 or Node cluster module for clustering, Worker Threads for specific CPU operations. Performance: 4-core system - clustering achieves 3.5-4x throughput for HTTP servers, Worker Threads achieve near-linear speedup for parallelizable CPU tasks. Valid for Node.js 20+ LTS versions.

Event loop is Node.js's core concurrency mechanism - single-threaded loop processing callbacks from queue. Phases (official Node.js documentation): (1) Timers: executes setTimeout/setInterval callbacks, (2) Pending callbacks: I/O callbacks deferred from previous cycle, (3) Idle/prepare: internal use, (4) Poll: retrieves new I/O events, executes I/O callbacks (most time spent here), (5) Check: setImmediate callbacks, (6) Close callbacks: socket.on('close'). Each phase has FIFO queue of callbacks. Event loop processes all callbacks in phase before moving to next. Microtask queue (process.nextTick executed immediately after current operation completes before next phase, promises processed as microtasks) - process.nextTick runs before promise microtasks. Important: process.nextTick is NOT technically part of event loop phases (processed between phases). Can starve event loop if infinite recursion (nextTickQueue blocks phase progression). Node.js 11+ improvement: microtasks run between individual timer/immediate callbacks. Blocking pitfalls: (1) Synchronous operations: fs.readFileSync, JSON.parse(huge_string), crypto.pbkdf2Sync block event loop entirely, (2) Heavy computation: loops processing large arrays, regex on large strings, complex calculations, (3) Synchronous APIs in libraries: some npm packages use sync operations internally. Consequences: request latency spikes (all requests wait), timeouts, poor throughput. Monitoring: event loop lag (time between scheduled and actual execution) - target <10ms, alert if >50ms. Solutions: (1) Replace sync with async: fs.promises.readFile, worker threads for heavy computation, (2) Break long tasks: use setImmediate to yield: function processArray(arr, index = 0) { if (index >= arr.length) return done(); process(arr[index]); setImmediate(() => processArray(arr, index + 1)); }, (3) Offload to workers: Worker Threads or child processes. Best practices: never block event loop >10ms, profile with clinic.js or --inspect, use async/await for all I/O. Performance: well-designed Node.js server handles 10K+ concurrent connections with <10ms response times. Valid for Node.js 20+ LTS versions (Node.js 18 reached EOL in 2025).

Connection pooling reuses connections instead of creating new ones per request, essential for Node.js performance (10-50x improvement). Database connection pooling (2025 production patterns): PostgreSQL with pg library (official node-postgres documentation) - const { Pool } = require('pg'); const pool = new Pool({ max: 20, min: 5, idleTimeoutMillis: 30000, connectionTimeoutMillis: 2000, allowExitOnIdle: false }). Why pooling: connecting new client requires 20-30ms handshake (password negotiation, SSL establishment, configuration sharing), PostgreSQL can only handle limited clients (unbounded connections crash server). Recommended: limited number of pools (usually just 1) for reusable client checkout/return. Configuration parameters (official pg-pool API): (1) max - maximum pool size (default 10), calculate based on: database max_connections limit (PostgreSQL default 100), number of application instances (4 instances × 20 connections = 80 total), reserve 20% for admin/monitoring (80 < 100 OK). Formula for CPU-bound apps: max = num_cores * 2 + 1. For I/O-bound (typical): start 10-20, increase if pool exhaustion detected. (2) min - minimum idle connections (default 0), keep warm connections ready (avoid cold start latency). Set to expected baseline concurrency (5-10 typical). (3) idleTimeoutMillis - close idle connections after timeout (default 10s), balance between connection reuse vs holding resources. Production: 30-60 seconds prevents churning, allows database cleanup. (4) connectionTimeoutMillis - max wait for available connection (default none), fail-fast prevents request pileup. Set to 2-5 seconds, return 503 Service Unavailable if pool exhausted. (5) allowExitOnIdle - prevent process exit when pool idle (set false for production, true for tests/scripts). Usage pattern (always release connections): const client = await pool.connect(); try { const result = await client.query('SELECT * FROM users WHERE id = $1', [userId]); return result.rows[0]; } finally { client.release(); }. Never forget release() or pool leaks, use try-finally even with async/await. Alternative: pool.query() for simple queries (auto-release): const result = await pool.query('SELECT NOW()'). Monitoring production pools: Track metrics - pool.totalCount (total connections), pool.idleCount (available), pool.waitingCount (queued requests). Alert when waitingCount > 0 (pool exhaustion), idleCount = 0 (increase max), totalCount approaches max (capacity limit). Libraries: node-postgres-prometheus for Prometheus metrics export. MySQL with mysql2 library: const pool = mysql.createPool({ host, user, password, database, connectionLimit: 20, queueLimit: 100, waitForConnections: true, enableKeepAlive: true, keepAliveInitialDelay: 10000 }). Key differences: connectionLimit (equivalent to pg max), queueLimit (max queued requests, prevents infinite backlog), enableKeepAlive (TCP keepalive prevents connection loss). MongoDB with native driver: const client = new MongoClient(uri, { maxPoolSize: 50, minPoolSize: 5, maxIdleTimeMS: 30000, serverSelectionTimeoutMS: 5000 }). Higher maxPoolSize than SQL databases (MongoDB designed for connection pooling, replica sets distribute load). HTTP connection pooling for external APIs (2025): axios with custom agent - const http = require('http'); const https = require('https'); const httpAgent = new http.Agent({ keepAlive: true, maxSockets: 50, maxFreeSockets: 10, timeout: 60000 }); const httpsAgent = new https.Agent({ keepAlive: true, maxSockets: 50, maxFreeSockets: 10, timeout: 60000 }); const axios = require('axios').create({ httpAgent, httpsAgent }). Parameters: keepAlive - reuse TCP connections (saves 50-200ms TLS handshake per request), maxSockets - max concurrent connections per host (default Infinity, set to 50-100 to prevent overwhelming downstream), maxFreeSockets - max idle connections kept in pool (default 256, reduce to 10-20 to free resources), timeout - socket idle timeout before close (60s typical, balance reuse vs resource holding). Benefits quantified: Without pooling - create connection (50ms TCP + 150ms TLS) + request (100ms) = 300ms total. With pooling - reuse connection (0ms) + request (100ms) = 100ms total (3x faster). High-volume APIs (1K+ req/sec) save thousands of TLS handshakes per second. node-fetch (native fetch in Node 20+) pooling: Global HTTP agents automatically pool by default, configure with undici (underlying HTTP client) - const { Agent, setGlobalDispatcher } = require('undici'); setGlobalDispatcher(new Agent({ connections: 50, pipelining: 10 })). connections - max connections per origin, pipelining - max pipelined requests per connection (HTTP/1.1 optimization). Redis connection pooling with ioredis: const Redis = require('ioredis'); const redis = new Redis.Cluster([{ host: 'localhost', port: 6379 }], { maxRetriesPerRequest: 3, enableReadyCheck: true, lazyConnect: false }). Cluster mode auto-pools connections across nodes, single instance uses single persistent connection (lightweight protocol, pooling not required). Best practices (2025 production checklist): (1) Single pool per application - create pool at startup (singleton), share across all request handlers. Anti-pattern: new Pool() inside request handler (creates pool per request, defeats purpose). (2) Always release connections - use try-finally or pool.query() auto-release. Leaked connections cause gradual pool exhaustion (symptoms: slow response times after hours/days uptime). (3) Configure timeouts - connectionTimeoutMillis prevents infinite waits, query timeout prevents long-running queries blocking pool: await client.query({ text: 'SELECT...', timeout: 5000 }). (4) Monitor pool health - expose metrics endpoint (Prometheus /metrics), alert on pool exhaustion (waitingCount > 0), high latency (P95 > 100ms), connection errors. (5) Separate pools for different workloads - read replica pool for analytics (high concurrency, slow queries), write pool for transactions (low concurrency, fast queries). Prevents slow analytical queries blocking fast transactional queries. (6) Graceful shutdown - drain pools on SIGTERM: process.on('SIGTERM', async () => { await pool.end(); await redisClient.quit(); }). Prevents connection leaks during rolling deploys. (7) Connection validation - enable keepalive to detect stale connections (database restarted, network interruption). PostgreSQL: pool.on('error', (err) => logger.error('Pool error', err)); reconnects automatically. (8) Pool sizing for serverless (AWS Lambda, Cloud Functions) - max: 1-2 per function instance (ephemeral, high concurrency scales horizontally). Use connection pooling proxy (RDS Proxy, Neon serverless) to multiplex connections. Common mistakes and fixes (2025): Mistake 1 - Pool per request. Code: app.get('/', async (req, res) => { const pool = new Pool(); ... }). Fix: const pool = new Pool(); (global scope), app.get('/', async (req, res) => { pool.query... }). Mistake 2 - Not releasing on error. Code: const client = await pool.connect(); await client.query(); client.release();. Fix: try { ... } finally { client.release(); }. Mistake 3 - Pool size = database max_connections. Database: max_connections = 100, App: 10 instances × 20 pool size = 200 total (oversubscribed). Fix: total_connections_across_all_instances < db_max_connections. 10 instances × 8 connections = 80 (safe). Mistake 4 - No connection timeout. Pool exhausts, requests wait forever (memory leak, process hangs). Fix: connectionTimeoutMillis: 2000, fail fast with 503 error. Mistake 5 - Mixing HTTP clients without pooling. Code: app.get('/', () => fetch(url)). fetch() in Node 20+ pools by default (OK), but axios without agent doesn't pool (add httpAgent). Performance benchmarks (2025 production): Scenario: Node.js API → PostgreSQL query (100ms latency). Without pooling (create connection per request): 50ms connect + 100ms query = 150ms total. Throughput: 6 req/sec per connection (connection overhead dominates). With pooling (reuse connections, pool size 20): 0ms connect + 100ms query = 100ms total. Throughput: 200 req/sec (20 concurrent queries, 10 req/sec each). 33x improvement. HTTP API pooling: External API call (200ms latency). Without keepAlive: 50ms TCP + 150ms TLS + 200ms request = 400ms. With keepAlive (pooling): 0ms + 0ms + 200ms = 200ms (2x faster). At 1K req/sec: saves 200 seconds of TLS handshakes per second (impossible without pooling, would need 200+ CPU cores). Production pool configuration examples (2025): Small app (1 instance, 100 req/sec): PostgreSQL max: 10, min: 2, MySQL max: 10, HTTP maxSockets: 20. Medium app (4 instances, 1K req/sec total): PostgreSQL max: 15 per instance (60 total < 100 db limit), MySQL max: 20, HTTP maxSockets: 50. Large app (20 instances, 10K req/sec total): PostgreSQL max: 4 per instance (80 total < 100 db limit), use read replicas (separate pool per replica), MySQL max: 10, HTTP maxSockets: 100. Serverless (Lambda/Cloud Functions): PostgreSQL max: 1-2 per function, use RDS Proxy (pools across all Lambdas), HTTP maxSockets: 10 (ephemeral, many instances). Valid for Node.js 20+ LTS versions.

Graceful shutdown ensures in-flight requests complete before process exits, preventing data loss and client errors. Implementation pattern (community best practice verified across production deployments): (1) Listen for signals: process.on('SIGTERM', gracefulShutdown); process.on('SIGINT', gracefulShutdown);. SIGTERM sent by Kubernetes/Docker on pod termination (Unix-based systems interrupt/terminate signal), SIGINT from Ctrl+C (manual user interruption). (2) Stop accepting new requests: server.close(() => { /* shutdown complete */ });. Node.js HTTP server close() method (official API) stops listening but waits for existing connections to complete. (3) Wait for in-flight requests: set timeout (30s typical) for requests to complete: setTimeout(() => { process.exit(1); }, 30000);. Forces exit if graceful shutdown exceeds timeout (prevents indefinite hangs). (4) Close resources: disconnect databases (await db.end()), flush logs, close message queue connections. Pattern: async function gracefulShutdown(signal) { console.log('${signal} received, starting graceful shutdown'); server.close(async () => { await db.end(); await redis.quit(); await messageQueue.close(); console.log('Shutdown complete'); process.exit(0); }); setTimeout(() => { console.error('Forced shutdown after timeout'); process.exit(1); }, 30000); }. HTTP keep-alive handling: server.keepAliveTimeout = 5000; prevents long-lived connections from blocking shutdown, or use terminus library for automatic connection draining. Kubernetes integration: readiness probe fails immediately on shutdown signal, allowing 30s (default terminationGracePeriodSeconds) before SIGKILL forces termination. Best practices: (1) Health endpoint returns 503 during shutdown (signals not ready to load balancer), (2) Log shutdown progress for debugging, (3) Flush logs/metrics before exit (prevent data loss), (4) Test graceful shutdown in staging (kill pods during load to verify zero errors). Common issues: (1) Database connections not closed (connection leaks in pool), (2) Message queue acks not sent (duplicate processing on restart), (3) Logs truncated (flush before exit). Libraries: terminus (HTTP-specific graceful shutdown), lightship (comprehensive shutdown with readiness/liveness integration). Performance: graceful shutdown prevents 500 errors during deploys, enables zero-downtime rolling updates. Valid for Node.js 20+ LTS versions.

Caching stores frequently accessed data in fast storage, reducing latency and database load. Layers: (1) In-memory cache (LRU): const LRU = require('lru-cache'); const cache = new LRU({ max: 500, ttl: 1000 * 60 * 5 });. Best for: small datasets, single-server apps. Drawbacks: lost on restart, not shared across instances. (2) Redis: distributed cache, shared across instances. Patterns: cache-aside (app checks cache, fetches from DB on miss, populates cache), write-through (writes update cache + DB synchronously), write-behind (async writes to DB). Implementation: const value = await redis.get(key); if (!value) { value = await db.query(...); await redis.set(key, value, 'EX', 300); } return value;. (3) CDN: cache static assets, API responses at edge. Use for: images, CSS/JS, public APIs. Strategies: (1) Time-based invalidation: TTL (Time To Live) - cache expires after duration. Set based on data freshness requirements (user profile: 5 min, product catalog: 1 hour). (2) Event-based invalidation: invalidate on data changes: await db.updateUser(id, data); await redis.del('user:' + id);. (3) Lazy invalidation: mark stale, revalidate on next access. Key design: hierarchical keys enable bulk invalidation - user:123:profile, user:123:orders → delete user:123:* on logout. Serialization: JSON.stringify for complex objects, MessagePack for binary efficiency. Cache stampede prevention: lock while refreshing using Redis SET NX EX (official Redis distributed lock pattern) - const lock = await redis.set('lock:key', 'locked', 'NX', 'EX', 10); if (lock) { value = await fetchExpensiveData(); await redis.set(key, value); }. NX (only set if not exists) ensures single client acquires lock, EX (expiration in seconds) prevents deadlocks. Monitoring: hit rate (target >80%), memory usage, eviction rate. Best practices: (1) Cache immutable data aggressively, mutable data conservatively, (2) Never cache auth tokens or PII without encryption, (3) Set max memory and eviction policy (allkeys-lru in Redis), (4) Warm cache on startup for critical data. Performance: Redis cache reduces API latency from 100-500ms to 1-5ms, 100x faster. Valid for Node.js 20+ LTS versions (lru-cache v11+, ioredis/node-redis).

Node.js profiling and optimization (2025 production playbook): Profiling identifies bottlenecks before optimization (measure first, optimize second principle). Production profiling tools: (1) Built-in V8 profiler - Generate profile with node --prof app.js (creates isolate-0xNNNN-v8.log file with CPU sampling data), process with node --prof-process isolate-0xNNNN-v8.log (produces human-readable report showing time spent per function). Shows statistical ticks (samples taken every 1ms), identifies hot functions (top 10 consuming 80%+ CPU). Limitation: requires process restart, only CPU profiling (no memory/async analysis). Use for: quick local profiling during development. (2) Chrome DevTools integration - Start with node --inspect app.js (opens debugger on port 9229), navigate to chrome://inspect in Chrome browser, click Open dedicated DevTools for Node, use Performance tab to record timeline. Captures: CPU profiles (flame graphs showing call stacks), heap snapshots (memory usage by object type), event loop delays, garbage collection pauses. Interactive: zoom into time ranges, filter by function name, compare multiple profiles. Use for: detailed local debugging, memory leak investigation, async bottleneck analysis. (3) Clinic.js suite (comprehensive diagnostics) - Install with npm install -g clinic, three specialized tools: clinic doctor -- node app.js analyzes overall health (event loop utilization, active handles, CPU usage), generates HTML report with recommendations (Detected event loop blocking, suggests async operations). clinic flame -- node app.js creates flame graphs (visualize call stack hierarchy, wider bars = more CPU time), interactive SVG with search/zoom. clinic bubbleprof -- node app.js identifies async delays (shows which async operations block event loop, bubble size = delay magnitude). Load testing integration: combine with autocannon for realistic load (clinic doctor -- node app.js in one terminal, autocannon -c 100 -d 30 http://localhost:3000 in another). Generates annotated report showing bottlenecks under load. (4) Continuous production profiling (always-on monitoring) - APM solutions with <1% overhead: Datadog Continuous Profiler (flame graphs in production, compare deployments, correlate with errors), Pyroscope (open-source, stores historical profiles, query by time range), New Relic (CPU + memory profiles, automatic anomaly detection). Benefits: catch performance regressions immediately after deploy, profile real production traffic (not synthetic load), historical comparison (is this deploy slower than previous?). Sampling frequency: 100Hz (100 samples/second) balances accuracy vs overhead. Essential for production (detect issues before users complain). Production optimization techniques (2025 patterns): (1) Memory allocation reduction - Preallocate buffers: const buffer = Buffer.allocUnsafe(size) (faster than Buffer.alloc, skips zero-fill for ~30% speedup), reuse with buffer.fill(0) when needed. Object pooling: maintain pool of reusable objects (database connections, HTTP agents, large buffers), recycle instead of creating new (avoids GC pressure). Example: connection pool with max 20 connections reuses existing vs creating 1000s per day. Avoid intermediate allocations in hot paths: Bad - items.map(x => transform(x)).filter(x => x.valid).slice(0, 10) creates 3 intermediate arrays. Good - const result = []; for (const item of items) { const t = transform(item); if (t.valid) { result.push(t); if (result.length === 10) break; } } creates single array. Impact: 50-70% memory reduction in hot loops, fewer GC pauses. (2) Regex optimization - Compile once: const pattern = /expression/g defined at module scope, not inside request handler (avoids recompilation overhead 1000s times). Avoid catastrophic backtracking: Bad - /aaa*b/.test(longString) exponential time. Good - /a+b/ linear time. Use anchors: ^pattern$ prevents full-string scanning when matching prefixes/suffixes. Benchmark: 10x faster for complex patterns. (3) Lazy module loading - Defer require until needed: Bad - const heavy = require('./heavy-module') at top (loads 50MB module on startup, 2s cold start). Good - function processData() { const heavy = require('./heavy-module'); ... } (loads only when called). Dynamic imports for async: const heavy = await import('./heavy-module') (non-blocking, parallel loading). Reduces cold start time 60-80% for serverless (AWS Lambda, Cloud Functions). (4) Stream processing for large data - Replace fs.readFileSync(largeFile) (loads entire 1GB file into memory, OOM crash) with fs.createReadStream(largeFile).pipe(transform).pipe(output) (processes chunks incrementally, constant 16KB memory). Stream transform example: csv.parse() → filter → map → json.stringify() → http.response, handles millions of rows with <20MB memory. Backpressure handling: stream automatically pauses when downstream slow (prevents buffer overflow). Use for: file processing, database exports, log analysis. (5) HTTP/2 enablement - Upgrade from HTTP/1.1: const server = http2.createSecureServer(options, app) enables multiplexing (single TCP connection for all requests, vs 6 connections in HTTP/1.1), header compression (HPACK reduces overhead 30-40% for API responses with repetitive headers). Performance: 20-30% faster for high-concurrency scenarios (100+ concurrent requests), eliminates head-of-line blocking. Requires HTTPS (TLS encryption). Supported by Node.js 18+ (stable). (6) Response compression - Middleware: app.use(compression({ level: 6, threshold: 1024 })) compresses responses >1KB using gzip/brotli. Level 6 balances compression ratio (60-70% size reduction) vs CPU cost (3-5ms per request). Brotli (br encoding) achieves 20% better compression than gzip but 2x CPU cost, use for static assets (CDN caching amortizes cost). Skip for already-compressed (images, video) and small payloads (<1KB, overhead exceeds benefit). Impact: 60% bandwidth reduction, 200ms faster load on 3G networks. (7) Database query optimization - Use connection pooling (covered in separate Q&A): max 20 connections prevents database overload. Avoid N+1 queries: Bad - for (const user of users) { const posts = await db.query('SELECT * FROM posts WHERE user_id = $1', [user.id]); } executes 100 queries for 100 users. Good - const posts = await db.query('SELECT * FROM posts WHERE user_id = ANY($1)', [userIds]); loadPostsByUser(posts) single query with IN clause. Use indexes: CREATE INDEX idx_posts_user_id ON posts(user_id) reduces query from 500ms table scan to 5ms index lookup. Monitor with EXPLAIN ANALYZE. (8) Caching strategies - In-memory: LRU cache with lru-cache library (max 500 items, ttl 300000ms = 5min), stores frequently accessed data (user profiles, API responses). Hit rate >80% reduces database load 5x. Distributed: Redis for shared cache across instances, use ioredis with cluster mode (automatic sharding). Cache invalidation: event-based (user.update event → redis.del('user:123')), time-based (TTL expires stale data automatically). Edge caching: Cloudflare/Fastly cache static API responses (304 Not Modified, Cache-Control max-age=3600). (9) Event loop optimization - Avoid blocking: synchronous operations (fs.readFileSync, crypto.pbkdf2Sync, JSON.parse(hugeString)) block event loop, causing request queue buildup. Replace with async alternatives: fs.promises.readFile, crypto.pbkdf2 with callback, streaming JSON parser (jsonstream for large payloads). Break long tasks: process array in chunks with setImmediate: function processLarge(items, index=0) { if (index >= items.length) return done(); process(items[index]); setImmediate(() => processLarge(items, index+1)); } yields to event loop every iteration, prevents blocking (each iteration <10ms). Offload to workers: Worker Threads for CPU-intensive (image processing, cryptography), child_process for isolation (sandboxed code execution). Monitor event loop lag: const lag = require('event-loop-lag')(); lag.on('data', ms => { if (ms > 50) console.warn('Event loop lag:', ms); }) alerts when lag exceeds 50ms (indicates blocking). Production benchmarking (essential): Load testing with autocannon: autocannon -c 100 -d 30 -p 10 http://localhost:3000/api (100 concurrent connections, 30 seconds duration, 10 pipelined requests). Metrics: requests/sec (target >5K for API servers), latency p50/p95/p99 (target p95 <100ms for real-time), throughput MB/sec. Compare before/after optimization (baseline → optimized, expect 2-5x throughput improvement). Stress testing: gradually increase concurrency (10 → 50 → 100 → 500 connections) until failure, identify breaking point (max sustainable load). Production monitoring (continuous): APM dashboards tracking: event loop lag (target <10ms p95, alert >50ms), heap memory usage (target <70% of max, alert approaching limit), garbage collection frequency (target <10 pauses/sec, alert >50), request latency p95/p99 (target <100ms, alert >500ms), error rate (target <0.1%, alert >1%). Correlate performance degradation with deployments (recent code change causing regression?). Best practices (2025 production standards): (1) Profile under realistic load - Don't profile idle server (no bottlenecks visible), use production traffic replay or load testing (autocannon simulating 1000 req/sec). (2) Optimize hot paths only - Pareto principle: 20% of code executes 80% of time, focus on top 10 functions in profiler report (optimizing cold paths wastes effort). (3) Measure before and after - Baseline current performance (requests/sec, latency), apply optimization, re-measure (quantify improvement, avoid regressions). (4) Avoid premature optimization - Don't optimize without profiling data (guessing wrong bottleneck wastes time), profile first (clinic.js identifies real issues). (5) Monitor continuously - Production profiling catches issues missed in dev/staging (real traffic patterns differ from synthetic tests). Real-world performance gains (2025 case studies): Startup migrated from synchronous file I/O to streams: 10x throughput (500 → 5000 req/sec), 80% memory reduction (1GB → 200MB per instance), eliminated OOM crashes. E-commerce API optimized database queries (N+1 → bulk loading): p95 latency 500ms → 50ms (10x faster), reduced database CPU 70% (fewer queries). Fintech app enabled HTTP/2 + compression: page load time 3s → 1.2s (2.5x faster on mobile), bandwidth costs reduced 60%. Essential for production-grade Node.js (achieving 10K+ req/sec per instance with <100ms p95 latency).

Both handle asynchronous data sequences - different programming models and use cases. Readable Streams (event-based, push model): (1) API: Event-driven - stream.on('data', chunk => {}), stream.on('end', () => {}), stream.on('error', err => {}). (2) Backpressure: Manual - stream.pause() when consumer overwhelmed, stream.resume() when ready, or use readable event for pull-based consumption. (3) Piping: Composable - source.pipe(transform).pipe(destination) automatically handles backpressure/errors between streams. (4) Example: const stream = fs.createReadStream('large.txt'); stream.on('data', chunk => db.write(chunk)); stream.on('end', () => db.close()); stream.on('error', err => console.error(err));. Async Iterators (async/await-based, pull model): (1) API: for-await-of syntax - for await (const chunk of stream) { await process(chunk); }. (2) Backpressure: Automatic - loop doesn't pull next chunk until await completes (consumer controls pace). (3) Error handling: try-catch works naturally - try { for await (const chunk of stream) {...} } catch (err) {...}. (4) Example: for await (const chunk of fs.createReadStream('file.txt')) { await db.write(chunk); } (Node.js streams are async iterables). (5) Custom generators: async function* fetchPages(url) { let page = 1; while (page <= 10) { yield await fetch(\${url}?page=${page++}`); } }. **When to use Streams**: (1) Node.js I/O (fs.createReadStream, http.IncomingMessage, process.stdin), (2) Complex transform pipelines (compression, encryption, parsing), (3) Need events (progress tracking, custom events), (4) High-performance scenarios (streams ~10-20% faster for large data), (5) Existing ecosystem (most Node.js I/O is stream-based). **When to use Async Iterators**: (1) Simpler async data processing (database cursors, paginated APIs), (2) Easier error handling (try-catch vs error event), (3) Custom async data sources without stream boilerplate, (4) Readability > raw performance (cleaner code for business logic). **Interoperability (Node.js 18+)**: (1) **Stream → Async Iterator**: All streams are async iterables - use for-await-of directly. (2) **Async Iterator → Stream**: Readable.from(asyncIterable)converts generator to stream. (3) **Web Streams**: ReadableStream (web standard) also supports async iteration. **Example hybrid approach**:async function* queryDB() { const cursor = await db.collection('users').find(); for await (const doc of cursor) { yield transform(doc); } } app.get('/users', async (req, res) => { const stream = Readable.from(queryDB()); stream.pipe(res); });. Database cursor as async iterator, converted to stream for HTTP response. **Best practices**: (1) Streams for I/O, async iterators for business logic, (2) Always handle errors (streams: error event, iterators: try-catch), (3) Implement backpressure (avoid memory leaks), (4) Use pipeline() for error propagation: pipeline(source, transform, destination, err => {})`. Performance (2025): Streams 10-20% faster for large data (optimized buffer management, less async overhead), async iterators more maintainable (fewer bugs). Node.js 20+ improvements: Better stream/async iterator interop, full ReadableStream (WHATWG) support, composable transform streams.

Use express-rate-limit middleware for simple in-memory rate limiting. Installation: npm install express-rate-limit. Basic setup: const rateLimit = require('express-rate-limit'); const limiter = rateLimit({ windowMs: 15 * 60 * 1000 (15 minutes), max: 100 (100 requests per window per IP), standardHeaders: true (adds RateLimit-* headers), message: 'Too many requests' }); app.use(limiter) applies globally, or app.use('/api/', limiter) for specific routes. Per-endpoint limits: app.use('/api/search', rateLimit({ max: 10, windowMs: 60000 })) for expensive operations (10/min), app.use('/api/read', rateLimit({ max: 1000, windowMs: 60000 })) for cheap reads (1000/min). Response: 429 Too Many Requests with headers RateLimit-Limit: 100, RateLimit-Remaining: 0, Retry-After: 57. Limitation: In-memory storage - limits reset on restart, not shared across multiple server instances. Use case: Single-server apps, development/staging, quick prototyping. For production multi-instance deployments, use Redis-based distributed rate limiting.

Use rate-limit-redis store for shared rate limiting across multiple server instances. Setup: npm install rate-limit-redis redis. Implementation: const RedisStore = require('rate-limit-redis'); const redis = require('redis').createClient({ host: 'redis.prod.com', port: 6379 }); const limiter = rateLimit({ store: new RedisStore({ client: redis, prefix: 'rl:' }), windowMs: 60000, max: 100 }); app.use(limiter). Benefits: Shared state across all instances (horizontally scalable, consistent limits regardless of which server handles request), persistent across restarts (Redis retains counts), high performance (Redis INCR <1ms). Architecture: All servers connect to shared Redis cluster, each request increments counter for client key (IP or user ID), Redis TTL auto-expires old windows. Use case: Production APIs with multiple instances (Kubernetes, load balancers), 10K-1M+ req/sec throughput. Performance: 1-2ms overhead per request (Redis network RTT + INCR operation). Connection pooling essential for high throughput. Alternative: Use Redis Cluster for horizontal scaling to millions of clients.

Robust error handling and logging prevent crashes and enable debugging. Error handling (Node.js official Process documentation): (1) Async errors: always use try-catch with async/await or .catch() with promises. Critical: unhandled promise rejections crash process in Node.js 15+ (default behavior changed from deprecation warning to termination). When --unhandled-rejections flag set to strict or throw (default) and rejection not handled, triggers crash. (2) Synchronous errors: try-catch around sync code. (3) Event emitter errors: emitter.on('error', handler) for streams, servers (prevents uncaught exceptions from event-based I/O). (4) Global handlers (last resort only): process.on('uncaughtException', err => { log.error(err); process.exit(1); }); and process.on('unhandledRejection', err => { log.error(err); process.exit(1); });. Official warning: 'uncaughtException' is crude mechanism for exception handling, intended only as last resort. Should NOT be used as equivalent to On Error Resume Next. Unhandled exceptions inherently mean application in undefined state - attempting to resume without proper recovery causes additional unforeseen issues. Always log and exit (process may be in inconsistent state). 'unhandledRejection' event useful for detecting/tracking promises rejected without handlers, but modern Node.js crashes by default. Express error handling: middleware with 4 params (signature distinguishes from regular middleware): app.use((err, req, res, next) => { log.error(err); res.status(500).json({ error: 'Internal server error' }); });. Never send stack traces to clients in production (security risk, information disclosure). Logging: (1) Structured logging: use JSON format for parsing (enables log aggregation, querying): log.info({ user_id: 123, action: 'login', ip: '1.2.3.4' });. (2) Log levels: error (bugs requiring immediate attention), warn (potential issues, degraded functionality), info (significant events, startup/shutdown), debug (detailed for development only). (3) Libraries: pino (fastest, 5-10x faster than winston, asynchronous by default), winston (feature-rich, transports), bunyan (structured, deprecated but still used). (4) Contextual logging: correlation IDs across requests for distributed tracing: const logger = log.child({ req_id: uuid() }); creates child logger with request-specific context. AsyncLocalStorage (Node.js async_hooks module, official API) recommended for automatic context propagation across async boundaries. (5) Sensitive data: redact passwords, tokens, PII: log.info({ email, password: '[REDACTED]' });. GDPR/compliance requirement for production systems. Centralized logging: ship logs to ELK Stack (Elasticsearch, Logstash, Kibana), Datadog, CloudWatch. Use log aggregation agents (Fluentd, Logstash) or direct HTTP streaming. Best practices: (1) Log errors with context (user, request, state, stack trace for debugging), (2) Don't log in synchronous hot paths (blocks event loop), use async logging (pino async mode), (3) Rotate logs (logrotate, PM2 handles this automatically), (4) Set log levels via environment (DEBUG in dev, INFO in prod, reduce noise), (5) Monitor error rates (alert on spikes indicating incidents). Performance: pino with pino-pretty in production achieves <1ms per log statement (asynchronous write, worker thread processing). APM: integrate with application performance monitoring (New Relic, Datadog APM) for automatic error tracking, distributed tracing, performance profiling. Valid for Node.js 20+ LTS versions (Node.js 18 EOL 2025).

Health checks determine if application is running correctly, critical for Kubernetes self-healing and load balancing. Types (Kubernetes official documentation): (1) Liveness probe: kubelet uses liveness probes to know when to restart container. Checks if app is alive (responds to requests). Kubernetes kills pod if liveness fails. Use for detecting deadlocks, infinite loops, process hanging. (2) Readiness probe: determines if container ready to receive traffic. Kubernetes removes from Service load balancers if readiness fails (temporarily, not restarted). Use during startup or temporary unavailability (DB connection lost). (3) Startup probe (introduced for long startup times): while startup probe running, liveness and readiness probes disabled. Once startup succeeds, other probes become active. Addresses variable/long startup times without making liveness probe overly lenient. Implementation (Node.js Reference Architecture - Red Hat/IBM official guidance): HTTP probe type (httpGet) recommended, demonstrates HTTP server up and responding to requests. Endpoint naming: 'z pages' pattern (/livez, /readyz) used by internal Kubernetes services. Response must be status 200/OK (body content not required). app.get('/livez', (req, res) => { res.status(200).send('OK'); }); for liveness (lightweight, always passes unless process hung). Warning: For liveness probes particularly, additional internal state checks often do more harm than good (end result is container restart, which may not fix actual problem - creates restart loops). app.get('/readyz', async (req, res) => { try { await db.query('SELECT 1'); await redis.ping(); res.status(200).send('OK'); } catch (err) { res.status(503).send('Not ready'); } }); for readiness (checks dependencies - safe to check because failure only removes from load balancer, doesn't restart). Kubernetes configuration: livenessProbe: { httpGet: { path: /livez, port: 3000 }, initialDelaySeconds: 30, periodSeconds: 10 }; readinessProbe: { httpGet: { path: /readyz, port: 3000 }, initialDelaySeconds: 5, periodSeconds: 5 }. Best practices (2025 production): (1) Liveness simple and fast (<100ms), no dependency checks (avoid restart loops when DB temporarily unavailable), (2) Readiness checks all dependencies (DB, Redis, downstream APIs) - failure removes from traffic but preserves container for debugging, (3) Different paths for liveness/readiness (avoid cascading failures where DB issue causes liveness failures across cluster), (4) Include startup probe for slow-starting apps: startupProbe: { httpGet: { path: /readyz, port: 3000 }, initialDelaySeconds: 0, periodSeconds: 10, failureThreshold: 30 } gives 300s startup time (10s × 30 attempts) before liveness/readiness activate, (5) Timeout: keep probe timeout < periodSeconds (prevents overlapping probes). Libraries: lightship (abstracts readiness, liveness, startup checks and graceful shutdown for Kubernetes, official Node.js Reference Architecture recommendation), terminus (HTTP-specific automatic health checks). Advanced: include version, uptime, dependencies in response for debugging: { status: 'healthy', version: '1.0.0', uptime: process.uptime(), dependencies: { db: 'connected', redis: 'connected' } }. Common mistakes (avoid these): checking dependencies in liveness (DB down → liveness fails → pod restarts → still DB down → infinite restart loop, wastes resources and prevents debugging), probes too aggressive (periodSeconds too short causes false positives under load, kills healthy containers). Performance: health checks add <1ms overhead per probe interval (default 10s), negligible for production applications. Integration with graceful shutdown: readiness probe should fail immediately when shutdown signal (SIGTERM) received, allowing terminationGracePeriodSeconds (default 30s) for in-flight requests to complete before SIGKILL. Valid for Node.js 20+ LTS versions, Kubernetes 1.20+.

Worker Threads and Clustering both enable multi-core utilization but serve different purposes (Node.js official documentation v25.2.0). Clustering: creates multiple Node.js processes via child_process.fork(), each with independent event loop, memory, and V8 instance. All processes share same server port. Use cases: horizontal scaling across cores, handling concurrent HTTP requests. Implementation: const cluster = require('cluster'); if (cluster.isPrimary) { for (let i = 0; i < numCPUs; i++) cluster.fork(); } else { app.listen(3000); }. Benefits: 20% higher performance under heavy load, automatic request distribution, process isolation (crash doesn't affect others). Drawbacks: high memory overhead (full Node.js per process), inter-process communication (IPC) required for shared state. Worker Threads: runs JavaScript in multiple threads within same process, shares memory via SharedArrayBuffer and can transfer ArrayBuffer instances. Official recommendation: when process isolation is not needed, use worker_threads module instead of child_process or cluster for running multiple application threads within single Node.js instance. Use cases: CPU-intensive tasks (image processing, cryptography, data compression) without blocking event loop. Implementation: const { Worker } = require('worker_threads'); const worker = new Worker('./task.js'); worker.postMessage(data);. Benefits: 70% faster for CPU-bound tasks, lower memory overhead than clustering, shared memory possible, two-way inter-thread message passing. Drawbacks: no separate event loop per thread (blocking operations still block). Recommendation: use Clustering for I/O-bound web servers (APIs, HTTP services), use Worker Threads for CPU-intensive operations within those servers. Combine both: clustered web server where each process uses Worker Threads for heavy tasks. Best practice: PM2 or Node cluster module for clustering, Worker Threads for specific CPU operations. Performance: 4-core system - clustering achieves 3.5-4x throughput for HTTP servers, Worker Threads achieve near-linear speedup for parallelizable CPU tasks. Valid for Node.js 20+ LTS versions.

Event loop is Node.js's core concurrency mechanism - single-threaded loop processing callbacks from queue. Phases (official Node.js documentation): (1) Timers: executes setTimeout/setInterval callbacks, (2) Pending callbacks: I/O callbacks deferred from previous cycle, (3) Idle/prepare: internal use, (4) Poll: retrieves new I/O events, executes I/O callbacks (most time spent here), (5) Check: setImmediate callbacks, (6) Close callbacks: socket.on('close'). Each phase has FIFO queue of callbacks. Event loop processes all callbacks in phase before moving to next. Microtask queue (process.nextTick executed immediately after current operation completes before next phase, promises processed as microtasks) - process.nextTick runs before promise microtasks. Important: process.nextTick is NOT technically part of event loop phases (processed between phases). Can starve event loop if infinite recursion (nextTickQueue blocks phase progression). Node.js 11+ improvement: microtasks run between individual timer/immediate callbacks. Blocking pitfalls: (1) Synchronous operations: fs.readFileSync, JSON.parse(huge_string), crypto.pbkdf2Sync block event loop entirely, (2) Heavy computation: loops processing large arrays, regex on large strings, complex calculations, (3) Synchronous APIs in libraries: some npm packages use sync operations internally. Consequences: request latency spikes (all requests wait), timeouts, poor throughput. Monitoring: event loop lag (time between scheduled and actual execution) - target <10ms, alert if >50ms. Solutions: (1) Replace sync with async: fs.promises.readFile, worker threads for heavy computation, (2) Break long tasks: use setImmediate to yield: function processArray(arr, index = 0) { if (index >= arr.length) return done(); process(arr[index]); setImmediate(() => processArray(arr, index + 1)); }, (3) Offload to workers: Worker Threads or child processes. Best practices: never block event loop >10ms, profile with clinic.js or --inspect, use async/await for all I/O. Performance: well-designed Node.js server handles 10K+ concurrent connections with <10ms response times. Valid for Node.js 20+ LTS versions (Node.js 18 reached EOL in 2025).

Connection pooling reuses connections instead of creating new ones per request, essential for Node.js performance (10-50x improvement). Database connection pooling (2025 production patterns): PostgreSQL with pg library (official node-postgres documentation) - const { Pool } = require('pg'); const pool = new Pool({ max: 20, min: 5, idleTimeoutMillis: 30000, connectionTimeoutMillis: 2000, allowExitOnIdle: false }). Why pooling: connecting new client requires 20-30ms handshake (password negotiation, SSL establishment, configuration sharing), PostgreSQL can only handle limited clients (unbounded connections crash server). Recommended: limited number of pools (usually just 1) for reusable client checkout/return. Configuration parameters (official pg-pool API): (1) max - maximum pool size (default 10), calculate based on: database max_connections limit (PostgreSQL default 100), number of application instances (4 instances × 20 connections = 80 total), reserve 20% for admin/monitoring (80 < 100 OK). Formula for CPU-bound apps: max = num_cores * 2 + 1. For I/O-bound (typical): start 10-20, increase if pool exhaustion detected. (2) min - minimum idle connections (default 0), keep warm connections ready (avoid cold start latency). Set to expected baseline concurrency (5-10 typical). (3) idleTimeoutMillis - close idle connections after timeout (default 10s), balance between connection reuse vs holding resources. Production: 30-60 seconds prevents churning, allows database cleanup. (4) connectionTimeoutMillis - max wait for available connection (default none), fail-fast prevents request pileup. Set to 2-5 seconds, return 503 Service Unavailable if pool exhausted. (5) allowExitOnIdle - prevent process exit when pool idle (set false for production, true for tests/scripts). Usage pattern (always release connections): const client = await pool.connect(); try { const result = await client.query('SELECT * FROM users WHERE id = $1', [userId]); return result.rows[0]; } finally { client.release(); }. Never forget release() or pool leaks, use try-finally even with async/await. Alternative: pool.query() for simple queries (auto-release): const result = await pool.query('SELECT NOW()'). Monitoring production pools: Track metrics - pool.totalCount (total connections), pool.idleCount (available), pool.waitingCount (queued requests). Alert when waitingCount > 0 (pool exhaustion), idleCount = 0 (increase max), totalCount approaches max (capacity limit). Libraries: node-postgres-prometheus for Prometheus metrics export. MySQL with mysql2 library: const pool = mysql.createPool({ host, user, password, database, connectionLimit: 20, queueLimit: 100, waitForConnections: true, enableKeepAlive: true, keepAliveInitialDelay: 10000 }). Key differences: connectionLimit (equivalent to pg max), queueLimit (max queued requests, prevents infinite backlog), enableKeepAlive (TCP keepalive prevents connection loss). MongoDB with native driver: const client = new MongoClient(uri, { maxPoolSize: 50, minPoolSize: 5, maxIdleTimeMS: 30000, serverSelectionTimeoutMS: 5000 }). Higher maxPoolSize than SQL databases (MongoDB designed for connection pooling, replica sets distribute load). HTTP connection pooling for external APIs (2025): axios with custom agent - const http = require('http'); const https = require('https'); const httpAgent = new http.Agent({ keepAlive: true, maxSockets: 50, maxFreeSockets: 10, timeout: 60000 }); const httpsAgent = new https.Agent({ keepAlive: true, maxSockets: 50, maxFreeSockets: 10, timeout: 60000 }); const axios = require('axios').create({ httpAgent, httpsAgent }). Parameters: keepAlive - reuse TCP connections (saves 50-200ms TLS handshake per request), maxSockets - max concurrent connections per host (default Infinity, set to 50-100 to prevent overwhelming downstream), maxFreeSockets - max idle connections kept in pool (default 256, reduce to 10-20 to free resources), timeout - socket idle timeout before close (60s typical, balance reuse vs resource holding). Benefits quantified: Without pooling - create connection (50ms TCP + 150ms TLS) + request (100ms) = 300ms total. With pooling - reuse connection (0ms) + request (100ms) = 100ms total (3x faster). High-volume APIs (1K+ req/sec) save thousands of TLS handshakes per second. node-fetch (native fetch in Node 20+) pooling: Global HTTP agents automatically pool by default, configure with undici (underlying HTTP client) - const { Agent, setGlobalDispatcher } = require('undici'); setGlobalDispatcher(new Agent({ connections: 50, pipelining: 10 })). connections - max connections per origin, pipelining - max pipelined requests per connection (HTTP/1.1 optimization). Redis connection pooling with ioredis: const Redis = require('ioredis'); const redis = new Redis.Cluster([{ host: 'localhost', port: 6379 }], { maxRetriesPerRequest: 3, enableReadyCheck: true, lazyConnect: false }). Cluster mode auto-pools connections across nodes, single instance uses single persistent connection (lightweight protocol, pooling not required). Best practices (2025 production checklist): (1) Single pool per application - create pool at startup (singleton), share across all request handlers. Anti-pattern: new Pool() inside request handler (creates pool per request, defeats purpose). (2) Always release connections - use try-finally or pool.query() auto-release. Leaked connections cause gradual pool exhaustion (symptoms: slow response times after hours/days uptime). (3) Configure timeouts - connectionTimeoutMillis prevents infinite waits, query timeout prevents long-running queries blocking pool: await client.query({ text: 'SELECT...', timeout: 5000 }). (4) Monitor pool health - expose metrics endpoint (Prometheus /metrics), alert on pool exhaustion (waitingCount > 0), high latency (P95 > 100ms), connection errors. (5) Separate pools for different workloads - read replica pool for analytics (high concurrency, slow queries), write pool for transactions (low concurrency, fast queries). Prevents slow analytical queries blocking fast transactional queries. (6) Graceful shutdown - drain pools on SIGTERM: process.on('SIGTERM', async () => { await pool.end(); await redisClient.quit(); }). Prevents connection leaks during rolling deploys. (7) Connection validation - enable keepalive to detect stale connections (database restarted, network interruption). PostgreSQL: pool.on('error', (err) => logger.error('Pool error', err)); reconnects automatically. (8) Pool sizing for serverless (AWS Lambda, Cloud Functions) - max: 1-2 per function instance (ephemeral, high concurrency scales horizontally). Use connection pooling proxy (RDS Proxy, Neon serverless) to multiplex connections. Common mistakes and fixes (2025): Mistake 1 - Pool per request. Code: app.get('/', async (req, res) => { const pool = new Pool(); ... }). Fix: const pool = new Pool(); (global scope), app.get('/', async (req, res) => { pool.query... }). Mistake 2 - Not releasing on error. Code: const client = await pool.connect(); await client.query(); client.release();. Fix: try { ... } finally { client.release(); }. Mistake 3 - Pool size = database max_connections. Database: max_connections = 100, App: 10 instances × 20 pool size = 200 total (oversubscribed). Fix: total_connections_across_all_instances < db_max_connections. 10 instances × 8 connections = 80 (safe). Mistake 4 - No connection timeout. Pool exhausts, requests wait forever (memory leak, process hangs). Fix: connectionTimeoutMillis: 2000, fail fast with 503 error. Mistake 5 - Mixing HTTP clients without pooling. Code: app.get('/', () => fetch(url)). fetch() in Node 20+ pools by default (OK), but axios without agent doesn't pool (add httpAgent). Performance benchmarks (2025 production): Scenario: Node.js API → PostgreSQL query (100ms latency). Without pooling (create connection per request): 50ms connect + 100ms query = 150ms total. Throughput: 6 req/sec per connection (connection overhead dominates). With pooling (reuse connections, pool size 20): 0ms connect + 100ms query = 100ms total. Throughput: 200 req/sec (20 concurrent queries, 10 req/sec each). 33x improvement. HTTP API pooling: External API call (200ms latency). Without keepAlive: 50ms TCP + 150ms TLS + 200ms request = 400ms. With keepAlive (pooling): 0ms + 0ms + 200ms = 200ms (2x faster). At 1K req/sec: saves 200 seconds of TLS handshakes per second (impossible without pooling, would need 200+ CPU cores). Production pool configuration examples (2025): Small app (1 instance, 100 req/sec): PostgreSQL max: 10, min: 2, MySQL max: 10, HTTP maxSockets: 20. Medium app (4 instances, 1K req/sec total): PostgreSQL max: 15 per instance (60 total < 100 db limit), MySQL max: 20, HTTP maxSockets: 50. Large app (20 instances, 10K req/sec total): PostgreSQL max: 4 per instance (80 total < 100 db limit), use read replicas (separate pool per replica), MySQL max: 10, HTTP maxSockets: 100. Serverless (Lambda/Cloud Functions): PostgreSQL max: 1-2 per function, use RDS Proxy (pools across all Lambdas), HTTP maxSockets: 10 (ephemeral, many instances). Valid for Node.js 20+ LTS versions.

Graceful shutdown ensures in-flight requests complete before process exits, preventing data loss and client errors. Implementation pattern (community best practice verified across production deployments): (1) Listen for signals: process.on('SIGTERM', gracefulShutdown); process.on('SIGINT', gracefulShutdown);. SIGTERM sent by Kubernetes/Docker on pod termination (Unix-based systems interrupt/terminate signal), SIGINT from Ctrl+C (manual user interruption). (2) Stop accepting new requests: server.close(() => { /* shutdown complete */ });. Node.js HTTP server close() method (official API) stops listening but waits for existing connections to complete. (3) Wait for in-flight requests: set timeout (30s typical) for requests to complete: setTimeout(() => { process.exit(1); }, 30000);. Forces exit if graceful shutdown exceeds timeout (prevents indefinite hangs). (4) Close resources: disconnect databases (await db.end()), flush logs, close message queue connections. Pattern: async function gracefulShutdown(signal) { console.log('${signal} received, starting graceful shutdown'); server.close(async () => { await db.end(); await redis.quit(); await messageQueue.close(); console.log('Shutdown complete'); process.exit(0); }); setTimeout(() => { console.error('Forced shutdown after timeout'); process.exit(1); }, 30000); }. HTTP keep-alive handling: server.keepAliveTimeout = 5000; prevents long-lived connections from blocking shutdown, or use terminus library for automatic connection draining. Kubernetes integration: readiness probe fails immediately on shutdown signal, allowing 30s (default terminationGracePeriodSeconds) before SIGKILL forces termination. Best practices: (1) Health endpoint returns 503 during shutdown (signals not ready to load balancer), (2) Log shutdown progress for debugging, (3) Flush logs/metrics before exit (prevent data loss), (4) Test graceful shutdown in staging (kill pods during load to verify zero errors). Common issues: (1) Database connections not closed (connection leaks in pool), (2) Message queue acks not sent (duplicate processing on restart), (3) Logs truncated (flush before exit). Libraries: terminus (HTTP-specific graceful shutdown), lightship (comprehensive shutdown with readiness/liveness integration). Performance: graceful shutdown prevents 500 errors during deploys, enables zero-downtime rolling updates. Valid for Node.js 20+ LTS versions.

Caching stores frequently accessed data in fast storage, reducing latency and database load. Layers: (1) In-memory cache (LRU): const LRU = require('lru-cache'); const cache = new LRU({ max: 500, ttl: 1000 * 60 * 5 });. Best for: small datasets, single-server apps. Drawbacks: lost on restart, not shared across instances. (2) Redis: distributed cache, shared across instances. Patterns: cache-aside (app checks cache, fetches from DB on miss, populates cache), write-through (writes update cache + DB synchronously), write-behind (async writes to DB). Implementation: const value = await redis.get(key); if (!value) { value = await db.query(...); await redis.set(key, value, 'EX', 300); } return value;. (3) CDN: cache static assets, API responses at edge. Use for: images, CSS/JS, public APIs. Strategies: (1) Time-based invalidation: TTL (Time To Live) - cache expires after duration. Set based on data freshness requirements (user profile: 5 min, product catalog: 1 hour). (2) Event-based invalidation: invalidate on data changes: await db.updateUser(id, data); await redis.del('user:' + id);. (3) Lazy invalidation: mark stale, revalidate on next access. Key design: hierarchical keys enable bulk invalidation - user:123:profile, user:123:orders → delete user:123:* on logout. Serialization: JSON.stringify for complex objects, MessagePack for binary efficiency. Cache stampede prevention: lock while refreshing using Redis SET NX EX (official Redis distributed lock pattern) - const lock = await redis.set('lock:key', 'locked', 'NX', 'EX', 10); if (lock) { value = await fetchExpensiveData(); await redis.set(key, value); }. NX (only set if not exists) ensures single client acquires lock, EX (expiration in seconds) prevents deadlocks. Monitoring: hit rate (target >80%), memory usage, eviction rate. Best practices: (1) Cache immutable data aggressively, mutable data conservatively, (2) Never cache auth tokens or PII without encryption, (3) Set max memory and eviction policy (allkeys-lru in Redis), (4) Warm cache on startup for critical data. Performance: Redis cache reduces API latency from 100-500ms to 1-5ms, 100x faster. Valid for Node.js 20+ LTS versions (lru-cache v11+, ioredis/node-redis).

Node.js profiling and optimization (2025 production playbook): Profiling identifies bottlenecks before optimization (measure first, optimize second principle). Production profiling tools: (1) Built-in V8 profiler - Generate profile with node --prof app.js (creates isolate-0xNNNN-v8.log file with CPU sampling data), process with node --prof-process isolate-0xNNNN-v8.log (produces human-readable report showing time spent per function). Shows statistical ticks (samples taken every 1ms), identifies hot functions (top 10 consuming 80%+ CPU). Limitation: requires process restart, only CPU profiling (no memory/async analysis). Use for: quick local profiling during development. (2) Chrome DevTools integration - Start with node --inspect app.js (opens debugger on port 9229), navigate to chrome://inspect in Chrome browser, click Open dedicated DevTools for Node, use Performance tab to record timeline. Captures: CPU profiles (flame graphs showing call stacks), heap snapshots (memory usage by object type), event loop delays, garbage collection pauses. Interactive: zoom into time ranges, filter by function name, compare multiple profiles. Use for: detailed local debugging, memory leak investigation, async bottleneck analysis. (3) Clinic.js suite (comprehensive diagnostics) - Install with npm install -g clinic, three specialized tools: clinic doctor -- node app.js analyzes overall health (event loop utilization, active handles, CPU usage), generates HTML report with recommendations (Detected event loop blocking, suggests async operations). clinic flame -- node app.js creates flame graphs (visualize call stack hierarchy, wider bars = more CPU time), interactive SVG with search/zoom. clinic bubbleprof -- node app.js identifies async delays (shows which async operations block event loop, bubble size = delay magnitude). Load testing integration: combine with autocannon for realistic load (clinic doctor -- node app.js in one terminal, autocannon -c 100 -d 30 http://localhost:3000 in another). Generates annotated report showing bottlenecks under load. (4) Continuous production profiling (always-on monitoring) - APM solutions with <1% overhead: Datadog Continuous Profiler (flame graphs in production, compare deployments, correlate with errors), Pyroscope (open-source, stores historical profiles, query by time range), New Relic (CPU + memory profiles, automatic anomaly detection). Benefits: catch performance regressions immediately after deploy, profile real production traffic (not synthetic load), historical comparison (is this deploy slower than previous?). Sampling frequency: 100Hz (100 samples/second) balances accuracy vs overhead. Essential for production (detect issues before users complain). Production optimization techniques (2025 patterns): (1) Memory allocation reduction - Preallocate buffers: const buffer = Buffer.allocUnsafe(size) (faster than Buffer.alloc, skips zero-fill for ~30% speedup), reuse with buffer.fill(0) when needed. Object pooling: maintain pool of reusable objects (database connections, HTTP agents, large buffers), recycle instead of creating new (avoids GC pressure). Example: connection pool with max 20 connections reuses existing vs creating 1000s per day. Avoid intermediate allocations in hot paths: Bad - items.map(x => transform(x)).filter(x => x.valid).slice(0, 10) creates 3 intermediate arrays. Good - const result = []; for (const item of items) { const t = transform(item); if (t.valid) { result.push(t); if (result.length === 10) break; } } creates single array. Impact: 50-70% memory reduction in hot loops, fewer GC pauses. (2) Regex optimization - Compile once: const pattern = /expression/g defined at module scope, not inside request handler (avoids recompilation overhead 1000s times). Avoid catastrophic backtracking: Bad - /aaa*b/.test(longString) exponential time. Good - /a+b/ linear time. Use anchors: ^pattern$ prevents full-string scanning when matching prefixes/suffixes. Benchmark: 10x faster for complex patterns. (3) Lazy module loading - Defer require until needed: Bad - const heavy = require('./heavy-module') at top (loads 50MB module on startup, 2s cold start). Good - function processData() { const heavy = require('./heavy-module'); ... } (loads only when called). Dynamic imports for async: const heavy = await import('./heavy-module') (non-blocking, parallel loading). Reduces cold start time 60-80% for serverless (AWS Lambda, Cloud Functions). (4) Stream processing for large data - Replace fs.readFileSync(largeFile) (loads entire 1GB file into memory, OOM crash) with fs.createReadStream(largeFile).pipe(transform).pipe(output) (processes chunks incrementally, constant 16KB memory). Stream transform example: csv.parse() → filter → map → json.stringify() → http.response, handles millions of rows with <20MB memory. Backpressure handling: stream automatically pauses when downstream slow (prevents buffer overflow). Use for: file processing, database exports, log analysis. (5) HTTP/2 enablement - Upgrade from HTTP/1.1: const server = http2.createSecureServer(options, app) enables multiplexing (single TCP connection for all requests, vs 6 connections in HTTP/1.1), header compression (HPACK reduces overhead 30-40% for API responses with repetitive headers). Performance: 20-30% faster for high-concurrency scenarios (100+ concurrent requests), eliminates head-of-line blocking. Requires HTTPS (TLS encryption). Supported by Node.js 18+ (stable). (6) Response compression - Middleware: app.use(compression({ level: 6, threshold: 1024 })) compresses responses >1KB using gzip/brotli. Level 6 balances compression ratio (60-70% size reduction) vs CPU cost (3-5ms per request). Brotli (br encoding) achieves 20% better compression than gzip but 2x CPU cost, use for static assets (CDN caching amortizes cost). Skip for already-compressed (images, video) and small payloads (<1KB, overhead exceeds benefit). Impact: 60% bandwidth reduction, 200ms faster load on 3G networks. (7) Database query optimization - Use connection pooling (covered in separate Q&A): max 20 connections prevents database overload. Avoid N+1 queries: Bad - for (const user of users) { const posts = await db.query('SELECT * FROM posts WHERE user_id = $1', [user.id]); } executes 100 queries for 100 users. Good - const posts = await db.query('SELECT * FROM posts WHERE user_id = ANY($1)', [userIds]); loadPostsByUser(posts) single query with IN clause. Use indexes: CREATE INDEX idx_posts_user_id ON posts(user_id) reduces query from 500ms table scan to 5ms index lookup. Monitor with EXPLAIN ANALYZE. (8) Caching strategies - In-memory: LRU cache with lru-cache library (max 500 items, ttl 300000ms = 5min), stores frequently accessed data (user profiles, API responses). Hit rate >80% reduces database load 5x. Distributed: Redis for shared cache across instances, use ioredis with cluster mode (automatic sharding). Cache invalidation: event-based (user.update event → redis.del('user:123')), time-based (TTL expires stale data automatically). Edge caching: Cloudflare/Fastly cache static API responses (304 Not Modified, Cache-Control max-age=3600). (9) Event loop optimization - Avoid blocking: synchronous operations (fs.readFileSync, crypto.pbkdf2Sync, JSON.parse(hugeString)) block event loop, causing request queue buildup. Replace with async alternatives: fs.promises.readFile, crypto.pbkdf2 with callback, streaming JSON parser (jsonstream for large payloads). Break long tasks: process array in chunks with setImmediate: function processLarge(items, index=0) { if (index >= items.length) return done(); process(items[index]); setImmediate(() => processLarge(items, index+1)); } yields to event loop every iteration, prevents blocking (each iteration <10ms). Offload to workers: Worker Threads for CPU-intensive (image processing, cryptography), child_process for isolation (sandboxed code execution). Monitor event loop lag: const lag = require('event-loop-lag')(); lag.on('data', ms => { if (ms > 50) console.warn('Event loop lag:', ms); }) alerts when lag exceeds 50ms (indicates blocking). Production benchmarking (essential): Load testing with autocannon: autocannon -c 100 -d 30 -p 10 http://localhost:3000/api (100 concurrent connections, 30 seconds duration, 10 pipelined requests). Metrics: requests/sec (target >5K for API servers), latency p50/p95/p99 (target p95 <100ms for real-time), throughput MB/sec. Compare before/after optimization (baseline → optimized, expect 2-5x throughput improvement). Stress testing: gradually increase concurrency (10 → 50 → 100 → 500 connections) until failure, identify breaking point (max sustainable load). Production monitoring (continuous): APM dashboards tracking: event loop lag (target <10ms p95, alert >50ms), heap memory usage (target <70% of max, alert approaching limit), garbage collection frequency (target <10 pauses/sec, alert >50), request latency p95/p99 (target <100ms, alert >500ms), error rate (target <0.1%, alert >1%). Correlate performance degradation with deployments (recent code change causing regression?). Best practices (2025 production standards): (1) Profile under realistic load - Don't profile idle server (no bottlenecks visible), use production traffic replay or load testing (autocannon simulating 1000 req/sec). (2) Optimize hot paths only - Pareto principle: 20% of code executes 80% of time, focus on top 10 functions in profiler report (optimizing cold paths wastes effort). (3) Measure before and after - Baseline current performance (requests/sec, latency), apply optimization, re-measure (quantify improvement, avoid regressions). (4) Avoid premature optimization - Don't optimize without profiling data (guessing wrong bottleneck wastes time), profile first (clinic.js identifies real issues). (5) Monitor continuously - Production profiling catches issues missed in dev/staging (real traffic patterns differ from synthetic tests). Real-world performance gains (2025 case studies): Startup migrated from synchronous file I/O to streams: 10x throughput (500 → 5000 req/sec), 80% memory reduction (1GB → 200MB per instance), eliminated OOM crashes. E-commerce API optimized database queries (N+1 → bulk loading): p95 latency 500ms → 50ms (10x faster), reduced database CPU 70% (fewer queries). Fintech app enabled HTTP/2 + compression: page load time 3s → 1.2s (2.5x faster on mobile), bandwidth costs reduced 60%. Essential for production-grade Node.js (achieving 10K+ req/sec per instance with <100ms p95 latency).

Both handle asynchronous data sequences - different programming models and use cases. Readable Streams (event-based, push model): (1) API: Event-driven - stream.on('data', chunk => {}), stream.on('end', () => {}), stream.on('error', err => {}). (2) Backpressure: Manual - stream.pause() when consumer overwhelmed, stream.resume() when ready, or use readable event for pull-based consumption. (3) Piping: Composable - source.pipe(transform).pipe(destination) automatically handles backpressure/errors between streams. (4) Example: const stream = fs.createReadStream('large.txt'); stream.on('data', chunk => db.write(chunk)); stream.on('end', () => db.close()); stream.on('error', err => console.error(err));. Async Iterators (async/await-based, pull model): (1) API: for-await-of syntax - for await (const chunk of stream) { await process(chunk); }. (2) Backpressure: Automatic - loop doesn't pull next chunk until await completes (consumer controls pace). (3) Error handling: try-catch works naturally - try { for await (const chunk of stream) {...} } catch (err) {...}. (4) Example: for await (const chunk of fs.createReadStream('file.txt')) { await db.write(chunk); } (Node.js streams are async iterables). (5) Custom generators: async function* fetchPages(url) { let page = 1; while (page <= 10) { yield await fetch(\${url}?page=${page++}`); } }. **When to use Streams**: (1) Node.js I/O (fs.createReadStream, http.IncomingMessage, process.stdin), (2) Complex transform pipelines (compression, encryption, parsing), (3) Need events (progress tracking, custom events), (4) High-performance scenarios (streams ~10-20% faster for large data), (5) Existing ecosystem (most Node.js I/O is stream-based). **When to use Async Iterators**: (1) Simpler async data processing (database cursors, paginated APIs), (2) Easier error handling (try-catch vs error event), (3) Custom async data sources without stream boilerplate, (4) Readability > raw performance (cleaner code for business logic). **Interoperability (Node.js 18+)**: (1) **Stream → Async Iterator**: All streams are async iterables - use for-await-of directly. (2) **Async Iterator → Stream**: Readable.from(asyncIterable)converts generator to stream. (3) **Web Streams**: ReadableStream (web standard) also supports async iteration. **Example hybrid approach**:async function* queryDB() { const cursor = await db.collection('users').find(); for await (const doc of cursor) { yield transform(doc); } } app.get('/users', async (req, res) => { const stream = Readable.from(queryDB()); stream.pipe(res); });. Database cursor as async iterator, converted to stream for HTTP response. **Best practices**: (1) Streams for I/O, async iterators for business logic, (2) Always handle errors (streams: error event, iterators: try-catch), (3) Implement backpressure (avoid memory leaks), (4) Use pipeline() for error propagation: pipeline(source, transform, destination, err => {})`. Performance (2025): Streams 10-20% faster for large data (optimized buffer management, less async overhead), async iterators more maintainable (fewer bugs). Node.js 20+ improvements: Better stream/async iterator interop, full ReadableStream (WHATWG) support, composable transform streams.

Use express-rate-limit middleware for simple in-memory rate limiting. Installation: npm install express-rate-limit. Basic setup: const rateLimit = require('express-rate-limit'); const limiter = rateLimit({ windowMs: 15 * 60 * 1000 (15 minutes), max: 100 (100 requests per window per IP), standardHeaders: true (adds RateLimit-* headers), message: 'Too many requests' }); app.use(limiter) applies globally, or app.use('/api/', limiter) for specific routes. Per-endpoint limits: app.use('/api/search', rateLimit({ max: 10, windowMs: 60000 })) for expensive operations (10/min), app.use('/api/read', rateLimit({ max: 1000, windowMs: 60000 })) for cheap reads (1000/min). Response: 429 Too Many Requests with headers RateLimit-Limit: 100, RateLimit-Remaining: 0, Retry-After: 57. Limitation: In-memory storage - limits reset on restart, not shared across multiple server instances. Use case: Single-server apps, development/staging, quick prototyping. For production multi-instance deployments, use Redis-based distributed rate limiting.

Use rate-limit-redis store for shared rate limiting across multiple server instances. Setup: npm install rate-limit-redis redis. Implementation: const RedisStore = require('rate-limit-redis'); const redis = require('redis').createClient({ host: 'redis.prod.com', port: 6379 }); const limiter = rateLimit({ store: new RedisStore({ client: redis, prefix: 'rl:' }), windowMs: 60000, max: 100 }); app.use(limiter). Benefits: Shared state across all instances (horizontally scalable, consistent limits regardless of which server handles request), persistent across restarts (Redis retains counts), high performance (Redis INCR <1ms). Architecture: All servers connect to shared Redis cluster, each request increments counter for client key (IP or user ID), Redis TTL auto-expires old windows. Use case: Production APIs with multiple instances (Kubernetes, load balancers), 10K-1M+ req/sec throughput. Performance: 1-2ms overhead per request (Redis network RTT + INCR operation). Connection pooling essential for high throughput. Alternative: Use Redis Cluster for horizontal scaling to millions of clients.

Robust error handling and logging prevent crashes and enable debugging. Error handling (Node.js official Process documentation): (1) Async errors: always use try-catch with async/await or .catch() with promises. Critical: unhandled promise rejections crash process in Node.js 15+ (default behavior changed from deprecation warning to termination). When --unhandled-rejections flag set to strict or throw (default) and rejection not handled, triggers crash. (2) Synchronous errors: try-catch around sync code. (3) Event emitter errors: emitter.on('error', handler) for streams, servers (prevents uncaught exceptions from event-based I/O). (4) Global handlers (last resort only): process.on('uncaughtException', err => { log.error(err); process.exit(1); }); and process.on('unhandledRejection', err => { log.error(err); process.exit(1); });. Official warning: 'uncaughtException' is crude mechanism for exception handling, intended only as last resort. Should NOT be used as equivalent to On Error Resume Next. Unhandled exceptions inherently mean application in undefined state - attempting to resume without proper recovery causes additional unforeseen issues. Always log and exit (process may be in inconsistent state). 'unhandledRejection' event useful for detecting/tracking promises rejected without handlers, but modern Node.js crashes by default. Express error handling: middleware with 4 params (signature distinguishes from regular middleware): app.use((err, req, res, next) => { log.error(err); res.status(500).json({ error: 'Internal server error' }); });. Never send stack traces to clients in production (security risk, information disclosure). Logging: (1) Structured logging: use JSON format for parsing (enables log aggregation, querying): log.info({ user_id: 123, action: 'login', ip: '1.2.3.4' });. (2) Log levels: error (bugs requiring immediate attention), warn (potential issues, degraded functionality), info (significant events, startup/shutdown), debug (detailed for development only). (3) Libraries: pino (fastest, 5-10x faster than winston, asynchronous by default), winston (feature-rich, transports), bunyan (structured, deprecated but still used). (4) Contextual logging: correlation IDs across requests for distributed tracing: const logger = log.child({ req_id: uuid() }); creates child logger with request-specific context. AsyncLocalStorage (Node.js async_hooks module, official API) recommended for automatic context propagation across async boundaries. (5) Sensitive data: redact passwords, tokens, PII: log.info({ email, password: '[REDACTED]' });. GDPR/compliance requirement for production systems. Centralized logging: ship logs to ELK Stack (Elasticsearch, Logstash, Kibana), Datadog, CloudWatch. Use log aggregation agents (Fluentd, Logstash) or direct HTTP streaming. Best practices: (1) Log errors with context (user, request, state, stack trace for debugging), (2) Don't log in synchronous hot paths (blocks event loop), use async logging (pino async mode), (3) Rotate logs (logrotate, PM2 handles this automatically), (4) Set log levels via environment (DEBUG in dev, INFO in prod, reduce noise), (5) Monitor error rates (alert on spikes indicating incidents). Performance: pino with pino-pretty in production achieves <1ms per log statement (asynchronous write, worker thread processing). APM: integrate with application performance monitoring (New Relic, Datadog APM) for automatic error tracking, distributed tracing, performance profiling. Valid for Node.js 20+ LTS versions (Node.js 18 EOL 2025).

Health checks determine if application is running correctly, critical for Kubernetes self-healing and load balancing. Types (Kubernetes official documentation): (1) Liveness probe: kubelet uses liveness probes to know when to restart container. Checks if app is alive (responds to requests). Kubernetes kills pod if liveness fails. Use for detecting deadlocks, infinite loops, process hanging. (2) Readiness probe: determines if container ready to receive traffic. Kubernetes removes from Service load balancers if readiness fails (temporarily, not restarted). Use during startup or temporary unavailability (DB connection lost). (3) Startup probe (introduced for long startup times): while startup probe running, liveness and readiness probes disabled. Once startup succeeds, other probes become active. Addresses variable/long startup times without making liveness probe overly lenient. Implementation (Node.js Reference Architecture - Red Hat/IBM official guidance): HTTP probe type (httpGet) recommended, demonstrates HTTP server up and responding to requests. Endpoint naming: 'z pages' pattern (/livez, /readyz) used by internal Kubernetes services. Response must be status 200/OK (body content not required). app.get('/livez', (req, res) => { res.status(200).send('OK'); }); for liveness (lightweight, always passes unless process hung). Warning: For liveness probes particularly, additional internal state checks often do more harm than good (end result is container restart, which may not fix actual problem - creates restart loops). app.get('/readyz', async (req, res) => { try { await db.query('SELECT 1'); await redis.ping(); res.status(200).send('OK'); } catch (err) { res.status(503).send('Not ready'); } }); for readiness (checks dependencies - safe to check because failure only removes from load balancer, doesn't restart). Kubernetes configuration: livenessProbe: { httpGet: { path: /livez, port: 3000 }, initialDelaySeconds: 30, periodSeconds: 10 }; readinessProbe: { httpGet: { path: /readyz, port: 3000 }, initialDelaySeconds: 5, periodSeconds: 5 }. Best practices (2025 production): (1) Liveness simple and fast (<100ms), no dependency checks (avoid restart loops when DB temporarily unavailable), (2) Readiness checks all dependencies (DB, Redis, downstream APIs) - failure removes from traffic but preserves container for debugging, (3) Different paths for liveness/readiness (avoid cascading failures where DB issue causes liveness failures across cluster), (4) Include startup probe for slow-starting apps: startupProbe: { httpGet: { path: /readyz, port: 3000 }, initialDelaySeconds: 0, periodSeconds: 10, failureThreshold: 30 } gives 300s startup time (10s × 30 attempts) before liveness/readiness activate, (5) Timeout: keep probe timeout < periodSeconds (prevents overlapping probes). Libraries: lightship (abstracts readiness, liveness, startup checks and graceful shutdown for Kubernetes, official Node.js Reference Architecture recommendation), terminus (HTTP-specific automatic health checks). Advanced: include version, uptime, dependencies in response for debugging: { status: 'healthy', version: '1.0.0', uptime: process.uptime(), dependencies: { db: 'connected', redis: 'connected' } }. Common mistakes (avoid these): checking dependencies in liveness (DB down → liveness fails → pod restarts → still DB down → infinite restart loop, wastes resources and prevents debugging), probes too aggressive (periodSeconds too short causes false positives under load, kills healthy containers). Performance: health checks add <1ms overhead per probe interval (default 10s), negligible for production applications. Integration with graceful shutdown: readiness probe should fail immediately when shutdown signal (SIGTERM) received, allowing terminationGracePeriodSeconds (default 30s) for in-flight requests to complete before SIGKILL. Valid for Node.js 20+ LTS versions, Kubernetes 1.20+.