What is Redis in one sentence?

Redis is an open-source, in-memory data store that keeps data in RAM for extremely fast access and is most often used as a cache, session store, message queue, or rate limiter alongside a primary database.

Is Redis a database or a cache?

It can be both. Redis is most commonly used as a cache in front of a slower database, but with persistence enabled it can serve as a primary store for certain workloads. Most teams use it as a fast supporting layer, not the system of record.

What data structures does Redis support?

Far more than key-value strings: lists, hashes, sets, sorted sets, bitmaps, hyperloglogs, streams, and geospatial indexes. These let Redis power leaderboards, queues, rate limiters, and real-time feeds, not just simple caching.

Does Redis lose data if it restarts?

By default data lives in memory and is lost on restart, but Redis offers two persistence options: RDB snapshots taken periodically, and AOF, an append-only log of every write. You choose the durability and performance trade-off that fits the use case.

What is the difference between Redis and Memcached?

Both are in-memory caches, but Memcached is a simpler string key-value store, while Redis adds rich data structures, persistence, replication, pub/sub, and scripting. Redis is more capable; Memcached is leaner for pure caching.

Glossary · Infrastructure

What is Redis?

Redis is an open-source, in-memory data store that keeps your data in RAM instead of on disk, so reads and writes complete in well under a millisecond. It is the workhorse that sits beside your main database to handle caching, user sessions, queues, rate limiting, and real-time features — the things a traditional database does too slowly.

The core idea: memory, not disk

Redis — the name comes from "Remote Dictionary Server" — was created by Salvatore Sanfilippo in 2009. Its defining choice is to keep the working dataset entirely in memory. RAM is orders of magnitude faster than disk, so operations that take a relational database several milliseconds take Redis microseconds. That speed is the whole point: Redis is not trying to be your system of record, it is trying to absorb the high-frequency, latency-sensitive work that would otherwise hammer a slower primary database.

More than key-value

People often picture Redis as a simple string-to-string dictionary, but its real power is its data structures. Lists make natural queues. Hashes store object-like records. Sets handle membership and deduplication. Sorted sets — values ranked by a score — are the canonical way to build a leaderboard or a time-ordered feed. There are also streams for append-only event logs, bitmaps and hyperloglogs for space-efficient counting, and geospatial indexes for "what is near me" queries. Because the server understands these structures natively, you push logic to the data instead of pulling data to the logic.

What people actually use it for

The most common job is caching: store the result of an expensive query or computation so the next request gets it instantly. Close behind is session storage — a shared place to keep login sessions so any server in a cluster can serve any user. Redis also makes a fine lightweight message broker via pub/sub or streams, a rate limiter using atomic counters with expiry, and a distributed lock. Many teams reach for it the moment a single database starts buckling under read load.

Persistence — it is not always volatile

A common misconception is that Redis loses everything on restart. By default in-memory data is indeed volatile, but Redis offers two durability mechanisms. RDB takes point-in-time snapshots of the dataset at intervals — compact and fast to restore, but you can lose the writes since the last snapshot. AOF (append-only file) logs every write operation, giving much stronger durability at some cost to performance and file size. You can run either, both, or neither, choosing the trade-off that matches how much data loss the use case can tolerate.

Scaling and the licensing twist

A single Redis node is limited by one machine's memory, so for scale Redis supports replication (read replicas), Redis Sentinel for automatic failover, and Redis Cluster, which shards keys across multiple nodes — the same partitioning idea that databases use for sharding. Worth knowing: in 2024 Redis changed its license away from the permissive BSD terms, prompting the Linux Foundation to launch Valkey, an open-source fork that stays compatible. For most teams the choice between Redis and Valkey is low-stakes today, but it is good to know both exist.

At QUANT LAB

Redis (or Valkey) is a frequent ingredient in the systems we build under SaaS platform development and operate under DevOps engineering. We use it to take read pressure off the primary database, to hold sessions so the app scales horizontally, and to enforce rate limits that protect both performance and security. We are also deliberate about what does and does not belong in it — treating a cache as a system of record, or leaving a Redis instance reachable without authentication, are mistakes we design against from the start.

Long-form deep-dives that use this term

All posts

Related terms

Database buckling under load?

We add caching, session stores, and rate limiting with Redis so your app stays fast as traffic grows. Book a 30-minute call.

SaaS platform development