Redis

Redis belongs in your stack the moment your application needs sub-millisecond data access, and that threshold arrives sooner than most teams expect. Common triggers include database query response times climbing above 100 ms under production load, session management becoming a bottleneck in horizontally scaled deployments, or the need for real-time features like leaderboards, live notifications, and rate limiting. Redis is also the right tool when you need a lightweight coordination layer between microservices — distributed locks, pub/sub messaging, or task queues that must process jobs within strict latency budgets. In our projects, adding Redis caching in front of PostgreSQL typically reduces p95 API response times by 60–80% and cuts database CPU utilization by 40–50%.

Redis stores all data in RAM and uses a single-threaded event loop to avoid the overhead of context switching and locking, which means every operation executes in microseconds without contention. A single Redis instance on modern hardware handles 100,000–300,000 operations per second depending on command complexity and payload size. For simple GET/SET operations with small values, throughput exceeds 250,000 ops/sec; more complex operations like sorted set range queries with scoring still achieve 80,000–150,000 ops/sec. When a single node is not enough, Redis Cluster distributes data across multiple shards, scaling linearly — a 6-node cluster delivers roughly 6x the throughput. We size and benchmark every Redis deployment against the application's projected peak load, adding a 2x headroom buffer to handle traffic spikes.

Memcached is a pure key-value cache with a simple string value model, while Redis offers rich data structures — hashes, sorted sets, lists, streams, HyperLogLog, bitmaps, and geospatial indexes — that enable use cases far beyond caching. Redis supports persistence (RDB snapshots and AOF logging), replication, Lua scripting, pub/sub messaging, and transactions, making it suitable as both a cache and a lightweight application database. Memcached's advantage is its multithreaded architecture, which can better utilize multi-core CPUs for pure cache workloads. In practice, we choose Memcached only when the workload is exclusively simple key-value caching with no need for eviction callbacks, data structures, or persistence. For 95% of projects, Redis covers the caching requirement plus additional use cases (sessions, queues, rate limiting), eliminating the need for a separate system.

Redis offers two persistence mechanisms that we configure based on data criticality. RDB snapshots create point-in-time backups at configurable intervals (e.g., every 60 seconds if at least 1,000 keys changed), providing compact backup files with fast restoration but accepting potential data loss of the last snapshot interval. AOF (Append Only File) logs every write operation and can be configured to fsync every second or on every write, reducing potential data loss to at most one second of operations. We typically enable both: AOF for durability and RDB for fast disaster recovery. For high-availability setups, Redis Sentinel monitors primary nodes and automatically promotes a replica within seconds if the primary fails, ensuring near-zero downtime. In Redis Cluster deployments, each shard has its own replicas, so no single node failure causes data unavailability.

Redis memory cost depends on dataset size: AWS ElastiCache pricing ranges from $13/month for a cache.t3.micro (0.5 GB) to $900+/month for a cache.r7g.4xlarge (105 GB), with cluster configurations multiplying the per-node cost. For self-managed deployments on Kubernetes, the primary cost is the RAM allocated to Redis pods. We optimize memory through several techniques: choosing the most compact data structure for each use case (hashes with ziplist encoding use 10x less memory than individual string keys), setting appropriate TTLs so stale data does not accumulate, enabling key-level compression for large values, and using Redis's maxmemory-policy to control eviction behavior. In one e-commerce project, we reduced Redis memory from 12 GB to 3.5 GB by switching from flat string keys to hash-encoded objects and tuning hash-max-ziplist thresholds, saving approximately $400/month in hosting costs.