# cell-based-architecture

A software architecture that uses multiple independent, isolated workload instances called cells to contain failures and handle subsets of requests.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Cursor Uses S3 WAL to Scale Git Storage to More than 300 Pushes per Second

DevFeed: [Cursor Uses S3 WAL to Scale Git Storage to More than 300 Pushes per Second](<https://devfeed.tech/articles/cursor-uses-s3-wal-to-scale-git-storage-to-more-than-300-pushes-per-second-62405.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/09/cursor-continuity-git-storage/>)

Author: Leela Kumili

Published: 2026-09-30T13:47:00Z

Content type: news

Language: en

Sources: [InfoQ](<https://devfeed.tech/sources/infoq.md>)

Topics: [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>), [cell-based-architecture](<https://devfeed.tech/topics/cell-based-architecture.md>), [Data integrity in software engineering](<https://devfeed.tech/topics/data-integrity-in-software-engineering.md>), [consistency](<https://devfeed.tech/topics/consistency.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai-architecture](<https://devfeed.tech/tags/ai-architecture.md>), [ai-assisted-coding](<https://devfeed.tech/tags/ai-assisted-coding.md>), [architecture-design](<https://devfeed.tech/tags/architecture-design.md>), [aws](<https://devfeed.tech/tags/aws.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [continuous-integration](<https://devfeed.tech/tags/continuous-integration.md>), [cursor-continuity-git-storage](<https://devfeed.tech/tags/cursor-continuity-git-storage.md>), [database-replication](<https://devfeed.tech/tags/database-replication.md>), [development](<https://devfeed.tech/tags/development.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [github](<https://devfeed.tech/tags/github.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [ide](<https://devfeed.tech/tags/ide.md>), [latency](<https://devfeed.tech/tags/latency.md>), [news](<https://devfeed.tech/tags/news.md>), [nvme](<https://devfeed.tech/tags/nvme.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [s3](<https://devfeed.tech/tags/s3.md>), [scaling](<https://devfeed.tech/tags/scaling.md>), [source-of-truth](<https://devfeed.tech/tags/source-of-truth.md>), [wal](<https://devfeed.tech/tags/wal.md>)

### AI overview

Cursor's Continuity Git storage architecture uses an S3-backed write-ahead log as the durable source of truth, while local NVMe repositories serve as warm caches. Cursor reports linear read scaling with up to 100 replicas and more than 300 pushes per second in synthetic tests. The article also notes that these performance figures have not been independently verified.

### Source excerpt

Cursor has introduced Continuity, a Git storage architecture that uses an S3 backed write ahead log as the source of truth. The design turns local NVMe repositories into warm caches and separates replica coordination from consistency. Cursor reports linear read scaling with up to 100 replicas and more than 300 pushes per second with S3 Express One Zone in synthetic tests. By Leela Kumili

## Cell-Based Architecture for Resilient Payment Systems

DevFeed: [Cell-Based Architecture for Resilient Payment Systems](<https://devfeed.tech/articles/cell-based-architecture-for-resilient-payment-systems-56635.md>)

Original publisher: [Read original article](<https://americanexpress.io/cell-based-architecture-for-resilient-payment-systems/>)

Published: 2026-06-11T04:00:00Z

Content type: article

Language: en

Sources: [American Express Technology](<https://devfeed.tech/sources/american-express-technology.md>)

Topics: [cell-based-architecture](<https://devfeed.tech/topics/cell-based-architecture.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Availability](<https://devfeed.tech/topics/availability.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [cell-based-architecture](<https://devfeed.tech/tags/cell-based-architecture.md>), [cloud-native](<https://devfeed.tech/tags/cloud-native.md>), [databases](<https://devfeed.tech/tags/databases.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [high-availability](<https://devfeed.tech/tags/high-availability.md>), [latency](<https://devfeed.tech/tags/latency.md>), [low-latency](<https://devfeed.tech/tags/low-latency.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [payment-systems](<https://devfeed.tech/tags/payment-systems.md>), [payments](<https://devfeed.tech/tags/payments.md>), [resiliency](<https://devfeed.tech/tags/resiliency.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [scale](<https://devfeed.tech/tags/scale.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

American Express describes how it uses cell-based architecture in a global payments platform to contain failures, reduce blast radius, maintain low-latency processing, and scale capacity without expanding failure domains. The approach groups related microservices, databases, and other components into independent cells.

### Source excerpt

How American Express uses cell-based architecture to deliver resilient, low-latency payments at global scale.

## How we handle multi-region sessions at Clever

DevFeed: [How we handle multi-region sessions at Clever](<https://devfeed.tech/articles/how-we-handle-multi-region-sessions-at-clever-19722.md>)

Original publisher: [Read original article](<https://engineering.clever.com/2021/08/10/how-we-handle-multi-region-sessions-at-clever/>)

Author: Nathan Leiby

Published: 2021-08-10T20:48:35Z

Content type: article

Language: en

Sources: [Clever](<https://devfeed.tech/sources/clever.md>)

Topics: [cell-based-architecture](<https://devfeed.tech/topics/cell-based-architecture.md>), [state-management](<https://devfeed.tech/topics/state-management.md>), [XtraDB Cluster (PXC)](<https://devfeed.tech/topics/xtradb-cluster-pxc.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [aws](<https://devfeed.tech/tags/aws.md>), [database](<https://devfeed.tech/tags/database.md>), [deploy](<https://devfeed.tech/tags/deploy.md>), [devops](<https://devfeed.tech/tags/devops.md>), [helps](<https://devfeed.tech/tags/helps.md>), [mirror](<https://devfeed.tech/tags/mirror.md>), [multi-region](<https://devfeed.tech/tags/multi-region.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [resiliency](<https://devfeed.tech/tags/resiliency.md>), [saml](<https://devfeed.tech/tags/saml.md>), [sessions](<https://devfeed.tech/tags/sessions.md>), [systems](<https://devfeed.tech/tags/systems.md>), [traffic](<https://devfeed.tech/tags/traffic.md>)

### AI overview

Clever's excerpt frames session resilience as a progression: in-memory sessions are lost on restart, so persist them in a database; run multiple application servers so sessions remain available across crashes or redeploys; and use database replicas to fail over if the primary instance fails. Those steps still leave the whole database setup vulnerable to cascading failures or a data-center networking issue, motivating a mirrored setup in another region. The excerpt ends as that multi-region step begins, so it does not explain its implementation or behavior.

### Source excerpt

Why multi-region sessions? Each year leading up to Back to School (our busiest season), Clever's engineering team invests in our highest traffic systems to make sure we can handle user growth and new traffic patterns. During 2020-2021, SAML auth at Clever grew from <10% of our login related traffic to about 40% of our traffic! For this [...] The post How we handle multi-region sessions at Clever appeared first on Clever Engineering Blog.

## Some risks of coordinating only sometimes

DevFeed: [Some risks of coordinating only sometimes](<https://devfeed.tech/articles/some-risks-of-coordinating-only-sometimes-12486.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2019/05/01/emergent.html>)

Author: Marc Brooker

Published: 2019-05-01T00:00:00Z

Content type: article

Language: en

Sources: [Marc Brooker's](<https://devfeed.tech/sources/marc-brooker-s-blog.md>)

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [Production Engineering](<https://devfeed.tech/topics/production-engineering.md>), [synchronization](<https://devfeed.tech/topics/synchronization.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>), [cell-based-architecture](<https://devfeed.tech/topics/cell-based-architecture.md>)

Tags: [availability](<https://devfeed.tech/tags/availability.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [cloud-architecture](<https://devfeed.tech/tags/cloud-architecture.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [clusters](<https://devfeed.tech/tags/clusters.md>), [controller](<https://devfeed.tech/tags/controller.md>), [costs](<https://devfeed.tech/tags/costs.md>), [design](<https://devfeed.tech/tags/design.md>), [failure](<https://devfeed.tech/tags/failure.md>), [load](<https://devfeed.tech/tags/load.md>), [network](<https://devfeed.tech/tags/network.md>), [node](<https://devfeed.tech/tags/node.md>), [operational](<https://devfeed.tech/tags/operational.md>), [operator](<https://devfeed.tech/tags/operator.md>), [risks](<https://devfeed.tech/tags/risks.md>), [scale](<https://devfeed.tech/tags/scale.md>), [systems](<https://devfeed.tech/tags/systems.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

Systems that avoid cross-cluster coordination for normal operation can behave unpredictably when failures or scaling suddenly require it. Correlated failures may trigger bursts of coordination and traffic, overwhelm controllers, and lengthen recovery; clusters may also lack spare capacity to recover while serving workloads. Stale system-state information can worsen scheduling choices during failures, increasing churn and capacity stress. These feedback effects can push a system from normal operation into an overloaded state. The excerpt describes three emerging design patterns: keep coordination work constant regardless of workload (at the cost of wasted work), limit communication to a defined blast radius, and maintain static stability so systems can keep operating as best they can without coordination. It also says better tools are needed to characterize and test real-world failure behavior.

### Source excerpt

Some risks of coordinating only sometimes Sometimes-coordinating systems have dangerous emergent behaviors A classic cloud architecture is built of small clusters of nodes (typically one to nine1), with coordination used inside each cluster to provide availability, durability and integrity in the face of node failures. Coordination between clusters is avoided, making it easier to scale the system while meeting tight availability and latency requirements. In reality, however, systems sometimes do need to coordinate between clusters, or clusters need to coordinate with a central controller. Some of these circumstances are operational, such as around adding or removing capacity. Others are triggered by the application, where the need to present a client API which appears consistent requires either the system itself, or a layer above it, to coordinate across otherwise-uncoordinated clusters. The costs and risks of re-introducing coordination to handle API requests or provide strong client guarantees are well explored in the literature. Unfortunately, other aspects of sometimes-coordinated systems do not get as much attention, and many designs are not robust in cases where coordination is required for large-scale operations. Results like CAP and CALM2 provide clear tools for thinking through when coordination must occur, but offer little help in understanding the dynamic behavior of the system when it does occur. One example of this problem is reacting to correlated failures. At scale, uncorrelated node failures happen all the time. Designing to handle them is straightforward, as the code and design is continuously validated in production. Large-scale correlated failures also happen, triggered by power and network failures, offered load, software bugs, operator mistakes, and all manner of unlikely events. If systems are designed to coordinate during failure handling, either as a mesh or by falling back to a controller, these correlated failures bring sudden bursts of coo