Valkey and Redis Sorted Sets: Leaderboards and Beyond

 

This blog post covers the details about sorted set use cases as discussed in this video. Sorted sets are one of the most powerful data structures in Valkey and Redis. While most developers immediately think about “gaming leaderboards” when they hear about sorted sets, this versatile data type can solve many problems, from task scheduling to autocomplete to rate limiting.

What is a sorted set?

A sorted set is a key-value data structure where each member has two components:

• A score (float64) – used for ordering
• A value (string) – the actual data

Here’s a simple example:

Properties

O(log N) performance: insertion and retrieval time don’t increase much as the set grows. This logarithmic complexity means sorted sets remain fast even with thousands of elements.

Always sorted: unlike relational databases, where you’d need an expensive ORDER BY operation to rank rows, sorted sets store elements in sorted order by score. This means retrieving the top 10 items is instant, as there isn’t any sorting done.

Unique members: each member can appear only once in a set. Exactly what you want in a leaderboard where the members are player names.

The classic leaderboards use case

Let’s start with the example that sorted sets are known for. Here’s how you’d implement a real-time gaming leaderboard:

Why are sorted sets so good for leaderboards?

Compare this to a relational database approach. In a traditional database, you’d have a table with rows for each player and their scores. To get the top 10, you’d need to:

1. Scan through all rows
2. Sort them (expensive!)
3. Return the top 10

With sorted sets, the data is already sorted. You simply fetch the range you need, whether it’s the top 10, bottom 10, or ranks 50-60. No scanning, no sorting overhead.

The scores update atomically thanks to Valkey’s single main execution loop for writes, and you can retrieve any range without scanning the whole set. Plus, ZREVRANK gives you a player’s ranking instantly, again without any sorting operation.

Beyond leaderboards

Now for the interesting part. The sorted set’s combination of a score and value opens up possibilities far beyond gaming. Let’s explore some of these creative applications.

1. Time-based task queue

The LIST datatype in Valkey is great for queuing, but what if you need to schedule jobs for future execution? Use Unix timestamps as scores with the sorted set:

Use cases: Delayed job execution, scheduled reminders, deferred email sending, and appointment notifications.

The beauty here is that ZRANGEBYSCORE efficiently retrieves only the tasks due for execution. No need to scan through thousands of future tasks—the sorted structure lets you grab exactly what you need.

2. Rate limiting with sliding window

Counters can be used for rate limiting, increasing the count when a request is made (if under the limit) and decreasing when completed. A more sophisticated rate limiting would use the sorted set with the timestamps as scores:

Use cases: API rate limiting, DDoS protection, request throttling, login attempt limiting.

This sliding window approach is more sophisticated than simple counters because it tracks exactly when each request occurred. The ZREMRANGEBYSCORE command efficiently removes old entries, and ZCARD gives you the count instantly.

3. Autocomplete with prefix search

Here’s one you may not know about; build your own autocomplete using lexicographical ordering:

Use cases: Search suggestions, command completion, tag lookups, dictionary searches.

When all scores are zero, sorted sets fall back to lexicographical (alphabetical) ordering. The ZRANGEBYLEX command then lets you efficiently find all entries matching a prefix. It’s a simple but effective autocomplete solution.

4. Trending topics with time decay

Implement social media-style trending algorithms:

Use cases: Social media trends, hot topics detection, viral content tracking, and news feed ranking.

The score here represents how “hot” a topic is based on both popularity and recency. You’ll need to periodically recalculate scores as content ages, but retrieving the current top trending items is always instant.

5. Range queries for product filtering

Implement multi-attribute filtering similar to SQL WHERE clauses:

Use cases: E-commerce product filtering, user search with multiple criteria, and data segmentation.

This pattern lets you create separate sorted sets for each filterable attribute (price, rating, etc.), then combine them using set operations. ZINTERSTORE finds the intersection, products that match ALL criteria. You could also use ZUNIONSTORE for OR logic.

Performance

Understanding the time complexity helps you use sorted sets effectively:

Note: ZRANGE and ZRANGEBYSCORE include M in their complexity. If you’re fetching 10 elements from a million-element set, you only pay for the 10 you retrieve, not the million you don’t need.

Best Practices

1. Memory optimization

Sorted sets use memory-optimized storage for small sets (fewer than 128 entries with values under 64 bytes each). The configuration parameters zset-max-ziplist-entries and zset-max-ziplist-value control when this optimization kicks in.

2. Use pipelining

When adding multiple elements, batch your ZADD operations using pipelining to reduce round trips:

3. Cleanup old data

Use ZREMRANGEBYSCORE or EXPIRE to prevent sorted sets from growing unbounded:

4. Combine multiple sets

Don’t feel limited to a single monolithic sorted set. Use ZUNIONSTORE and ZINTERSTORE to combine multiple sets for complex queries.

Recent performance improvements

The Valkey community has invested heavily in optimizing sorted sets. Some recent highlights:

Valkey 8.1

• 27% less memory usage compared to Valkey 8.0
• 28% less memory usage compared to Redis 8.2
• ZRANK operations 45% faster using SIMD instructions 

Future improvements being explored:

• Embedding elements directly in skiplist nodes (reduces pointer overhead) 
• Optimizing ZRANK to avoid path comparisons
• Replacing skiplist with B+ tree variant for certain workloads 

These improvements are automatic—just upgrade Valkey and you get faster, more memory-efficient sorted sets for free.

Takeaways

Sorted sets aren’t just for leaderboards. The combination of a score and value enables some other great use cases:

• Time-based task queues with ZRANGEBYSCORE
• Rate limiting with sliding windows
• Autocomplete with prefix search using lexicographical ordering
• Trending topics with time decay algorithms
• Range queries on any numeric attribute

It’s a core data type included in both Valkey and Redis with a straightforward API that’s easy to learn and powerful to use. Performance is excellent and continues to improve. The Valkey community is actively optimizing sorted sets, delivering automatic performance gains with each release. Think creatively about the score. It doesn’t have to represent a traditional “score” in a leaderboard; it can be a timestamp, a priority level, a price, a distance, or any numeric value that defines your ordering.

Try it

Ready to experiment with sorted sets? Here’s how to get started:

• Try it out: github.com/valkey-io/valkey
• Join the community: valkey.io/community/
• Join the conversation: Valkey Slack

If you’ve built something interesting with sorted sets or have discovered another creative use case, I’d love to hear about it. The Valkey community is always excited to see what people build with these versatile data structures.

Valkey and Redis at Percona

At Percona, we’re happy to support Open Source Redis and Valkey with enterprise-grade, 24/7 support and consultative expertise. Percona specialises in unbiased architectural guidance and seamless migrations, ensuring users can scale their data environments without being tied to proprietary licenses. More info.

Look out for our upcoming video and blog post on rate limiting strategies.