Choosing a Shard Distribution Strategy Without Guessing Slot Assignments

You're staring at 16384 hash slots and a blank cluster config. Do you spread them evenly, group them by node, or use hash tags? The answer isn't in the docs—it's in the traffic patterns you haven't mapped yet. Most teams guess slot ranges and pay for it later with hot shards, migration freezes, or split-brain during failover.

I've seen this play out at three different shops. One pre-assigned slots by customer tier and spent a weekend moving data when a tenant grew. Another used hash tags for everything and hit a 200% CPU spike on a single node. A third let the cluster auto-rebalance and couldn't explain why keys kept moving. This article is the field guide I wish I'd had: no hand-wavy theory, just concrete trade-offs you can evaluate before you type CLUSTER ADDSLOTS.

The Real Places Slot Decisions Bite You

Heat maps that lie, and the 3 AM call you didn't expect

Most teams discover slot distribution matters when something catches fire. Not during architecture reviews, not during capacity planning—but at 3 AM, when pager duty lights up because one node in the cluster is serving 80 % of requests while its neighbors sit bored. I have seen this exact scene at three different companies. The monitoring dashboard showed a beautiful, balanced heat map at the cluster level. What it didn't show: three hot keys landing on the same slot, and that slot living on a single primary node. The failover logic worked perfectly—the replica took over in under a second. Then it promptly melted too, because the load imbalance was structural, not transient. That's the first place slot decisions bite you: failover doesn't redistribute data, it just moves the bottleneck.

Daily ops: where slot imbalance hides in plain sight

The second place is boring, repetitive, and far more common. Resizing the cluster.

You add a node. Redis Cluster reshards some slots to it. If you let the automatic resharding run wild, it moves slots greedily—chasing perfect evenness per node without considering the request patterns inside those slots. What usually breaks first is latency. Suddenly, one of your existing nodes has fewer slots but more cross-slot operations, because the slots it kept are the ones with expensive aggregation commands. Resharding completed in minutes. The latency regression took three days to diagnose, because nobody mapped commands to slot ranges. We fixed this by tagging related keys with hash tags and pinning them to the same slot—but only after a painful root-cause.

The catch: slot imbalance is not always visible in CPU or memory metrics. It hides in request queuing, in network round-trips, in the time a single-threaded node spends executing large pipeline batches while smaller pipelines wait. Wrong order: most teams monitor node health, not slot health. That hurts.

Slot reassignment during a live incident—don't

Here is the third operational trap. A node fails. The cluster's slot migration logic kicks in, moving affected slots to replicas. If your slot distribution was already lopsided—say one node held 12 % of all slots but processed 40 % of write traffic—the failover doubles down on that asymmetry. The backup node inherits the overload. I watched a team lose an entire afternoon manually migrating slots during a partial outage, trying to reshuffle load while clients kept timing out. The move itself generated replication traffic, which made the latency worse. They should have failed fast, shed traffic, and redistributed slots in a planned window. Instead, they chased balance during chaos. That's a pitfall baked into automatic slot management: it optimizes for availability, not for performance symmetry.

'Slot rebalancing during a live incident is like changing tires while the car is moving—you might succeed, but you will almost certainly damage the alignment.'

— paraphrased from a production postmortem I read on a community mailing list, circa 2022

The real cost here is not the lost hour. It's the eroded trust in the cluster's predictable behavior. Once a team learns that slot misalignment can silently degrade performance, they stop trusting the default configuration. They start over-engineering key placement, or worse, they avoid scaling the cluster at all. That's a capacity planning failure triggered entirely by a slot distribution decision made months earlier, when nobody thought to examine where the hash ring puts pressure.

What Most People Get Wrong About Hash Slots

The 16384-slot lie most teams never question

I watched an engineer spend three days writing a custom slot-to-node mapper because they believed Redis Cluster would reshard automatically if they stayed under the magic number. Wrong. The 16,384-slot limit is a fixed hash ring, not a capacity ceiling. Every slot holds a subset of keys, and Redis Cluster never rebalances those slots on its own — you trigger `reshard` or you push data onto orphaned nodes. The real gotcha: slot ownership is static until you move it. That means one node can hold 3,000 slots while its neighbour holds 400, and Redis won't blink. Hot spots bloom fast when you assume uniform distribution.

Most documentation glosses over the math: CRC16(key) modulo 16384. No virtual nodes. No weight knobs. If your key space clusters around certain hash values — say, user IDs that all start with the same prefix — you get slot collisions that look like an even split in a dashboard but hammer one primary node into a soft timeout. The fix is a hash tag, but teams often scatter tags wrong, or worse, use the same tag across 90% of their keys. I have seen a 12-node cluster where slot 6528 carried 40% of all writes because every session key had {session}. That's not a sharding strategy. That's a single point of failure painted with a broad brush.

Hash slots, consistent hashing, and range partitioning are not the same thing

People swap these terms like they're synonyms. They're not. Consistent hashing assigns keys to a ring with replication boundaries that shift gracefully when nodes join or leave. Range partitioning splits the key space into contiguous blocks — think DynamoDB sort keys or MySQL table shards. Redis slots are fixed, deterministic buckets between 0 and 16383. No sliding scale. No ring rebalancing without manual intervention. The trade-off hits hardest during scaling: adding a node in a consistent-hash system means some keys move; adding a node to a Redis Cluster means you must explicitly migrate slots, one chunk at a time, or the new node sits idle with zero slots and zero data.

The catch is subtle but painful. Consistent hashing spreads load probabilistically; Redis slots distribute load only if your keys hash evenly. A three-node cluster with 5,461 slots each still burns if one slot contains a single key that gets hammered at 100,000 QPS. I have debugged that exact scenario — a cache key leaderboard:global sat alone in slot 8942 while the node behind it melted. The rest of the cluster hummed along at 10% CPU. Nobody expected a single key to crater performance. Anecdote aside, the lesson is structural: slot distribution is about *ownership*, not *work*. Owning a slot doesn't guarantee even workload.

Flag this for redis: shortcuts cost a day.

Flag this for redis: shortcuts cost a day.

Most teams skip asking: 'What happens when one slot holds 1,000 keys and another holds 1,000,000?' Redis doesn't care. Your latency curve will.

— field note from a production postmortem, three hours in

How slot ownership fights replication

A primary node owns a set of slots; its replicas mirror those exact slots. That sounds simple until you realise replica promotion does not rebalance slot distribution. If a primary crashes and its replica takes over, the slot set stays identical. The cluster is still lopsided. Worse, if you bin two hot slots onto different primaries but those primaries share a replica set, the replica node double-pays — it replicates write load from both primaries while serving read offload. I have seen a 64GB replica throttle because it was absorbing replication traffic for two slot-heavy primaries while handling read queries for a third. The design docs called it a "high-availability topology." The on-call log called it a "scheduled outage waiting for the next latency spike."

Slot drift happens when you move slots reactively — chasing hot keys, patching uneven ownership, or scaling out in a panic. Each migration copies the slot's data in bulk, locks the slot briefly, then updates the cluster state. Do that five times and you own a fragmented slot map where keys that should sit together are scattered across three nodes. The fix is not more migrations. The fix is a deliberate slot-allocation plan before you seed the first key. Pick a pattern — node-count-split, modulo by slot range, or key prefix routing — then test it against your actual key distribution. Run a quick script: CLUSTER KEYSLOT your top 1,000 keys and check the spread. If any slot appears more than 2% of the time, rethink your hash tags or your key naming convention before you ship.

Three Shard Patterns That Hold Up Under Load

Hash tags for colocated keys

You’ve got a user session and their shopping cart — two keys that must land on the same node. Without that guarantee, a single read becomes a scatter-gather mess, and worse, you lose atomicity on multi-key operations. Hash tags solve this by wrapping a portion of the key in curly braces: '{user:42}:session' and '{user:42}:cart'. Redis hashes only the tag, ignoring the rest. Both keys hit the same slot, same node. I have seen teams cut their cross-slot errors to zero with this one trick — but there’s a catch.

The tag concentrates load. If your hottest user accounts all hash to the same slot, that one node melts while its peers sit idle. That hurts. Large-scale deployments sometimes work around this by appending a shard suffix inside the tag — '{user:42:shardA}' — but now you’re managing shard assignment by hand. You trade simplicity for control. The pattern works best when your access pattern is inherently local: per-tenant data, per-session state, or time-series events grouped by device ID. Wrong order? Using tags for keys that should be globally distributed — you amplify hot spots instead of avoiding them.

Most teams skip proper tag scoping. They throw braces around the whole key, negating any distribution advantage. Key lesson: tags are a scalpel, not a sledgehammer. Use them only when the co-location benefit outweighs the concentration risk.

Pre-split slot ranges by business dimension

Imagine you run a multi-tenant SaaS platform. Tenant A does 80% of the writes; Tenant B through Z trickle in. Default slot assignment would scatter Tenant A’s keys across all nodes — fine for balance, terrible for cache locality if you ever need to migrate that tenant off. Pre-splitting fixes this. You carve the 16,384 slots into contiguous ranges and assign each range to a logical partition: slots 0–4000 for high-volume tenants, 4001–8000 for mid-tier, the rest for long-tail data.

The assignment itself is just CLUSTER ADDSLOTS followed by a range. No guessing. The trick is sizing the ranges so no single partition saturates — you leave buffer slots. What usually breaks first is teams over-committing. They assign 6,000 slots to a “big” tenant, then that tenant grows faster than expected, and suddenly you’re shuffling slots under production load. The pattern holds when you have stable business boundaries — regulatory regions, pricing tiers, or organizational units. Change those boundaries, and your slot ranges become legacy debt.

That sounds fine until you have 200 tenants and only 16,384 slots. The math gets tight. Most deployments cap at around 1,000 nodes anyway, but slot scarcity becomes real. You waste slots on empty ranges. The trade-off: deterministic mapping vs. packing efficiency. For teams with fewer than 50 shards, pre-split ranges are gold. Beyond that, the management overhead eclipses the benefits.

Dynamic rebalancing with resharding tools

Let the cluster move slots for you. Redis’s built-in resharding — redis-cli --cluster reshard — migrates slots one node at a time, no manual slot math. You tell it how many slots to move and which target node, and it handles the key migration in the background. I have fixed a production hotspot by shifting 200 slots off a saturated node in under three minutes. The catch? Resharding is synchronous for the keys being moved — they lock briefly — and the migration can stall if your network is latent or your keys large.

Most teams treat resharding as a fire drill. That’s backward. The pattern shines when you build it into normal operations: add a node, reshard a few hundred slots onto it, repeat. Over a quarter, your cluster self-heals imbalance. But — and this is where teams get stuck — you can't reshard blindly. If your slot distribution is already lopsided because of hash tags or poor pre-splitting, moving slots just shifts the hot spot. You need slot-level monitoring (see: CLUSTER SLOTS output) to know which slots are actually hot.

The real pitfall is operational drift. Teams reshard once, it works, then nobody remembers the procedure. Six months later, a disk fills, and the reshard command errors because of stale node IDs. Dynamic rebalancing requires a runbook, periodic dry runs, and acceptance that some migrations take hours. It's not a set-and-forget pattern. It's a living practice.

‘Slot assignment is not a configuration. It's a topology contract — break it without testing, and the cluster will remind you.’

— senior SRE, fintech, after a 3-hour reshard incident

Field note: redis plans crack at handoff.

Field note: redis plans crack at handoff.

Anti-Patterns That Get Teams Stuck

Even Slot Counts Ignoring Key Popularity

The most seductive anti-pattern is the one that looks mathematically perfect: distribute 16,384 slots evenly across your nodes. Every shard gets 2,046 slots, the dashboard glows green, and your latency metrics hum. That sounds fine until you watch one node’s CPU spike to 90% while its twin sits at 40%. I have debugged this exact scenario three times this year — each team insisted the slot count was equal, but nobody had measured access frequency per slot. A single high-traffic key, even one, can saturate a shard if its sibling keys are cold storage. The catch? Redis doesn't tell you which slots are hot. You have to instrument reads per slot manually, or you fly blind until the PagerDuty alert wakes you at 3 AM.

Most teams skip this because they assume load balances across keys naturally. It doesn't. Real traffic patterns cluster around session tokens, leaderboard entries, or a small set of product IDs. An even split of slots guarantees nothing about an even split of work. One team I worked with had 70% of all operations hitting exactly three slots — the rest were nearly idle. Their even-count distribution was a textbook anti-pattern that took two weeks to unwind.

What hurts most is the false confidence. You think you have solved distribution because the math works on paper. Then the seam blows out under a flash crowd, and you're reassigning slots during an outage. Never trust slot count alone; trust slot pressure.

Manual Slot Reassignment Without Migration Planning

You see a hot shard. You grab a handful of its slots and move them to a quieter node. Done, right? Wrong order. The naive path goes like this: issue CLUSTER SETSLOT to migrate state, then CLUSTER SETSLOT NODE to reassign. That works — once. The second time you do it live, you forget that the migrating node still holds copies of migrated keys. Until you flush them, they keep serving stale reads. I have seen a team double-process 40,000 orders because stale slot data on the old owner answered a GET faster than the new owner. The migration looked clean on paper. The rework took a holiday weekend.

The deeper pitfall is ignoring migration ordering. If you reassign slot 1234 from node A to node B without first ensuring node B is importing and node A is migrating, the cluster can split-brain. Redis gives you error codes, but teams in a hurry ignore them. Then one node thinks it owns the slot, another node thinks it owns the slot, and your application starts getting MOVED redirections in a loop — clients spinning, latency doubling, frustration compounding. Honest — I have fixed that exact loop three times. Each fix required a full slot rebalancing plan, not a hot-patch.

Using Hash Tags for Everything

Hash tags look like a cheat code — wrap part of a key in {} and Redis forces all those keys into the same slot. Multi-key operations become atomic across those keys. Perfect for transactions. The trap? Teams tag everything. Every key gets {user:1234}:profile, {user:1234}:cart, {user:1234}:history. Now all data for user 1234 lives in exactly one slot. If user 1234 is a power user running 1,200 requests per second, that single slot — and the node hosting it — takes the full hit. The rest of the cluster yawns.

'Hash tags solved our transaction problem so well that we put them on every key. Then one power user melted a node, and we realized we had just recreated the single-server bottleneck we were trying to escape.'

— Lead platform engineer, mid-size e-commerce team, after a post-mortem

The editorial signal here is proportionality. Use tags only when you genuinely need atomic operations across keys — say, incrementing a counter and updating a status together. Don't spray them everywhere because the documentation mentions them first. Every tagged key couples its fate to a single slot. That coupling kills the very distribution you set up the cluster to achieve. I have seen teams undo a year of careful slot planning in one sprint by adding hash tags across their entire data model. The fix? Audit every {} in your key space. If the tag has no multi-key operation behind it, remove it. Not maybe. Do it.

Long-Term Costs: Slot Drift and Data Migration

How slot distribution drifts over time

You balanced everything perfectly on launch day. Six nodes, slots spread like a textbook diagram, traffic humming. Fast-forward six months and that clean picture is a mess. Real production reshuffles data daily—hot keys emerge, write-heavy patterns shift, and the even distribution you fought for becomes a historical artifact. I have watched teams discover this the hard way: their Redis CPU graphs show one node pegged at 85% while its neighbor loafs at 30%. That's not a cluster failure—it's slot drift, the slow gravitational pull of uneven access patterns. The original assignment stays static unless you intervene, but the workload underneath moves constantly. What looked like a win during the planning meeting turns into a latent tax on operations.

Cost of moving slots under production load

Migrating a slot sounds administrative—a few commands, some keys relocate, done. The reality bites harder. Every slot migration forces the source node to serialize keys, ship them over the wire, and wait for the target to acknowledge. During that window both nodes hold duplicate data, memory spools up, and CPU cycles burn on transfer overhead. Under light load this is barely noticeable. Under peak traffic it can amplify latency spikes by 40–60 milliseconds per batch. We fixed this once by scheduling migrations at 2 AM, only to watch a global e-commerce burst hit anyway—someone in Singapore was shopping. The catch is that Redis blocks certain operations during slot handoff: multi-key commands across migrating slots fail outright. Losing one order pipeline because a migration crossed the wrong boundary hurts more than any theoretical distribution gain.

'Slot migration is not free. Every key you move costs CPU on both sides, and your p99 latency pays the bill.'

— lead SRE, after a midnight migration incident

Most teams underestimate the cumulative cost. A single slot holding 200,000 keys might take 30–40 seconds to migrate, but when you have 150 slots to rebalance across six nodes, that stretches into hours. During that window your cluster is effectively degraded. Not dead—just slow enough to trigger client timeouts. The worst pattern I have seen is a team triggering rebalances reactively every Tuesday, never measuring the residual CPU debt. Their nodes ran hot not from application load, but from perpetual migration churn.

Monitoring gaps that hide imbalance

Standard dashboards show node-level CPU and memory. That's not enough. A node can look healthy at 60% CPU while one of its slots handles 90% of the read traffic—because the other slots on that node are nearly idle. The metric averages away the pain. What breaks first is the slow query log: keys in the hot slot take 15ms while cold keys return in 1ms. But who watches per-slot latency? Almost nobody. The monitoring gap is real—most tools expose aggregate node stats, not slot-level request counts. You can close this with a custom script that polls cluster slots every minute and bins request rates, but that adds its own overhead. The honest trade-off: either you invest in slot-aware monitoring upfront, or you rediscover the imbalance during the next incident post-mortem. I have seen both approaches fail—the former because nobody maintained the script, the latter because the incident was blamed on "random slowdown."

Flag this for redis: shortcuts cost a day.

Flag this for redis: shortcuts cost a day.

The practical fix is not to eliminate drift—impossible under shifting load—but to cap its cost. Run a weekly rebalance that moves at most 5% of your total slots per window. Measure the migration CPU overhead and set a hard stop if it exceeds 15% of any node's cycles. That keeps the cluster from bleeding performance into its own repair work. And stop relying on Kubernetes autoscaling to fix slot imbalance—it can't. Scaling pods doesn't redistribute hash slots; it only adds more connections to the same skewed nodes. Wrong order. That hurts.

When You Shouldn't Bother With Manual Distribution

When Your 'Cluster' Could Fit on a Post-It Note

I once watched a team spend three weeks designing a slot-ownership map for a dataset that clocked in at 450 MB. The entire working set fit in a single EC2 instance with room to spare. They were solving a distribution problem that didn’t exist yet—and the cluster overhead ate 60 % of their Redis throughput. That hurts. Here’s the hard truth: if your total dataset stays under 5 GB and your read-write volume never breaches 10,000 ops per second, you're paying complexity tax for zero gain. The latency from internal cluster bus chatter often exceeds any sharding benefit at that scale. Start with a single-node Sentinel deployment, measure actual contention, then ask yourself—did you actually hit a wall, or did you just want to use the word 'cluster' in your architecture diagram?

Application-Level Sharding: The Ugly, Overlooked Cousin

Most engineers recoil at application-level sharding because it sounds like manual work. Fair. But here’s the trade-off they miss: when you split keys across three separate, non-clustered Redis instances from your service layer, you gain full control over data placement without any of the slot-migration headaches. The catch? You lose automatic failover and resharding. For teams with modest throughput (

‘Every layer of abstraction you don’t need is a footgun you carry willingly.’

— Systems engineer, during a post-mortem for a cluster that never needed to cluster

Redis Cluster Itself: When It’s the Wrong Container Entirely

Not every caching or session-store problem is a Redis problem. If your data has strong relational constraints, if you need range scans across thousands of keys regularly, or if your access pattern is 90 % bulk reads of contiguous key ranges, Redis Cluster fights you at every turn. Hash slots scatter your logically related data across nodes, turning a simple batch read into a multi-node scatter-gather nightmare. Teams keep forcing this square peg through the round hole because 'Redis is fast'—but fast at the wrong job still leaves your users waiting. Consider a dedicated key-value store like DynamoDB or a scaled PostgreSQL with partitioning if your queries outgrow simple key lookups. One team I know spent six months migrating a session store into a 12-node cluster, only to discover that their real bottleneck was a single serialized JSON field that had bloated to 4 MB. Slot strategy didn’t matter. The data model was the enemy.

Next action: Run a load test on a single node with your full dataset and expected peak throughput. If it holds—you’re done. No cluster. No slot strategy. Just ship it.

Open Questions Teams Still Debate

Should You Pin Slots to Physical Nodes?

I have watched teams spend two full sprints building a slot-to-node mapping system, only to discover that their hardware refresh cycle made the whole thing obsolete six months later. The temptation is real: pinning specific hash slots to specific machines sounds like control. But here's the trade-off that nobody mentions in the planning room. When you pin slots, you lose the ability to failover cleanly—if node-7 dies, those slots stay dead until you manually reassign them. The alternative, letting the cluster redistribute slots on membership changes, means you give up deterministic routing. That hurts if your application logic assumes slot X always lives on host Y. My fix for this: use a proxy layer that maps logical shards to physical hosts, and update the proxy on node changes. You get deterministic semantics without pinning slots in Redis itself. The catch is latency—every hop adds a few microseconds. Most teams I have seen eventually accept that small cost rather than fight with slot pinning during a Saturday outage.

How to Handle Slot Exhaustion in Very Large Clusters

Redis gives you 16,384 hash slots. That sounds like a lot until you run a 200-node cluster and discover you can't distribute slots evenly—each node gets roughly 82 slots, but some nodes inevitably host hot keys that consume 80% of their CPU. Slot exhaustion is not a numeric problem; it's a thermal problem.

You don't run out of slots. You run out of room on the nodes that hold the slots your busiest keys hash to.

— field note from a production postmortem

One workaround: split your hot keys into multiple logical keys with a suffix pattern (user:12345:0, user:12345:1) so they spread across different slots. That feels hacky, but it works. The cleaner path is using a consistent-hashing ring above Redis, then mapping ring partitions to slot ranges. We did exactly this for a critical path system last year—pushed a small C library that sits between the client and Redis, rehashes keys onto a virtual ring with 10,000 vnodes, then translates ring positions to slot ranges. It adds complexity, yes. But it eliminated the hot-node thrashing we had run into twice before. The real question your team should face: do you need more slots, or do you need better key distribution?

Alternatives to Hash Slot Routing: Proxies and Client-Side Hashing

The default Redis Cluster protocol forces your client to know the slot-to-node mapping. That means every language driver implements the same slot-shuffling logic, and if one driver has a bug—well, you migrate data the hard way. Proxies like Envoy's Redis filter or a dedicated Twemproxy layer can abstract slot management away from your application. I saw a team recently switch from native cluster mode to a proxy topology simply because their Python client's slot-redirect handling was silently dropping writes. The proxy cost them 2ms of P99 latency but ended write loss overnight. The alternative—client-side hashing without slots at all—is simpler but brutally unforgiving. If your client hashes keys into buckets and that hashing logic changes during a deployment, every key lands in a different bucket and the cluster is effectively empty. That happened to a payments system I audited. They rolled back within nine minutes, but nine minutes of misrouted transactions took three weeks to reconcile. So here is the blunt choice: use the built-in slot table if you control all your clients and can test every driver upgrade. Use a proxy if you have polyglot teams or can't tolerate client bugs. Use client-side hashing only if you never, ever change the hash function. That last condition is harder than it sounds.

Summary: A Decision Matrix and Two Experiments

Decision matrix for picking a strategy

You have three viable paths, not one. I have seen teams burn a sprint agonizing over which to pick — the answer depends on three variables: slot count, write skew, and acceptable migration pain. A team running 256 slots with a single hot key? Hash tags fix it in ten minutes. A 16,384-slot cluster with five services all hammering different keysets? Manual distribution buys you control but costs you flexibility. Here is the matrix I use. If your cluster has fewer than 500 slots — use consistent‑hash‑aware clients and let Redis handle placement. If your write traffic is balanced within 20% across nodes — use the same default strategy. If you have a known hot key or three — apply hash tags, but only on that handful of keys. The moment you see uneven slot utilization above 40%, you need the third path: manual slot assignment with a planned rebalance window. That sounds fine until your ops team resists — manual means you own the migration scripts, the rollback plan, the late‑night pager. I walked into a post‑mortem once where manual distribution had saved them from a daily hotspot — but cost them two full weekends every quarter when they added capacity. The trade-off is real.

Experiment 1: simulate hot shard with hash tags

Stop guessing. Spin up a three‑node test cluster. Load it with 10,000 keys, evenly distributed. Now add one key that gets 60% of your reads — that's the hot shard you have been dodging. Apply a hash tag — {hot} — to that key and its ten closest neighbors. Measure latency before and after. What usually breaks first is not the tag itself but the cascading effect: the node holding {hot} now saturates its CPU, while the other two sit idle. The fix? Only tag the truly hot key, not the neighbors. Most teams skip this step: they tag everything, then wonder why rebalancing took hours. I saw a team cut their p99 from 200ms to 40ms by isolating a single key — the rest stayed untagged. Run this for fifteen minutes. If your p50 moves less than 5%, your hotspot was not the problem — look elsewhere.

Experiment 2: simulate rebalancing with slot migration

Here is where the rubber meets the roadmap. Take that same test cluster — three nodes, 500 slots each. Now add a fourth node. Do not let Redis auto‑migrate. Instead, manually move 100 slots from the hottest node to the new one using CLUSTER SETSLOT … MIGRATING and IMPORTING. Watch the slot drift in real time — that's your future. A single slot migration on a cluster under mild load takes about 200 milliseconds. A full rebalance of 4,000 slots? Twenty minutes of volatile routing — every client reconnect, every stale redirect, every missed read. The catch is most teams test this on an idle cluster and call it done. That hurts — under load, migration time triples and error rates spike. I watched a team lose 12% of their reads during a slot move because they skipped this experiment. Do it under 80% CPU load. If the p99 degrades more than 30%, your manual strategy needs a smaller batch size or a rolling migration window — not a different topology.

The fastest migration is the one you never have to do. But the second fastest is the one you rehearsed under real load.

— field note from a production post‑mortem, after a slot move took down search for eleven minutes