Redis is excellent at what it was built for. The issue isn't Redis. It's defaulting to any tool before defining constraints. Define requirements first. The right tool is usually obvious once you do. This applies to every infrastructure decision, not just caching.

4 questions worth answering before picking your cache: 1. How large will this data get? (memory ceiling) 2. Can I tolerate a cache miss? (fallback cost) 3. Do I need persistence across restarts? (durability) 4. Read-heavy or write-heavy? (throughput pattern)

When Redis is clearly the right call: → Sub-millisecond latency is a hard requirement → Dataset fits comfortably in memory → You need pub/sub or atomic operations → TTL-based expiry covers your eviction needs Outside these? Worth at least questioning.

The failure mode most teams hit: Redis without cluster mode = single point of failure. Most teams don't set this up until after the first outage. The eviction policy can also silently degrade cache hit rate for weeks before anyone connects the dots.

Redis is an in-memory store. That's its power and its ceiling. When cache grows beyond available RAM, you're choosing between: - Pay more for memory - Evict data you actually needed - Shard across nodes None of these are free decisions.

Most engineers reach for Redis the moment someone says "we need a cache." It works, until data grows, traffic patterns shift, or you need something Redis wasn't designed for. Here are the trade-offs worth knowing before you spin up the instance. 🧵👇

Interview answer in order: 1. Clarify requirements 2. Pick algorithm + justify it against requirements 3. Design single-server version 4. Scale to distributed address race conditions 5. Handle failure modes This structure works for almost all system design questions.

How to handle Redis going down: Option A: "Fail open" let all requests through (availability wins) Option B: "Fail closed" block all requests (safety wins) Option C: Local fallback counter with eventual sync (complexity wins)

The 4 algorithms, when to use each: Token Bucket → allows bursts, good for APIs Leaky Bucket → smooths traffic, good for queues Fixed Window Counter → simple, but has boundary spike problem Sliding Window Log → precise, but expensive on memory Know the trade-off of each

Start with requirements, not algorithms. Before drawing anything, ask: → Per user or per IP? → Hard limit or soft limit (allow bursts)? → Distributed system or single server? → What's the acceptable latency overhead? The algorithm choice falls out of these answers.

"Design a rate limiter." This question shows up in 80% of big tech system design rounds. Most candidates jump straight to token bucket. That's not wrong but it's also not an answer. Here's how to actually structure a response that signals senior-level thinking. 🧵 @Redisinc

Gamedays aren't about finding bugs. They're about building confidence that when traffic spikes, a dependency flakes, or a region goes down, your system degrades gracefully instead of collapses completely. That's what makes it fun & challenging to work for PrimeVideo 🚀🚀

What happens after a game day matters more than the game day itself. Every finding gets triaged: severity, owner, fix timeline. But the real value is the institutional knowledge. Your team now knows how the system behaves under pressure before a live event.

The thing that surprises engineers the first time they see a game day: Most failures aren't in the service under test. They show up in the retry logic upstream. In the timeout configs nobody touched in 2 years. In the shared cache that wasn't sized for this load profile.

Before every game day, we answer 3 questions: 1. What's the failure scenario we're simulating? 2. What does healthy steady state look like for each service? 3. What are our stop conditions, when do we abort? Without these, you're just causing chaos.

A gameday is a structured exercise where you deliberately stress a system and observe how it behaves. Not a drill. Not a test. You're generating real signal about real failure modes with engineering, on-calls, and sometimes leadership all watching live.

I run load tests across 200+ services at Prime Video. Here's what breaks first during a gameday. It's never the service you tested last month. It's always the dependency nobody thought to check. 🧵

I run chaos experiments across 200+ services at Prime Video. The goal is never to break things. It's to find out what breaks before a live event does it for you. Next: what a real game day looks like from the inside. Follow so you don't miss it.

Where most chaos programs die: - They only test in staging (prod has different load patterns) - No defined steady state, so results are uninterpretable - Teams treat it as a one-time exercise, not a practice - Findings go into a doc nobody reads Process beats tools. Always.

Most teams do reliability wrong. They wait for prod to fail, write a postmortem, add a retry, and move on. Chaos engineering flips this. You go looking for the failure before it finds your users. Proactive vs reactive. That's the entire mental model shift.👇