Redis

Set a string value (overwrites, clears TTL unless KEEPTTL).

Read a string value (nil if missing).

Set a value with a TTL atomically.

Atomic +1 / -1 on an integer string.

Append to a string, returns new length.

Set/get multiple keys in one round trip.

Set one or more fields of a hash.

Read one field, or the whole hash as field/value pairs.

Atomically add to a numeric hash field.

Push onto the head (L) or tail (R) of a list.

Pop element(s) from the head/tail.

Blocking pop — wait for an element instead of polling.

Read a slice / trim a list to a slice (capped list).

Add member(s) to an unordered set of unique strings.

Set algebra: intersection, union, difference.

Add member(s) to a sorted set, ranked by score.

Read members by rank (position), low-to-high or high-to-low.

Read members whose score falls in a range.

Get the 0-based rank of a member (low/high first).

Append an entry to a stream; '*' auto-generates an ID.

Read new entries after an ID; optionally block for new ones.

Consumer groups: distribute entries across workers with acks.

Bitmap: set a single bit; count set bits.

HyperLogLog: approximate unique-count in ~12 KB.

Geospatial index: store points, query by radius/box.

Attach a TTL to an existing key (seconds / milliseconds).

How long until a key expires (seconds / ms).

Remove a key's TTL, making it permanent again.

Expiry is not instantaneous — two mechanisms reclaim memory.

Cap memory so Redis acts as a bounded cache.

What Redis discards when memory is full — pick by workload.

App checks cache; on miss, loads from DB and backfills.

When to update the cache on writes — sync vs async.

Keep the cache correct after the source of truth changes.

Many clients miss the same key at once and all hit the DB.

One key gets so much traffic it saturates a single shard.

Acquire a lock atomically: set only if absent, with a TTL.

Release a lock ONLY if you still own it — atomically.

Queue commands and run them atomically; WATCH aborts on conflict.

Lua runs atomic server-side logic; pipelining just batches RTTs.

Fire-and-forget broadcast to currently-connected subscribers.

Ephemeral broadcast vs durable, replayable log with groups.

Point-in-time binary dumps of the whole dataset.

Append-only log of every write; replayed on restart.

Async copies of a primary for read scaling and failover.

HA failover (Sentinel) vs horizontal sharding (Cluster).

Incrementally iterate keys without blocking the server.

Server stats: memory, clients, persistence, replication, stats.

Log of commands that exceeded a latency threshold.

Stream every command the server processes — debug only.

Bytes used by a key, and its internal encoding.

Get Pub/Sub events when keys change or expire.