Cassandra Has Changed a Lot Since 3.11 – You May Not Recognize It Now
A look at the architectural changes in Apache Cassandra 5.0 and the features coming in 6.0, including indexing, compaction, vector search, repair and transactions.
Anyone who learned Cassandra around version 3.11 got fairly uniform advice: model tables around queries, treat secondary indexes with caution, pick a compaction strategy per workload, and organize repair scheduling on your own. Use lightweight transactions for conditional updates. And if you need transactions across several partitions, be prepared to handle more of the work outside the database.
In my consulting work I still come across 3.11 clusters run according to that model. Much of it is still valid, but a number of the limitations that drove those recommendations are no longer the same. Cassandra now offers indexing integrated with storage, vector search, a more flexible compaction strategy and built-in repair scheduling. The 6.0 work goes even deeper into cluster metadata and transactions.
As of September, 2026, the newest GA release is Apache Cassandra 5.0.9. Cassandra 6.0 has not reached GA yet, though alpha builds can be downloaded. The difference is important: SAI is worth evaluating on the stable release, while Accord is a reason to keep an eye on the next one and test it.
What makes this interesting is not that Cassandra has acquired more configuration knobs. It is that a number of long-held assumptions about how Cassandra has to be queried and run have begun to relax. Roughly, the comparison looks like this:
| Area | What changed | Release |
|---|---|---|
| Streaming | A qualifying whole SSTable can be sent via a zero-copy transfer path | 4.0 |
| Operational limits | Guardrails offer configurable warnings and failures | 4.1 |
| Secondary indexing | Storage-Attached Indexing, or SAI | 5.0 |
| Compaction | Unified Compaction Strategy, or UCS | 5.0 |
| Similarity queries | Built-in vectors and approximate nearest-neighbor search | 5.0 |
| Repair scheduling | Auto Repair, requiring explicit opt-in in the 5.0 backport | 5.0.8+ |
| Cluster metadata | Transactional Cluster Metadata | 6.0 work |
| Cross-partition transactions | Integration of Accord | 6.0 work |
The question worth asking today is which pieces of advice still stem from Cassandra’s architecture and which merely reflected the limits of an older implementation.
Cassandra 4.0 improved the cost of moving data
Streaming moves data between nodes during bootstrap, replacement, rebuild, repair and topology changes. In a big cluster, it decides how long it takes before a node is useful and how fast missing replica data can be recovered.
Cassandra 4.0 added a zero-copy streaming path for qualifying whole SSTables. Rather than deserializing their contents into Java objects and then serializing them once more, Cassandra can send the files more directly. Partial transfers and other cases still go through the appropriate streaming path; the optimization does not cover every transfer.
The 4.0 streaming documentation cites about a fivefold speedup in the benchmark used when the feature was introduced. That is not a capacity forecast for every cluster, but it shows why the change was significant: with less allocation and CPU work, more of the transfer can be bounded by storage and network throughput instead.
For a node storing terabytes, faster streaming can make replacement quicker and shorten the period during which replicas are missing. It is an operational gain even though the application’s CQL does not change at all.
Guardrails move some limits into the database
Older Cassandra deployments frequently relied on conventions policed through code review or runbooks. Don’t create hundreds of tables. Keep collections bounded. Don’t let an application run queries across an uncontrolled number of partitions. Be careful with ALLOW FILTERING.
With the Guardrails Framework added in 4.1, operators can encode some of these rules in Cassandra itself. Depending on the guardrail, the configuration can issue a warning, reject an operation once a threshold is passed, or switch a feature off. Examples cover the number of tables and indexes, collection sizes and how many partition keys a query selects. ALLOW FILTERING can be turned off.
In concept:

A warning lets the application team address rising usage before it hits the failure threshold. A rejection blocks any operation that goes over the configured limit. Neither one is a substitute for workload design, but both are more dependable than hoping every developer has read the same operations guide.
Secondary-index advice needs to distinguish SAI from older indexes
If you picked up Cassandra years ago, someone very likely told you:
Stay away from secondary indexes.
Often, that was sound advice. Classic Cassandra secondary indexes could perform badly at scale, particularly when queries had to fan out over many partitions or when index cardinality did not fit the workload. Seasoned teams tended to favour a different Cassandra pattern: build an extra table holding exactly the shape the query needs.
Let’s say we store users:
CREATE TABLE users (
id uuid PRIMARY KEY,
country text,
age int,
status text,
name text
);
and need to query them by country and age. The classic Cassandra solution could be one more table:
users_by_country_and_age
with a suitable partition and clustering key. Then a new query comes along, and so does a new table. That is not automatically a mistake – query-driven denormalization is still one of Cassandra’s strong points.
Cassandra 5.0 introduces Storage-Attached Indexing. We can index the columns we filter on:
CREATE INDEX users_country_idx
ON users(country)
USING 'sai';
CREATE INDEX users_age_idx
ON users(age)
USING 'sai';
CREATE INDEX users_status_idx
ON users(status)
USING 'sai';
These examples presume an existing keyspace already selected for the session. Syntax and supported column types are described in the CQL index documentation.
SAI ties indexes into memtables and SSTables. Reads merge results from these structures, and the index lifecycle tracks the storage engine’s flushes and compactions. It handles numeric ranges, combinations of indexed predicates, collection predicates and text equality. For certain access patterns, this can make an extra query-specific table unnecessary.
There is a relevant operational upside too. When the needed filtering can remain inside Cassandra, you may not have to maintain a second copy in an external indexing system with its own replication, recovery and monitoring. That is true only if SAI delivers the query behavior the application requires.
An index does not eliminate query fan-out
SAI changes the way Cassandra locates matching rows. It does not make a query spanning many partitions as cheap as a lookup by a single partition key.
Using the indexes above, we can filter on both country and age without ALLOW FILTERING:
SELECT id, name, age
FROM users
WHERE country = 'PL'
AND age >= 30
AND age < 40;
SAI lets you combine indexed predicates with AND, as the query documentation shows. That gives us one more access pattern without having to maintain another table.
The physical layout, however, is not the same. A table partitioned by country, with age as a clustering column, can answer this query from the replica set of the relevant country. In the users table, rows are still partitioned by ID, so an indexed query may have to do work across several token ranges. Supporting the same filter does not mean the same routing, ordering or read cost.
The users example is intentionally simple. Filtering on a common country or status can hit a big share of the dataset. An index makes such a query possible to express and can cut down local scanning, but the value distribution and the work spread across nodes still count.
For a frequent query with tight latency requirements, I would benchmark SAI against a table built for that query, using representative data. Measure read latency and cluster work, and then factor in the write and storage cost of maintaining either the indexes or the denormalized tables.
The old blanket rule of avoiding secondary indexes is too sweeping. What replaces it is evaluating SAI for the specific access pattern, while partitioning and selectivity remain part of the decision.
UCS makes compaction behavior easier to adjust
Traditionally, Cassandra operators have picked from several compaction strategies:
| Strategy | Typical reason to choose it | Cost to consider |
|---|---|---|
| STCS | Workloads dominated by writes | Reads may have to check more SSTables |
| LCS | Lower read amplification | Compaction rewrites more data |
| TWCS | Time-series data with fitting TTL patterns | How well it works depends on timestamp and expiration behavior |
Cassandra 5.0 introduces Unified Compaction Strategy. The UCS documentation recommends it for the majority of workloads and explains how to configure it to behave like the older strategies.
UCS expresses the tiered-versus-leveled trade-off through scaling parameters. Positive values lean towards tiered behavior, negative ones towards leveled behavior, and each level can use its own settings. Sharding lets compaction work run in parallel and helps keep SSTable sizes under control on nodes with large datasets.

You can change the parameters while the system runs, without a full recompaction just to move between these behaviors. That makes tuning far less disruptive than treating the original strategy as a decision for life.
Measurement is still necessary. A change that lowers read amplification may raise background write work. Existing SSTables also need time to pass through compaction; adjusting a setting does not produce a new layout right away. UCS gives operators one shared mechanism for shifting that balance – it does not make the balance go away.
Vector search can stay next to operational data
Cassandra 5.0 adds a native vector type and approximate nearest-neighbor search via SAI. A product can keep its operational fields and an embedding side by side:
CREATE TABLE products (
id uuid PRIMARY KEY,
name text,
description text,
embedding vector<float, 768>
);
CREATE INDEX products_embedding_idx
ON products(embedding)
USING 'sai';
A client can then prepare a similarity query:
SELECT id, name
FROM products
ORDER BY embedding ANN OF ?
LIMIT 10;
In this query, ? is a bind marker for a 768-element query vector that the client provides. The model producing the embedding stays outside Cassandra.
The supported similarity functions are cosine similarity, dot product and Euclidean distance. The 5.0 announcement lists vector search among the main additions in the release.
The most compelling case is an application that already keeps a large operational dataset in Cassandra and wants to run similarity queries on it. Storing the record and the embedding together can spare you from copying that data into a second database only for vector retrieval.

This does not decide which retrieval system to use. Approximate search quality, filtering, latency, update behavior and operating cost all still have to be assessed. For a RAG application, say, what counts is good retrieval over its real corpus, not merely being able to execute an ANN query.
Auto Repair adds built-in scheduling
Cassandra replicas may drift apart temporarily. Anti-entropy repair compares replica data and reconciles differences that other mechanisms did not fix. The repair machinery has been in Cassandra for a long time; scheduling it across the cluster, however, has frequently relied on external tools such as Cassandra Reaper.
The scheduler has to cover the relevant token ranges, retry failed attempts and spread the work so that foreground traffic is not swamped. Auto Repair, built under CEP-37 for 6.0 and backported to 5.0.8, brings that orchestration into Cassandra. It handles scheduling of full, incremental and preview repair, token-range splitting, repair history and table priorities. Preview repair verifies consistency instead of fixing differences.
The 5.0 backport involves two distinct steps. The JVM property cassandra.autorepair.enable turns on the required schema support, and scheduling is then switched on through configuration or JMX. According to the documentation, the property cannot be reversed; turning off a schedule is a separate operation. This calls for a deliberate migration decision instead of being lumped in with routine configuration cleanup.
Having a scheduler built in means less need to run a separate orchestration service. Operators must still check coverage, successful completion and resource consumption. A configured schedule does not prove that every range gets repaired often enough.

Cassandra 6.0 orders cluster metadata changes
The changes that follow are part of the 6.0 development line, not the current stable 5.0 release.
Historically, Cassandra has leaned heavily on gossip and eventual propagation for cluster information. That is fine for sharing observations, but topology and schema changes require a consistent interpretation. When a node joins or leaves, coordinators have to know which replicas own the affected ranges, even while requests are still in flight.
Transactional Cluster Metadata, specified in CEP-21, brings a Cluster Metadata Service and an ordered log of transformations. Nodes apply committed metadata changes in that sequence. This gives changes such as schema updates and token ownership transitions a shared history.

The key distinction is between agreeing on the cluster’s structure and observing whether nodes are alive. Gossip still plays a part; it is just no longer expected to set the authoritative order of critical metadata changes. Nor does every write of user data turn into an operation routed through a permanent primary node.
For operators, this removes ambiguity around topology changes that happen concurrently or are only partially observed. The goal is to make ownership transitions explicit and interpreted consistently, instead of counting on every node eventually piecing together the same view.
Accord extends the transaction model across partitions
Cassandra already supports atomic operations within a partition and lightweight transactions based on Paxos for conditional updates. Claiming a username is a well-known example:
INSERT INTO usernames (username, user_id)
VALUES ('alice', ?)
IF NOT EXISTS;
This presumes a table keyed by username and a client that binds user_id. It expresses a conditional operation inside that partition. It does not offer a general transaction for arbitrary reads and writes over unrelated partitions.
This matters when an invariant covers several accounts, inventory items or other entities partitioned independently. Squeezing everything into a single partition can make coordination easier, but it can also lead to a hot or unbounded partition. A logged batch spanning partitions cannot stand in for an isolated, conditional multi-partition transaction.
CEP-15 brings Accord for general-purpose transactions with strict serializability. It aims at a leaderless protocol whose fast path needs one WAN round trip under normal conditions. That is a property of the protocol under the conditions it states, not a general latency guarantee for every application transaction.
The 6.0-alpha2 integration documentation explains how Cassandra links CQL execution, persistence and recovery to Accord. For a transfer between accounts in separate partitions, the expected gain is that the database can coordinate the conditional debit and credit as a single transaction.
Strict serializability means committed transactions act as though they ran in some serial order that also honours real-time ordering. That is a far broader guarantee than individual successful writes to each account.

Coordination and migration still need attention
Cross-partition transactions involve the participating replicas, transaction state, conflict handling and recovery. Data locality still influences cost, and contention can influence latency. Accord can uphold an invariant that used to need coordination in the application, but it does not make every distributed update cheap.
The adoption design also lets existing Paxos-based LWT and Accord run side by side during a transition. CEP-15 calls for live migration and leaves any eventual deprecation of Paxos to a future decision. AxonOps’ summary of Ariel Weisberg’s operator talk says Accord is meant to be disabled by default and adopted table by table, with the possibility of moving a table back to Paxos-based LWT. The precise configuration and migration behavior should be verified against whichever 6.0 release you are evaluating; how an alpha behaves is not a final production contract.
For an existing application, I would begin with an invariant that is hard to enforce today and test that specific operation. Measure normal execution as well as recovery after failures. The new guarantee pays off when it simplifies an actual requirement, not when it becomes an excuse to spread naturally related data over several partitions.
What still needs the same care
Partition keys still decide where data lands. Skewed traffic can create hot partitions, and large partitions are still costly to read, compact and move. SAI and Accord do not change any of that.
Denormalization is still valuable for predictable, frequent queries. There is simply one more option to weigh now: compare what a purpose-built table costs against indexed access, including the work of keeping each representation up to date.
Tombstones and TTLs continue to affect reads, compaction and repair. Deleting or expiring data does not instantly get rid of every stored version. A new compaction strategy changes how that work is organized, not whether it has to happen.
Cassandra also stays focused on distributed, partitioned workloads. Flexible indexing and wider transactions do not bring arbitrary relational joins. Whether it fits still depends on the application’s query patterns, distribution needs and consistency choices.
Returning from 3.11
If you run 3.11, Cassandra 5.0 is the sensible release to evaluate first. SAI, UCS and vector search are already there, together with lower-level changes such as trie-based memtables and the BTI SSTable format. Auto Repair ships in the later 5.0 maintenance releases, subject to the opt-in requirements described earlier.
There is a maintenance argument for moving as well: Apache declared the end of life of the 3.x series together with 5.0. Assessing new features should be kept apart from deciding how to get off an unmaintained branch.
Plan the migration via a supported 4.x release before going to 5.0. Apache describes 3.11 to 4.x and 4.x to 5.0 as upgrade paths designed and tested to be done online. Specific patch versions, runtime requirements, driver compatibility and SSTable steps still have to follow the upgrade notes of the release you are targeting.

I would do the version upgrade on its own, separately from schema and indexing changes, and then compare representative queries and operational tasks on the upgraded cluster. That way it is easier to tell which change influenced behavior.
If your picture of Cassandra was formed by 3.11, the update worth making is concrete: some queries may not need an extra table anymore, compaction is simpler to tune within a single strategy, and repair scheduling can live inside the database. The 6.0 work may take another burden off the application through cross-partition transactions. Partitioning and workload design are still what decides whether those capabilities actually help.