Redis: product and architecture
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 a prominent 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.
Strengths & Trade-offs
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-serverstarts a server;SET key valuestores 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
