Skip to main content
All posts
Software Engineering20 min read

Cell-Based Architecture: Cap Your Blast Radius at 1/N

Cell-based architecture explained: partition keys, a thin cell router, an out-of-path control plane, deployment waves and the maths that caps blast radius.

Published Updated: 15 November 2026

On 18 November 2025, a database permissions change at Cloudflare doubled the size of a generated Bot Management feature file. The file broke a hard limit in the proxy and was, in Cloudflare's words, "propagated to all the machines that make up our network". Core traffic failed from 11:20 UTC; the main impact lasted until 14:30 and full recovery until 17:06. A month earlier, a latent race condition in DynamoDB's DNS automation had disrupted AWS us-east-1 for about 15 hours. Nine days after that, on 29 October, an inadvertent tenant configuration change in Azure Front Door caused a global disruption of more than eight hours.

None of these were attacks. They were ordinary changes with an unlimited blast radius. A year on, architecture boards ask us less "how do we get more nines?" and more "how do we make sure one bad change only hurts a slice of our customers?". Cell-based architecture is the most proven answer we know. This article is for the people deciding whether to build it: CTOs, platform leads, SRE managers and architects of multi-tenant systems.

TL;DR / Key takeaways

  • Blast radius becomes a design parameter. With N equal, independent cells, a failure in one cell affects 1/N of tenants. Ten cells cap it at 10 percent. You choose that number instead of discovering it during an outage.
  • The router is the part that can still take everything down. It is shared by all cells, so it must be the thinnest possible layer: no business logic, a cached map, staged changes.
  • The control plane stays out of the request path. Provisioning and migration can be down for hours while cells keep serving. That static stability is what you are buying.
  • Cells turn deployments into experiments. Releasing wave by wave, starting with one cell, is where most of the value lands, because so many outages start with a change.
  • It costs real money and real tooling. Microsoft says plainly that stamps substantially increase operating cost. Cells pay off for multi-tenant platforms where a total outage is unacceptable.
Cell-based architecture. A thin router sends each request to the cell that owns its partition key; the control plane stays out of the request path; a failure stays inside one cell. Numbers 1–6 match the sections below.
Cell-based architecture. A thin router sends each request to the cell that owns its partition key; the control plane stays out of the request path; a failure stays inside one cell. Numbers 1–6 match the sections below.

Download: Editable draw.io file · Open in diagrams.net · Chart data (CSV)

Why this matters now

Three things have changed since 2023. First, the pattern got documented. In September 2023 AWS published Reducing the Scope of Impact with Cell-Based Architecture as part of its Well-Architected Framework, extending the best practice "use bulkhead architectures to limit scope of impact". Microsoft's Azure Architecture Center describes the same idea as the Deployment Stamps pattern and lists "cell" as a synonym for a stamp.

Second, public examples arrived. In August 2023 Slack described turning each availability zone into a cell after a June 2021 "gray failure", when a flaky link between zones left components disagreeing about what was healthy. Its goal: drain a zone within five minutes, in steps as small as 1 percent. In December 2023 Roblox described cells of about 1,400 machines each, two years after a 73-hour outage, with over 70 percent of back-end traffic served from cells at peak.

Third, the outages of late 2025 and 2026 kept making the same point: the failures that hurt most were global. Cloudflare's February 2026 post-mortem shows the counter-example. A BYOIP configuration change withdrew 25 percent of customers' BYOIP prefixes, but "did not impact all BYOIP customers because the configuration change was applied iteratively". Among its follow-ups: "require controlled rollouts for any configuration change that is propagated to the network". That is cell thinking, written down as an action item. We cover the provider side in our analysis of control-plane failures in hyperscaler outages.

The architecture, piece by piece

The AWS guidance defines three components. A cell is "a complete workload, with everything needed to operate independently". The cell router is "the thinnest possible layer", responsible for routing requests to the right cell "and only that". The control plane handles administration: provisioning and de-provisioning cells and migrating customers between them. Our diagram adds the two things that decide whether the design works in practice: the partition key and the deployment waves. The numbers match the callouts.

① Partition key: choose the grain

Everything starts with the key that decides which cell owns a request. AWS's advice is to match the "grain" of the service: the natural way the workload splits with minimal cross-cell interaction. For most B2B SaaS that is the tenant ID. For IoT it might be the device fleet, for a payments platform the merchant.

Three questions decide whether a key is good:

  • Is it in nearly every request? If the router has to call a database to find the key, the router is no longer thin.
  • Does it keep most traffic inside one cell? Some operations, such as global search or cross-tenant reporting, will always cut across cells. They should be the minority, and AWS suggests sending cross-cell calls back through the router rather than letting cells talk to each other directly.
  • What happens to your biggest customer? A tenant ID is a poor key if one tenant can outgrow a cell. AWS recommends adding a second dimension to the key for that case, for example tenant plus workspace.

AWS lists full mapping, range mapping, modulo and consistent hashing "without specific recommendations". For B2B platforms we default to a full mapping table: it costs a lookup, but lets you move one tenant without moving anyone else.

② Cell router: the thinnest possible layer

The router is the one component every cell shares, and therefore the one that can still turn a cell failure into a total outage. AWS asks for a router that is simple, fast, light on business logic, isolates dispatching per cell and keeps serving the other cells when one is unreachable. In practice that means:

  • A cached, versioned copy of the tenant-to-cell map, with the last known version used if the source is unavailable.
  • No business rules: no feature flags, no tenant-specific policies.
  • Its own changes go out in waves, because a bad router release has a 100 percent blast radius.
  • Per-cell connection pools and timeouts, so a slow cell cannot exhaust capacity for the healthy ones.

On AWS the paper discusses Route 53, API Gateway, or compute that loads the map from S3. Microsoft's Azure example uses Front Door for global entry and API Management resolving the stamp from a tenant-to-stamp map in Cosmos DB. Both work. A router that has grown into an API gateway with forty policies does not, because every policy change becomes a global change.

③ The cell: a complete, independent stack

A cell contains everything a request needs: compute, queues, workers and, critically, its own data store. If cells share a database, you do not have cells, you have stateless replicas in front of a shared failure domain. That is the most common mistake we see in designs that call themselves cellular.

AWS sets out the sizing trade-offs clearly. Smaller cells shrink the scope of impact, are easier to test at full scale and less likely to hit cloud quotas. Larger cells are easier to operate, split fewer big customers and use capacity better. Cap the maximum cell size, keep sizes consistent and know each cell's limits in transactions per second, tenants and storage.

Cells do not automatically mean more infrastructure: in AWS's example, 30 hosts stay 30 hosts, grouped behind a router. The extra cost is fixed per-cell overhead (databases, load balancers, monitoring) and the tooling to run many copies. Microsoft is blunter: the pattern "substantially increases the cost of operating your solution". Budget for it honestly.

Zonal cells map one cell to one availability zone, as Slack did, and are easy to retrofit. Regional cells span zones for in-cell redundancy and put several cells in a region, giving smaller blast radii.

④ Control plane: out of the request path

The control plane provisions and retires cells, places new tenants, migrates tenants between cells, publishes the cell map and drives deployment waves. It must not be in the request path: if it is down, cells keep serving and the router uses its last map. AWS calls this static stability and notes that control planes are "statistically more likely to fail than data planes". It is the first thing we test in a cellular design review: switch off the control plane and check that traffic is unaffected.

Tenant migration is where most teams underestimate the work. Microsoft warns that moving tenants between stamps "can be difficult" and may need a backplane. A typical sequence:

Loading diagram...

The read-only window is the honest cost of a simple migration. Zero-downtime migration needs change-data capture and dual writes, a project in its own right. Decide early which one you are building.

⑤ Deployment waves: cell by cell

This is where we see the biggest return. AWS says the important point is "to deploy in waves, cell by cell or set of cells", rolling back on any sign of failure. A typical plan: wave 0 is one cell with a bake time, wave 1 a few cells, wave 2 a quarter of the fleet, wave 3 the rest. Each wave is gated on health metrics, not on a clock alone.

The rule that matters most is that configuration is a deployment. None of the three incidents in the opening was a code release: they were a generated file, a tenant configuration and an automated DNS plan. If feature flags, WAF rules, routing tables and generated config bypass the wave pipeline, your cells give you no protection against exactly that kind of trigger. Microsoft makes the same connection: stamps can implement deployment rings.

⑥ Containment: when a cell fails

When something goes wrong, the failure stays inside the cell because nothing else shares its state. Monitoring reports per cell, so a dead cell is not hidden in a small rise of the global error rate. And operators have a short list of actions: stop the wave, roll back the cell, drain it, or migrate tenants.

Draining needs headroom. If cells absorb a drained neighbour's traffic, as with Slack's zonal cells, each survivor needs spare capacity of 1/(N−1): 50 percent per zone with three zonal cells. If tenants are pinned to cells with their own data, you usually cannot drain and fall back to rollback and repair. Know which kind of cell you have before the incident.

What the numbers say

Blast radius 1/N and drain headroom 1/(N−1) against the number of cells
Blast radius 1/N and drain headroom 1/(N−1) against the number of cells

The formulas. With N equal cells and tenants spread evenly, the share of tenants affected by a single-cell failure is:

blast radius = 1 / N

If a drained cell's load must be absorbed by the others, each survivor needs extra capacity of:

drain headroom = 1 / (N − 1)

Three readings stand out. The curve is steep at the start: one to three cells cuts the blast radius from 100 to 33 percent, while 20 to 50 cells only moves it from 5 to 2 percent. Drain headroom follows the same curve: three zonal cells need 50 percent spare capacity, ten cells about 11 percent. And the chart assumes even placement and independent failure. One giant tenant, or a shared dependency beneath all cells, breaks both assumptions. That is what a design review should look for.

One poison-pill customer, share of other customers affected under no isolation, fixed cells and shuffle sharding
One poison-pill customer, share of other customers affected under no isolation, fixed cells and shuffle sharding

Shuffle sharding goes further: each customer gets its own random combination of k workers out of n. Colm MacCárthaigh's Builders' Library example uses eight workers. With four fixed shards of two, a poison-pill customer that crashes its workers hits 25 percent of customers. With shuffle shards of two there are 28 combinations, so only 1 in 28 customers, about 3.6 percent, share the exact pair:

fully affected = 1 / C(n, k) · at least one shared worker = 1 − C(n−k, k) / C(n, k)

The second formula is the honest footnote: 46 percent of customers share at least one worker with the poison-pill customer, and stay up only if clients retry on the other worker. At scale the effect is dramatic: by our arithmetic, 100 nodes with shards of five give 75.3 million combinations, and Route 53's shards of four out of 2,048 virtual name servers give the "staggering 730 billion" in the AWS article. Shuffle sharding suits stateless fleets and the inside of a cell. It does not replace cells for stateful data.

All values in both charts are our own calculations from the formulas above, not measurements. The CSV lists every point together with its formula.

In a recent engagement…

A European B2B software company asked us to review its platform after a run of serious incidents. Each started in one tenant, once a pathological import job, once a malformed integration payload, and each ended with every customer down, because all tenants shared one application tier and one database cluster. The team's first idea was a microservices rewrite. We argued against it: services split the system by function, so the poison-pill payload would still have reached every tenant, just through more hops.

Instead we designed cells around the tenant ID with a full mapping table, starting with two cells: a "canary" cell with internal and friendly tenants, and everything else. The router was a small reverse proxy reading a versioned map from blob storage. The first months were unglamorous: removing hidden cross-tenant queries, splitting a shared scheduler, and making the pipeline target cells rather than "production". The canary cell paid for itself before the main cell was ever split: faulty releases that would once have reached everyone stopped in wave 0.

What we would do differently: put configuration into the wave pipeline from day one. The team kept feature flags global "because they are not deployments". They are. Cells work with a modular monolith or with services; if you are still choosing, see the modular monolith before microservices.

Decision table: do you need cells?

SignalCells probably worth itCells probably not worth it yet
TenancyMulti-tenant platform, many customers on shared infrastructureSingle-tenant or a few internal users
Cost of a total outageContractual SLAs, regulatory reporting, revenue loss per minuteInconvenience; a manual workaround exists
Incident historySingle-tenant triggers became global outages (poison pills, noisy neighbours, bad config)Outages come mainly from infrastructure you cannot cell (one region, one provider)
Natural partition keyTenant, merchant, account or device fleet in nearly every requestHeavy cross-entity queries are the core of the product
Platform maturityFully automated IaC and pipelines; per-environment config already parameterisedManual deployments; snowflake environments
Team capacityA platform team that can own router, control plane and per-cell observabilityNo one to own the shared tooling

And the design checklist we use in reviews:

#CheckWhy it matters
1Each cell has its own data storeA shared database is a shared failure domain
2Router has no business logic and serves from a cached, versioned mapThe router is the only component shared by all cells
3Control plane off → traffic unaffected (tested)Static stability is the point
4Every change, including config and flags, goes out in cell wavesChanges are the usual trigger of global outages
5Maximum cell size defined and load-testedUnknown limits become scaling cliffs
6Dashboards and alerts per cell, not only globalA 2 percent global error rate can hide a dead cell
7Tenant migration procedure documented and rehearsedHot tenants and rebalancing will happen
8Shared dependencies (identity, DNS, secrets, CDN) listed with their own blast radiusCells do not protect you from what sits beneath all of them

Governance for European enterprises

Cells are an engineering pattern, not a compliance framework, but they map well onto two regimes that already apply to many of our clients.

DORA. Regulation (EU) 2022/2554 has applied to financial entities since 17 January 2025. Article 9(4)(b) asks for a sound network and infrastructure management structure, and the paragraph that follows requires network connection infrastructure designed so it can be "instantaneously severed or segmented in order to minimise and prevent contagion". Article 9(4)(e) requires ICT changes to be "recorded, tested, assessed, approved, implemented and verified in a controlled manner". A cellular design with wave-based releases answers both demonstrably: you can show the segmentation and each change moving through gated cells. Our DORA implementation guide covers the wider ICT risk framework.

NIS2. Article 21(2)(c) of Directive (EU) 2022/2555 lists business continuity, "such as backup management and disaster recovery, and crisis management", among the minimum measures. A rehearsed cell drain or tenant migration is good evidence that continuity is more than a document.

Data residency. Microsoft names data sovereignty as a reason to pin customers to specific regions; for DACH clients that often means EU-only cells. Cells do not replace multi-region disaster recovery, though: stamps "aren't inherently redundant across regions". Our multi-region Azure DR patterns cover that layer.

A pragmatic adoption path

  1. Measure your current blast radius. For your last ten incidents, note the share of customers affected and the trigger. If most hit everyone and started with a change, you have your business case.
  2. Pick the partition key and remove cross-cell paths. Find every query, job and cache that spans tenants. This is the longest step, and worth doing even if you stop here.
  3. Build two cells and a boring router. A canary cell and a main cell, a thin router, a versioned map. With only one cell, hidden "there is only one" assumptions survive.
  4. Move every change into waves. Code, infrastructure, configuration, feature flags, gated on per-cell health with automatic rollback.
  5. Grow the control plane, then the cell count. Add placement and migration tooling, then split the main cell as scale and risk require. For isolation models inside and across cells, see our guide to multi-tenant SaaS isolation on Azure.

The verdict

Cell-based architecture is neither new nor glamorous. It is a bulkhead applied to a whole workload, with a router in front and a control plane beside it. It turns the most important resilience question, "how many customers does one failure hurt?", into a number you choose: 1/N.

Our view: if you run a multi-tenant platform where a total outage is unacceptable, head towards cells. Start with two, put every change through waves, and keep the router boring. For a single-tenant internal system, use the cheaper patterns first: timeouts, in-process bulkheads and good deployment hygiene. Whatever you build, list what sits underneath all your cells. The outages of 2025 and 2026 showed that the global dependency you forgot defines your real blast radius.

If you want a second opinion on a cellular design or a migration plan, our software architecture team runs fixed-scope architecture reviews built around the checklist above.

FAQ

What is a cell-based architecture?

It runs several complete, independent copies of a workload, called cells, and sends each request to exactly one of them based on a partition key such as the tenant ID. Cells share no state. A thin router does the routing; a separate control plane provisions cells and places tenants. If one cell fails, only its tenants are affected. AWS documents the pattern in its Well-Architected guidance; Microsoft calls it Deployment Stamps.

How is a cell different from a microservice or an availability zone?

A microservice splits a system by function, so one request touches many services. A cell splits it by customer: each cell contains every service the workload needs, and a request stays inside one cell. An availability zone is an infrastructure fault boundary your provider gives you; a cell is a workload fault boundary you build yourself. Slack made each zone a cell; other designs put several cells in a region.

How many cells do we need, and how big should a cell be?

Start from the blast radius you can tolerate. With N equal cells, one failed cell affects 1/N of tenants: 10 cells means 10 percent, 20 cells 5 percent. Then cap the cell size: big enough for your largest tenant, small enough to load-test at full size and stay below cloud quotas. Deploy at least two from the start, as Microsoft advises, so no code assumes there is only one.

What is shuffle sharding and how does it relate to cells?

Each customer gets its own random combination of k workers out of n instead of a fixed cell. A poison-pill customer then fully takes down only customers with exactly the same combination: 1 in 28 with 8 workers and shards of 2, against 1 in 4 with four fixed cells. Route 53 uses shards of four out of 2,048 virtual name servers, about 730 billion combinations. It suits stateless fleets and the inside of a cell, with clients that retry on another worker.

Is the cell router a single point of failure?

It is the one component all cells share, so it must be the most boring part of the system: no business logic, a cached and versioned tenant-to-cell map, horizontal scaling, and normal routing to healthy cells when one is unreachable. Release it in waves like a cell, and make sure it keeps serving from its last known map when the control plane is down.

Does cell-based architecture help with DORA or NIS2 compliance?

It helps you evidence them; it does not make you compliant on its own. DORA Article 9(4) asks financial entities for network infrastructure that can be severed or segmented to prevent contagion, and for controlled ICT change management. Cells and wave-based releases demonstrate both. NIS2 Article 21(2)(c) requires business continuity measures, and a rehearsed cell drain or tenant migration is useful evidence for that.

Sources

All sources checked on 15 November 2026. Chart values are our own calculations from the formulas stated in the article.

Tier A: primary and regulatory

Tier B: engineering research and practitioner reports

Tier C: news and analysis, directional

Topics

cell-based architectureblast radiuscell routershuffle shardingdeployment stampsfault isolationbulkhead patternAWS Well-Architected cell-based architecture

Frequently Asked Questions

It runs several complete, independent copies of a workload, called cells, and sends each request to exactly one of them based on a partition key such as the tenant ID. Cells share no state. A thin router does the routing; a separate control plane provisions cells and places tenants. If one cell fails, only its tenants are affected. AWS documents the pattern in its Well-Architected guidance; Microsoft calls it Deployment Stamps.

Expert engagement

Need expert guidance?

Our team specializes in cloud architecture, security, AI platforms, and DevSecOps. Let's discuss how we can help your organization.

Get in touchNo commitment · No sales pressure

Related articles

All posts