Redis
Redis is an open-source, in-memory data structure store used as a database, cache, and message broker, supporting strings, hashes, lists, sets, and sorted sets with sub-millisecond read and write latency.
62 resources across 4 libraries
Glossary Terms(12)
Redis
Redis is an open-source, in-memory data structure store used as a database, cache, and message broker, supporting strings, hashes, lists, sets, and sorted sets…
Aerospike
Aerospike is a high-performance, distributed NoSQL database designed for sub-millisecond read/write latency and high throughput at large scale, commonly used i…
Beego
Beego is an open-source, full-stack web framework for the Go programming language that provides built-in ORM, caching, session management, and RESTful routing…
Amazon DynamoDB
Amazon DynamoDB is a fully managed, serverless NoSQL database from AWS that stores data as key-value pairs and documents, designed to deliver consistent, singl…
ArangoDB
ArangoDB is an open-source native multi-model database that supports graph, document, and key-value data models within a single storage engine, queried through…
Lua
Lua is a lightweight, fast, and embeddable scripting language designed to be integrated into larger applications written in C and other languages.
Upstash
Upstash is a serverless data platform offering pay-per-request Redis-compatible caching and messaging, along with serverless Kafka and other data services, des…
Memcached
Memcached is an open-source, high-performance, distributed in-memory key-value store used primarily to cache the results of database queries, API calls, and pa…
Apache Ignite
Apache Ignite is an open-source, distributed database and in-memory computing platform that combines a distributed key-value store, SQL engine, and compute gri…
Query Optimization
Query optimization is the process of improving how a database query is written and executed so it returns correct results using the least amount of time, memor…
Key-Value Store
A key-value store is the simplest form of NoSQL database, mapping unique keys directly to values with no required schema, optimized for extremely fast lookups,…
In-Memory Database
An in-memory database stores its primary dataset in RAM rather than on disk, trading persistence guarantees for dramatically lower latency and higher throughpu…
Study Notes(32)
Scaling with the Redis Adapter
Learn how the Redis adapter uses Redis's pub/sub to synchronize rooms and broadcasts across multiple Socket.IO server instances, enabling true horizontal scali…
WebSockets with Redis Pub/Sub
How Redis Pub/Sub lets a cluster of WebSocket servers broadcast messages to clients connected to any instance, and where it falls short.
Cache Invalidation Patterns
How to keep Redis-cached data correct as the underlying source changes, covering explicit invalidation, TTL trade-offs, and Pub/Sub-based invalidation across m…
Caching Strategies with Redis
A practical guide to the core caching patterns — cache-aside, write-through, and write-behind — used to speed up applications with Redis, plus how to pick sane…
Hashes in Redis
Learn how Redis Hashes model field-value objects efficiently, covering HSET/HGET, partial updates, memory-efficient small-hash encoding, and common object-mode…
Installing and Connecting to Redis
A practical guide to installing Redis locally or via Docker, understanding the core config file settings, and connecting to it from client libraries.
Key Expiration and TTL
Learn how Redis lets keys expire automatically using TTLs, and how expiration is implemented internally through lazy and active mechanisms.
Lists in Redis
Understand Redis Lists as ordered, linked-list-backed collections, covering push/pop operations, blocking reads for queues, and range-based trimming.
Pipelining in Redis
How Redis pipelining collapses many network round trips into one for bulk operations, how it differs from MULTI/EXEC transactions, and when it can't help.
Redis as a Session Store
How Redis centralizes web session state across multiple application servers, from modeling sessions as hashes with TTLs to session security and scaling with Se…
Redis Cluster Explained
How Redis Cluster shards data across multiple nodes using hash slots, and how it handles failover and multi-key operations.
Redis Data Persistence: RDB and AOF
How Redis persists in-memory data to disk using RDB snapshots and the AOF log, and how to choose (or combine) the right strategy for your workload.
Redis Eviction Policies
How Redis decides which keys to remove when memory is full, the available eviction policies, and how to choose the right one for your workload.
Redis Interview Questions
A study guide covering the Redis concepts most commonly probed in interviews: data structures, persistence, replication, and scaling tradeoffs.
Redis Key Naming Conventions
Understand why disciplined key naming matters in Redis and how to design namespaces that scale across teams and services.
Redis Memory Optimization
Techniques for minimizing Redis's RAM footprint, from choosing efficient encodings and bucketing strategies to compression, serialization, and maxmemory tuning.
Redis Persistence Tradeoffs
A practical comparison of RDB snapshots and AOF logging in Redis, and how to choose or combine them based on your durability and performance needs.
Redis Pub/Sub
Learn how Redis's publish/subscribe messaging model works, its fire-and-forget delivery guarantees, and when to reach for Streams instead.
Redis Quick Reference
A condensed cheat sheet of the most-used Redis commands across data types, key management, and server administration.
Redis Replication
How Redis copies data from a primary to one or more replicas for read scaling and failover readiness, and the consistency tradeoffs that come with it.
Redis Security Basics
Core practices for securing a Redis deployment: authentication, ACLs, TLS encryption, and network hardening.
Redis Sentinel for High Availability
How Redis Sentinel monitors a primary/replica deployment, detects failures, and orchestrates automatic failover without a cluster topology.
Redis Streams
How Redis Streams model an append-only log, and how XADD, consumer groups, and trimming work together for durable event processing.
Redis Transactions: MULTI/EXEC
Understand how Redis groups commands into atomic transactions using MULTI, EXEC, DISCARD, and optimistic locking with WATCH.
Showing 24 of 32.
Cheat Sheets(1)
Interview Questions(17)
What is a Key-Value Store and When Should You Use One?
A key-value store is the simplest NoSQL model: every item is an opaque value retrieved by a unique key, with no required schema and no built-in support for que…
What Data Structures Does Redis Support and When to Use Them?
Redis is an in-memory key-value store whose values can be rich data structures — strings, hashes, lists, sets, sorted sets, and streams — each offering differe…
Redis as a Cache vs a Primary Data Store: What Changes?
Using Redis as a cache means treating it as disposable, rebuildable-from-source data that the application never needs to survive as its only copy, whereas usin…
What is a Skip List?
A skip list is a probabilistic, layered linked-list structure that keeps elements sorted and adds multiple levels of 'express lane' pointers above the base lis…
What is Caching in System Design?
Caching is storing copies of frequently accessed data in a fast, temporary layer so future requests are served from it instead of the slower original source, r…
How to Design a Rate Limiter?
A rate limiter is designed by choosing an algorithm (token bucket, leaky bucket, fixed window, or sliding window log) that tracks request counts per client key…
How Would You Design a Distributed Lock?
A distributed lock is a coordination primitive that lets multiple independent processes across different machines agree that only one of them may hold a named…
How Would You Design a Real-Time Leaderboard?
A real-time leaderboard ranks a large, constantly updating set of scores and answers “what is this player’s rank” and “who are the top N” in near-constant time…
How to Design an API Rate Limiter
An API rate limiter design centers on a shared, low-latency counter store (typically Redis) that tracks per-client request counts using a sliding-window or tok…
How Would You Design a Distributed Counter (e.g. Like Counts)?
A distributed counter tracks a fast-changing count (like a like button) across many concurrent writers by sharding the counter into multiple sub-counters that…
How Do You Design a Social Media Timeline?
A social media timeline is built with a hybrid fan-out approach: posts from most users are pushed into each follower’s precomputed feed at write time (fan-out-…
How to Design a Chat Presence System
A presence system tracks whether each user is online, offline, or away by having clients maintain a persistent connection (WebSocket) with periodic heartbeats…
What Are Cache Eviction Policies?
A cache eviction policy is the rule a fixed-size cache uses to decide which entry to remove once it is full and a new item needs to be stored, and the choice o…
How Do WebSockets Scale in a Distributed System?
WebSockets scale in a distributed system by keeping the persistent connection itself pinned to one server while offloading cross-server message delivery to a s…
How Do You Implement Rate Limiting Across Multiple Servers?
Distributed rate limiting means enforcing a shared request budget for a client across many stateless application servers, which requires moving the counter or…
How Do You Manage User Sessions Across Multiple Servers?
Distributed session management means ensuring a logged-in user’s session data is available no matter which of many stateless application servers handles their…
Rate Limiting in Distributed Systems
Rate limiting caps how many requests a client, service, or API key can make within a time window, protecting backend systems from overload, abuse, and cascadin…