Best of Redis — 2025

1. 1
   Video

   Web Dev Simplified·1y

   Every Senior Developer Needs To Know This!

   Understanding and implementing background jobs or job queuing systems can significantly optimize server performance by offloading non-critical tasks from the main request flow. This concept allows tasks such as sending emails or saving information to a file-based system to be processed in the background, reducing the wait time for users. The post explains the architecture and implementation of a Redis-based job queue system, including priority handling, delayed jobs, and retry mechanisms.

   321
2. 2
   Article

   WebCraft·1y

   The Backend-for-Frontend (BFF) Pattern: Secure Auth Done Right

   The Backend-for-Frontend (BFF) pattern addresses security risks in web applications by storing JWTs server-side in Redis, eliminating exposure to XSS attacks and enhancing session management. This pattern is particularly suited to SPAs and mobile apps, offering improved scalability and user experience with silent token refreshes and instant logouts.

   258

   26
3. 3
   Article

   Community Picks·1y

   Redis Deep Dive for System Design Interviews

   Redis is a versatile and simple tool ideal for system design interviews due to its diverse capabilities and ease of understanding. It supports various data structures and communication patterns, making it suitable for high-speed caching, distributed locking, rate limiting, and proximity searches. Nevertheless, its in-memory nature means it lacks durability, requiring careful consideration in design decisions.

   146

   1
4. 4
   Article

   freeCodeCamp·45w

   How In-Memory Caching Works in Redis

   Redis is an in-memory data store that dramatically improves application performance by caching frequently accessed data in RAM. The guide covers Redis installation, core data types (strings, lists, hashes, sets, sorted sets), and Python integration. Key features include automatic key expiration, persistence options, and scalability through replication and clustering. Common use cases include API response caching, session management, and real-time data storage, making Redis essential for building fast, scalable web applications.

   126
5. 5
   Video

   YouTube·1y

   Stop Using Redis. Use Open Source Instead

   Redis, a widely-used in-memory database, recently changed its license to a more restrictive model, leading to the creation of an open-source alternative, Valkey. Valkey has garnered support from tech giants like AWS, Oracle, and Google, promising to maintain the free and open-source nature of the original Redis. The post explains how to switch from Redis to Valkey and compares their features, performance, and pricing.

   120

   8
6. 6
   Article

   Towards Dev·1y

   Introduction to Redis (Part 1)

   Redis is an open-source, in-memory data structure store used as a database, cache, and message broker. It supports various data structures such as strings, hashes, and lists. Redis is known for its high performance, flexibility, and durability. It offers features like in-memory storage with persistence options, multi-language support, and scalability through master-slave replication. Redis can act as both a secondary database for caching and a primary database for modern applications.

   119

   2
7. 7
   Video

   JavaScript Mastery·1y

   Build and Deploy a Fullstack App with Admin Dashboard | Next.js, PostgreSQL, Redis, Auth.js

   This post guides you through building and deploying a production-grade University Library management system using Next.js, PostgreSQL, Redis, and Auth.js. The project consists of two interconnected applications within a monorepo architecture, teaching industry-standard practices such as rate limiting, DDoS protection, caching, database queries, multimedia uploads, and automated workflows. Technologies like Tailwind CSS, Drizzle ORM, and ImageKit are used to create a polished and scalable application, catering to both user-facing and admin interfaces.

   101
8. 8
   Article

   LogRocket·1y

   Migrating to Valkey from Redis

   The post discusses migrating from Redis to Valkey, highlighting key differences such as licensing changes, performance improvements, and new features in Valkey 8.0. It covers the similarities in basic features, improvements in multi-threading, RDMA support, and cost advantages. Detailed migration steps are provided, along with the recommendation to test applications thoroughly before making the switch.

   99

   3
9. 9
   Article

   Foojay.io·1y

   Rate limiting with Redis: An essential guide

   Rate limiting is essential for managing traffic, preventing abuse, and ensuring fair access to resources. Redis is a preferred tool for implementing rate limiting due to its speed, reliability, and features. The choice of rate-limiting pattern, such as leaky bucket, token bucket, fixed window counter, sliding window log, or sliding window counter, depends on traffic patterns, precision needs, and resource constraints. Understanding these patterns and their trade-offs helps in building efficient, fair, and user-friendly systems.

   96

   1
10. 10
    Article

    Towards Dev·50w

    Blazing Fast Leaderboards using Redis

    A gaming platform faced severe performance issues with MySQL-based leaderboards, taking 30+ seconds to load for 1 million users. By migrating to Redis sorted sets (ZSETs), they reduced response times from 30 seconds to under 50 milliseconds. The implementation uses ZADD for storing user scores, ZCOUNT for ranking, and ZREVRANGE for pagination. While Redis dramatically improved performance, challenges remain with initial data loading for large datasets and concurrent write operations affecting query response times.

    94

    4
11. 11
    Article

    Anton Zhiyanov·45w

    Redka: Redis re-implemented with SQL

    Redka is a Redis-compatible server and Go module that reimplements Redis functionality using SQL databases (SQLite or PostgreSQL) as the backend. It supports five core Redis data types (strings, lists, sets, sorted sets, hashes) and offers both standalone server and embedded library usage. While not matching Redis performance, Redka handles tens of thousands of operations per second and provides benefits like SQL introspection, embedded caching for Go apps, and simplified testing environments.

    90

    4
12. 12
    Video

    Awesome·50w

    I built my own Redis in Go and it was too easy...

    A developer builds a custom in-memory database in Go as an alternative to Redis, implementing core features like TCP server with goroutines, command parsing for basic operations (set, get, delete), data persistence through file logging, pub/sub messaging using Go channels, and key expiration with background cleanup routines. The project demonstrates how Go's concurrency features make building database-like systems surprisingly straightforward.

    85

    3
13. 13
    Video

    ByteGrad·51w

    Build Next.js MCP - Your Website & MCP-Server In 1 App!

    A comprehensive tutorial demonstrating how to build a Next.js application that includes both a traditional website and an MCP (Model Context Protocol) server in a single app. The guide covers creating MCP tools that AI agents can invoke, implementing course recommendation functionality based on user experience level, deploying to Vercel with Redis integration, and testing the MCP server with GitHub Copilot. The tutorial also showcases CodeRabbit for automated code reviews and includes practical examples of AI agent interactions with custom MCP endpoints.

    82

    2
14. 14
    Article

    Ramp Engineering·1y

    Rate limiting with Redis

    Rate limiting is crucial in managing API usage and prevents overloading systems. Different rate limiting algorithms such as fixed-window, sliding window, leaky bucket, and GCRA offer various benefits and pitfalls. Ramp chose the GCRA algorithm for its efficiency and ease of implementation with Redis, tailoring it to handle multiple use cases. They continue to expand its application and monitor its performance.

    77
15. 15
    Article

    W endell Adriel·40w

    Laravel Queues Under the Hood

    Laravel's queue system transforms slow, unreliable tasks into fast, reliable workflows by moving work off the request cycle. The system follows a pipeline: dispatch jobs, serialize them into JSON payloads, store them via connectors (Redis, Database, SQS), pop them with workers, execute through middleware, and acknowledge or retry with backoff strategies. Redis uses lists and sorted sets for main queues, delayed jobs, and reserved jobs with visibility timeouts. Workers run as long-lived processes that handle job lifecycle, retries, and failures. Advanced features include job chains for sequential execution, batches for parallel processing with progress tracking, unique jobs, and overlapping prevention through cache locks.

    60
16. 16
    Article

    Bun·34w

    Bun v1.2.23

    Bun v1.2.23 introduces major improvements including pnpm-lock.yaml migration for seamless switching from pnpm, Redis Pub/Sub support, concurrent test execution with configurable parallelism, platform-specific dependency filtering, system CA certificates support, Windows code signing for compiled executables, JSX configuration improvements, SQL array helpers, randomized test ordering, and numerous Node.js compatibility fixes across http, dns, worker_threads, crypto, and other modules.

    50

    1
17. 17
    Article

    Phoronix·31w

    Valkey 9.0 Released With Ability To Achieve One Billion Requests / Second

    Valkey 9.0 has been released, marking a major milestone for the Linux Foundation-backed Redis fork. The new version introduces significant performance improvements, with the capability to handle up to one billion requests per second. This key-value database continues to evolve as a popular alternative in the data storage ecosystem.

    48

    1
18. 18
    Article

    Collections·1y

    Redis Returns to Open Source with Redis 8

    Redis is changing its licensing model to the AGPLv3 for the upcoming Redis 8 release, moving away from the SSPL license. This decision aims to align Redis more closely with open-source values and enhance its platform. Redis 8 introduces performance improvements, JSON and Time Series support, and features like vector sets for AI workloads. The switch is influenced by the impact of forks like Valkey and the need to compete in the open-source ecosystem. Redis continues to balance intellectual property protection with community-driven development.

    44

    11
19. 19
    Article

    Simple Thread·27w

    I Love You, Redis, But I’m Leaving You for SolidQueue

    Rails 8 introduces SolidQueue, SolidCache, and SolidCable as PostgreSQL-based replacements for Redis in the default stack. SolidQueue leverages PostgreSQL's FOR UPDATE SKIP LOCKED feature to handle job queuing without lock contention, eliminating the operational complexity of maintaining Redis infrastructure. The article provides a complete migration guide from Sidekiq to SolidQueue, including setup instructions, recurring job configuration, and Mission Control monitoring. While Redis remains necessary for high-throughput applications processing thousands of jobs per second, SolidQueue handles 200-300 jobs/second and is sufficient for most Rails applications, as demonstrated by 37signals processing 20 million jobs daily on PostgreSQL.

    40
20. 20
    Article

    Laravel News·38w

    Smart Cache Package for Laravel

    SmartCache is a Laravel package that automatically optimizes cache storage for large datasets through intelligent compression, chunking, and serialization. It provides driver-aware optimization strategies for Redis, file, and database caches, automatically detecting when optimization is needed and seamlessly reconstructing data on retrieval. The package includes features like gzip compression, performance monitoring, and extensible strategy patterns for custom optimizations.

    39

    1
21. 21
    Article

    Medium·50w

    Laravel Under Pressure: High-Traffic Optimization with Cache, Queue & Session Tactics

    Laravel applications can handle high traffic effectively when properly configured. Key optimizations include switching from file-based to Redis caching, using proper queue drivers instead of database queues, implementing route/config/view caching, managing sessions with Redis, and ensuring stateless architecture for horizontal scaling. The guide covers practical tactics like eager loading to prevent N+1 queries, batch job processing, rate limiting, and proper monitoring tools for production environments.

    39

    1
22. 22
    Video

    Community Picks·1y

    Redis Streams vs Pub/Sub: Performance

    This post compares the performance of Redis Streams and Redis Pub/Sub by running a benchmark on AWS. It highlights the primary differences, emphasizes the stateless nature of Pub/Sub, and contrasts it with the durability of Redis Streams. The benchmark tests measure latency, throughput, and CPU usage, revealing that Pub/Sub can handle over 1 million messages per second with lower resources, while Streams provide higher durability at the cost of increased CPU usage and reduced throughput.

    37
23. 23
    Article

    Bun·1y

    Bun v1.2.9

    Bun v1.2.9 release fixes 48 bugs and introduces Bun.redis, a built-in Redis client, support for ListObjectsV2 in Bun.S3Client, and additional libuv symbols. Enhancements include support for require.extensions and require.resolve paths, a WebKit upgrade, performance improvements in array handling, and several bug fixes across node:http, AsyncLocalStorage, node:crypto, diffieHellman, and more. New options like maxBuffer in Bun.spawn and improved socket field support were also added.

    31
24. 24
    Article

    Distributed Computing Musings·39w

    Thundering Herd Problem: Preventing the Stampede – Distributed Computing Musings

    The thundering herd problem occurs when multiple concurrent requests cause cache misses for the same key, leading all requests to hit the database simultaneously and defeating the purpose of caching. The post demonstrates this issue with a Spring Boot application using Redis cache and Postgres database, then presents two solutions: distributed locking using Redis and in-process synchronization with CompletableFuture and ConcurrentHashMap. The distributed lock approach works across multiple nodes but requires additional network calls, while in-process synchronization is faster but only coordinates requests within a single node.

    28

    1
25. 25
    Article

    Redis·48w

    Redis to Manage Storage Replication

    A freelancer shares how Redis transformed their file system replication architecture by replacing a complex SQL-based solution with Redis pub/sub messaging. The new approach eliminated scheduled batch jobs in favor of real-time replication, reduced operational overhead, and leveraged Redis data structures for analytics. The case study demonstrates Redis's versatility beyond caching, showing its effectiveness for messaging, data storage, and system coordination.

    25

    2