Redis

Redis is the in-memory data store used as a database, cache, message broker, and streaming engine by millions of developers, delivering sub-millisecond latency for real-time applications. In this Redis review, we examine how the platform evolved from a simple cache into a multi-model database powering everything from session storage to real-time AI applications.

Overview

Redis (redis.io) was created by Salvatore Sanfilippo in 2009 and is the most popular in-memory data store in the world. Redis Ltd (formerly Redis Labs) raised $347M in funding and provides Redis Cloud, the managed service. Redis is used by millions of developers and thousands of companies including Twitter, GitHub, Snapchat, Stack Overflow, and Craigslist.

Redis stores data structures in memory — strings, hashes, lists, sets, sorted sets, streams, bitmaps, and HyperLogLogs — with optional persistence to disk. Operations on these data structures are atomic and execute in microseconds, making Redis the standard choice for caching, session management, real-time leaderboards, rate limiting, and pub/sub messaging.

Redis Stack extends the core with modules: RedisJSON (document storage), RediSearch (full-text search and secondary indexing), RedisTimeSeries (time-series data), and RedisGraph (graph queries). Redis 7.0+ includes Redis Functions (server-side scripting) and improved cluster management.

Key Features and Architecture

In-Memory Data Structures

Redis provides native data structures — strings, hashes (field-value maps), lists (linked lists), sets (unique collections), sorted sets (scored collections), streams (append-only logs), and more. Each structure has specialized commands optimized for common operations: ZADD/ZRANGE for leaderboards, LPUSH/RPOP for queues, SADD/SINTER for set operations.

Sub-Millisecond Latency

All operations execute in memory with single-threaded command processing (avoiding lock contention). Typical latency is 0.1–0.5ms for simple operations. This performance makes Redis the standard for latency-sensitive use cases: caching, session storage, rate limiting, and real-time features.

Redis Streams

An append-only log data structure for event streaming, similar to Apache Kafka but embedded in Redis. Streams support consumer groups, acknowledgment, and pending entry lists. Suitable for lightweight event streaming where Kafka's complexity isn't justified.

Pub/Sub Messaging

Built-in publish/subscribe messaging for real-time communication between application components. Redis Pub/Sub delivers messages to all subscribers with minimal latency, powering real-time features like chat, notifications, and live updates.

Redis Stack (Multi-Model)

Extends Redis with document storage (RedisJSON), full-text search (RediSearch), time-series data (RedisTimeSeries), and graph queries (RedisGraph). This transforms Redis from a cache into a multi-model database capable of handling diverse data types in a single system.

Clustering and High Availability

Redis Cluster distributes data across multiple nodes with automatic sharding and failover. Redis Sentinel provides high availability for non-clustered deployments with automatic master election. Both ensure Redis remains available during node failures.

Ideal Use Cases

Application Caching

The most common use case: caching database query results, API responses, and computed values to reduce latency and database load. Redis's TTL (time-to-live) support enables automatic cache expiration. Most web frameworks have Redis caching libraries.

Session Storage

Storing user sessions in Redis provides fast access (sub-millisecond) and automatic expiration. Redis's atomic operations prevent race conditions in session updates. This is the standard approach for session management in distributed web applications.

Real-Time Leaderboards and Counting

Redis sorted sets provide O(log N) insertion and O(log N) range queries, making them ideal for leaderboards, ranking systems, and real-time counters. Gaming platforms, social media, and e-commerce use Redis for real-time ranking features.

Rate Limiting

Redis's atomic increment operations and TTL support make it the standard tool for API rate limiting. The INCR command with EXPIRE provides a simple, reliable rate limiter that handles millions of requests per second.

Real-Time AI (Vector Search)

Redis Stack's vector similarity search enables real-time AI applications — semantic search, recommendation engines, and RAG (Retrieval-Augmented Generation) with sub-millisecond vector queries on millions of embeddings.

Pricing and Licensing

Redis offers open-source and managed options:

For comparison: Amazon ElastiCache (managed Redis) starts at $0.017/hour (~$12/month), Memcached is free (open-source, simpler), DragonflyDB is an open-source Redis alternative claiming 25x throughput, and KeyDB is a multi-threaded Redis fork.

Pros and Cons

Pros

• Sub-millisecond latency — in-memory operations deliver consistent microsecond-level performance; the fastest data store available
• Rich data structures — native support for strings, hashes, lists, sets, sorted sets, streams, and more; purpose-built commands for each
• Universal adoption — used by millions of developers; libraries for every programming language; extensive documentation and community
• Multi-model with Redis Stack — JSON documents, full-text search, time-series, graph, and vector search in one system
• Simple to start — redis-server starts a server; SET key value stores data; minimal learning curve for basic usage
• Pub/Sub and Streams — built-in messaging and event streaming without external dependencies

Cons

• Memory cost — all data must fit in RAM; significantly more expensive per GB than disk-based databases; 1TB of Redis costs 10-50x more than 1TB of PostgreSQL
• License change controversy — 2024 switch from BSD to RSALv2/SSPL; Valkey fork by Linux Foundation; community trust damaged
• Data durability concerns — despite persistence options, Redis can lose recent writes during crashes; not suitable as sole data store for critical data
• Single-threaded core — command processing is single-threaded; CPU-bound workloads don't benefit from multi-core servers (though I/O threading was added in 6.0)
• Operational complexity at scale — Redis Cluster requires careful slot management, resharding, and monitoring; more complex than managed alternatives

Alternatives and How It Compares

Memcached

Memcached is the original in-memory cache — simpler than Redis with only string key-value storage. Memcached is easier to operate and uses memory more efficiently for simple caching. Redis is more versatile with data structures, persistence, and pub/sub. Memcached for pure caching; Redis for everything else.

Valkey (Linux Foundation)

Valkey is the BSD-licensed fork of Redis 7.2, maintained by the Linux Foundation with backing from AWS, Google, and Oracle. Valkey is functionally identical to Redis OSS with a permissive license. Choose Valkey for BSD licensing; Redis for Redis Stack modules and commercial support.

DragonflyDB

DragonflyDB is a modern in-memory data store claiming 25x Redis throughput through multi-threaded architecture. It's Redis-compatible (drop-in replacement) and open-source. DragonflyDB for high-throughput workloads; Redis for ecosystem maturity and Redis Stack features.

Amazon ElastiCache / MemoryDB

AWS managed Redis services. ElastiCache provides managed Redis with automatic failover. MemoryDB provides Redis-compatible storage with durability guarantees (data survives node failures). AWS-native teams often choose these over self-managed Redis.