Production Checklist

Always set redis.keyPrefix when sharing Redis with other applications or environments. This enables safe scoped cache clearing.

Set redis.poolSize to 4-8 for production. This increases throughput and provides partial failure tolerance.

Set cache.enableCompression: true with an appropriate compressionThreshold (default 1024 bytes) for entities larger than a few KB.

Ensure schema TTLs align with your data freshness requirements. Use cascadeTTL for parent-child relationships when parents are longer-lived.

Adjust resilience.circuitBreaker thresholds based on your Redis latency and failure tolerance.

Configure limits.maxHydrationDepth and limits.maxMemoryUsagePerOperation to prevent runaway memory usage.

Ensure your Redis version is >= 6 for full compatibility with all features.

Set maxmemory and maxmemory-policy (e.g., allkeys-lru) to prevent Redis from running out of memory.

Configure RDB/AOF persistence if you need to survive Redis restarts. Note that this adds latency.

Set up monitoring for memory usage, hit rate, latency, and connection count.

For ~100k entities at typical sizes, plan for ~1–2 GB RAM. For 1M entities, 8–16 GB. Compression cuts these roughly in half. INFO memory tells you the truth about your specific data. Use allkeys-lru if cache-only data being evicted is acceptable.

For sustained workloads above ~30k ops/sec on one Node process, sync JSON.parse on the event loop becomes the bottleneck — not Redis. Run multiple Node processes behind a load balancer (PM2 exec_mode: 'cluster', Kubernetes pods, etc.). Each process opens its own pool.

When a hot key expires, every concurrent reader misses the cache and hits your database. The cache doesn't deduplicate. Add request coalescing — e.g. p-memoize, dataloader, or a small in-process map of in-flight DB fetches keyed by entity id.

Catch and handle CircuitBreakerOpenError and RedisConnectionError by falling back to your primary data store.

Call getMetrics() periodically and export to your observability stack. Hit rate is the most important signal.

Call invalidateEntity() when data changes in your database to maintain cache consistency.

Call disconnect() on shutdown to close Redis connections gracefully.

Use indexedList instead of plain list for collections that may exceed ~200 items.

Set trackMembership: true only when you need cascade invalidation. It doubles the write traffic per insert.

Configure maxSize on indexed lists to cap memory usage for unbounded feeds.

Design your schema to avoid circular relations, or use excludeRelations to break cycles during reads.

Run load tests to validate your configuration can handle expected traffic patterns.

Test how your application behaves when Redis is down or the circuit breaker trips.

Track hitRate from getMetrics(). Hit rate is the only honest signal of whether the cache is paying off; investigate sub-50% rates.