100+ Free Redis Developer Practice Questions

Pass your Redis Certified Developer exam on the first try — instant access, no signup required.

✓ No registration✓ No credit card✓ No hidden fees✓ Start practicing immediately

100+ Questions

100% Free

1 / 100

Question 1

Score: 0/0

In the Redis Sorted Set, what does `ZPOPMIN key count` do?

Sets the minimum valid score threshold for the Sorted Set

Removes and returns the member(s) with the lowest score(s)

Removes members with scores below a given minimum

Removes the count of least recently accessed members

to track

2026 Statistics

Key Facts: Redis Developer Exam

~60

Exam Questions

Redis University

90 min

Time Limit

Redis University

70%

Passing Score

Redis University

$0–$250

Exam Fee

Redis University

2 years

Validity

Redis University

Practice Questions

OpenExamPrep

The Redis Certified Developer exam (~60 questions, 90 min, 70% passing) covers all Redis data types and commands, RDB/AOF persistence trade-offs, MULTI/EXEC transactions and Lua scripting, Pub/Sub and Streams with consumer groups, Redis Stack modules (RediSearch/RedisJSON/RedisTimeSeries), Redis Cluster hash slots, and client patterns (pipelining, eviction, caching). Verify current pricing and blueprint on university.redis.com.

Sample Redis Developer Practice Questions

Try these sample questions to test your Redis Developer exam readiness. Each question includes a detailed explanation. Start the interactive quiz above for the full 100+ question experience with AI tutoring.

1What is the time complexity of the Redis `GET` command for a String value?

A.O(n) — proportional to the length of the string

B.O(1) — constant time regardless of string length

C.O(log n) — proportional to the number of keys in the database

D.O(n) — proportional to the number of keys in the database

Explanation: Redis `GET` retrieves a string value by key in O(1) time. The in-memory hash table lookup is constant time. String length does not affect the key lookup itself (only data copying for very large strings).

2Which Redis command atomically sets a key to a value AND sets an expiration in milliseconds in a single operation?

A.SET key value EX 1000

B.SET key value PX 1000

C.SETEX key 1000 value

D.EXPIRE key 1000

Explanation: `SET key value PX 1000` sets the key to the value with a 1000-millisecond (1-second) TTL atomically. The `PX` option is for milliseconds; `EX` is for seconds. Using the `SET` command with options is the modern approach preferred over the older `PSETEX`.

3In Redis, what does the `LPUSH mylist a b c` command result in for the list `mylist`?

A.[a, b, c] (left to right insertion order)

B.[c, b, a] (last pushed element is the head/left-most)

C.[a, b, c] with 'a' at the tail (right-most)

D.[c, a, b] (random order)

Explanation: `LPUSH` prepends each element to the head (left end) of the list. When called with multiple elements, Redis pushes them left one-by-one: first `a`, then `b` (now head), then `c` (new head). Final list (head to tail): `[c, b, a]`.

4Which Redis data type stores unique, unordered members and supports set operations like UNION, INTERSECTION, and DIFFERENCE?

A.Sorted Set (ZSET)

B.Hash

C.Set

D.Stream

Explanation: Redis Sets (`SET` type) store unique, unordered strings. They support O(1) membership testing and set algebra commands: `SUNION`, `SINTER`, and `SDIFF` for union, intersection, and difference operations respectively.

5What does the Redis `ZADD leaderboard 100 'alice'` command do?

A.Adds 'alice' to a Set named leaderboard

B.Adds 'alice' with a score of 100 to the Sorted Set named leaderboard

C.Increments 'alice's score by 100 in the Sorted Set leaderboard

D.Sets 'alice' as the 100th rank in the Hash leaderboard

Explanation: `ZADD key score member` adds the member with the given score to a Sorted Set. If 'alice' already exists, her score is updated to 100. The Sorted Set maintains members in ascending score order for efficient range queries.

6In Redis persistence, what does RDB (Redis Database) persistence do?

A.Appends every write operation to a log file in real time

B.Takes point-in-time snapshots of the entire dataset and saves them to disk as a binary file

C.Replicates data to a secondary Redis instance synchronously

D.Stores write-ahead logs for transaction replay

Explanation: RDB persistence periodically forks the Redis process and saves a point-in-time snapshot of all data to a binary `.rdb` file. It is compact, fast to restore, and suitable for backups, but any writes between snapshots are lost on a crash.

7What is the key trade-off between using `appendfsync always` versus `appendfsync everysec` in Redis AOF persistence?

A.`always` has better throughput; `everysec` has better durability

B.`always` is more durable (no data loss on crash) but slower; `everysec` risks losing up to 1 second of writes but has better throughput

C.Both provide identical durability; `always` is just an alias for `everysec`

D.`everysec` provides zero data loss; `always` may lose up to 1 second of data

Explanation: `appendfsync always` calls `fsync()` after every write, guaranteeing no data loss on crash but significantly reducing write throughput. `appendfsync everysec` fsyncs once per second — if Redis crashes, up to 1 second of recent writes may be lost, but throughput is much higher.

8Which Redis command initiates a Lua-script-based atomic batch of operations that cannot be interrupted by other clients?

A.MULTI / EXEC

B.EVAL

C.WATCH / MULTI / EXEC

D.PIPELINE

Explanation: `EVAL` (or `EVALSHA`) executes a Lua script atomically inside Redis. The script runs to completion without other commands interleaving, making it ideal for complex conditional atomic operations that go beyond what `MULTI/EXEC` transactions can express.

9In a Redis `MULTI` / `EXEC` transaction, what happens if one of the queued commands has a runtime error (e.g., calling `INCR` on a string value)?

A.The entire transaction is rolled back

B.The failed command returns an error, but the remaining commands in the transaction still execute

C.The transaction is queued but never executed

D.Redis rejects the entire EXEC and returns an error for all commands

Explanation: Redis transactions do NOT support rollback. If a command within `MULTI/EXEC` fails at runtime (type mismatch, wrong number of args at runtime), that command returns an error, but the rest of the queued commands execute normally. Syntax errors before EXEC cause the whole transaction to be rejected.

10What is the purpose of the Redis `WATCH` command?

A.It subscribes a client to a Pub/Sub channel for monitoring

B.It marks one or more keys so that if any are modified before `EXEC`, the entire transaction is aborted

C.It sets up a keyspace notification for a specific key

D.It enables slow query logging for specific keys

Explanation: `WATCH` implements optimistic locking in Redis. Before a `MULTI/EXEC` transaction, you WATCH the keys your transaction depends on. If another client modifies any watched key before `EXEC`, the `EXEC` returns a nil reply (transaction aborted) and the client retries.

About the Redis Developer Exam

The Redis Certified Developer validates skills to build production-grade Redis applications: all major data types (Strings, Lists, Hashes, Sets, Sorted Sets, Streams, Bitmaps, HyperLogLog, Geo), persistence (RDB/AOF), transactions (MULTI/EXEC/WATCH/Lua), Pub/Sub, Streams with consumer groups, Redis Stack modules (RediSearch, RedisJSON, RedisTimeSeries, RedisBloom), replication, Sentinel, Cluster with hash slots, and client patterns (pipelining, connection pooling, eviction policies, caching patterns).

Assessment

Multiple-choice questions delivered online via Redis University

Time Limit

90 minutes

Passing Score

70%

Exam Fee

$0–$250 USD (Redis / Redis University)

Redis Developer Exam Content Outline

~35%

Data types and commands

Strings (SET/GET/INCR/INCRBY/NX/XX/PX/EX), Lists (LPUSH/RPUSH/LRANGE/LMOVE/LPOP/RPOP), Hashes (HSET/HGET/HGETALL/HKEYS/HLEN), Sets (SADD/SMEMBERS/SINTER/SUNION/SDIFF/SINTERSTORE), Sorted Sets (ZADD/ZSCORE/ZRANK/ZCARD/ZRANGEBYSCORE/ZINCRBY/GT/LT flags), Streams (XADD/XREAD), Bitmaps (SETBIT/GETBIT/BITCOUNT), HyperLogLog (PFADD/PFCOUNT), Geo (GEOADD/GEORADIUS).

~20%

Persistence and replication

RDB: point-in-time snapshots, save triggers, compactness. AOF: appendfsync always/everysec/no, auto-rewrite (rewrite-percentage, rewrite-min-size). Replication: async default, WAIT command. Redis Sentinel: monitoring, quorum-based failover. Redis Cluster: 16,384 hash slots, CRC16 key hashing, hash tags, node migration.

~15%

Transactions and scripting

MULTI/EXEC/DISCARD: atomic batching, no rollback on runtime errors, QUEUED state. WATCH: optimistic locking, nil reply on abort. EVAL/EVALSHA: Lua scripting, atomic server-side execution, KEYS[] and ARGV[] arrays.

~15%

Pub/Sub and Streams

Pub/Sub: PUBLISH/SUBSCRIBE/PSUBSCRIBE/UNSUBSCRIBE, fire-and-forget, no durability. Streams: XADD (auto-ID *), XREAD (simple consumer), XREADGROUP/XACK/XCLAIM/XAUTOCLAIM (consumer groups), XINFO STREAM, XLEN, XDEL.

~10%

Redis modules and Stack

RediSearch: FT.CREATE (ON HASH, SCHEMA TEXT/NUMERIC/GEO), FT.SEARCH, FT.AGGREGATE. RedisJSON: JSON.SET/JSON.GET with JSONPath ($). RedisTimeSeries: TS.ADD/TS.CREATE/TS.RANGE. RedisBloom: BF.ADD/BF.EXISTS (Bloom filter).

~5%

Client patterns and performance

Pipelining (network efficiency, not atomic), connection pooling, SCAN vs KEYS (production safety), cache-aside pattern, cache stampede (TTL jitter), eviction policies (noeviction/allkeys-lru/volatile-lru/allkeys-lfu/volatile-lfu), maxmemory, key namespacing conventions, OBJECT ENCODING/IDLETIME/FREQ, DEL vs UNLINK.

How to Pass the Redis Developer Exam

What You Need to Know

Passing score: 70%
Assessment: Multiple-choice questions delivered online via Redis University
Time limit: 90 minutes
Exam fee: $0–$250 USD

Keys to Passing

Complete 500+ practice questions
Score 80%+ consistently before scheduling
Focus on highest-weighted sections
Use our AI tutor for tough concepts

Redis Developer Study Tips from Top Performers

1Know every major data type's primary commands and their O() time complexity.

2Understand RDB vs AOF trade-offs: RDB is compact/fast-restore but loses data between snapshots; AOF is durable but larger.

3Know what MULTI/EXEC guarantees: atomicity (all-or-nothing execution), but NO rollback on runtime errors.

4Understand the 16,384 hash slots in Redis Cluster and how hash tags `{...}` force co-location.

5Practice consumer group semantics: XREADGROUP creates a pending entry; XACK removes it from the PEL.

6Know eviction policies by name: noeviction, allkeys-lru, volatile-lru, allkeys-lfu, volatile-lfu, allkeys-random.

7Use SCAN instead of KEYS in production — KEYS blocks Redis; SCAN iterates incrementally.

Frequently Asked Questions

How many questions are on the Redis Certified Developer exam?

The Redis Certified Developer exam is approximately 60 multiple-choice questions completed in 90 minutes via Redis University. Always verify the exact count and time limit on the official university.redis.com page before scheduling.

What score do I need to pass the Redis Certified Developer exam?

The passing score for the Redis Certified Developer is approximately 70%. Aim for 80%+ on practice sets before scheduling to give yourself a margin against unexpected question phrasing.

How much does the Redis Certified Developer exam cost?

Redis University exam pricing ranges from $0 to $250 USD depending on the current access model. Free study materials and courses are available at university.redis.com. Verify current pricing before scheduling.

What topics are covered on the Redis Certified Developer exam?

Topics include all Redis data types (Strings, Lists, Hashes, Sets, Sorted Sets, Streams, Bitmaps, HyperLogLog, Geo), persistence (RDB snapshots, AOF fsync modes), MULTI/EXEC transactions, WATCH optimistic locking, Lua scripting with EVAL, Pub/Sub, Streams with consumer groups, Redis Stack modules (RediSearch, RedisJSON, RedisTimeSeries), Redis Cluster hash slots, and client patterns.

What is the difference between pipelining and MULTI/EXEC in Redis?

Pipelining batches multiple commands into one network round trip for throughput efficiency — but commands are NOT guaranteed to be atomic and can be interleaved with other clients. MULTI/EXEC creates a transaction where queued commands execute atomically as a unit. They solve different problems: pipelining is for latency reduction, MULTI/EXEC is for atomicity.

Does the Redis Certified Developer certification expire?

The Redis Certified Developer certification is valid for 2 years. Recertification is required to maintain active status. Verify recertification requirements on university.redis.com.