home
›
cheatsheets
›
database_technologies
›
cassandra
Free to read Every card and diagram, and Quiz me
2
Free account Star cards. Your Quiz me marks are kept, so next time you drill just what you missed
3
Pro All 41 answers on this sheet, My sheet across every topic, and PDFs
A free account keeps your stars and Quiz me marks. Pro adds all 41 answers on this sheet, My sheet across every topic, and PDFs.
/
Read
Quiz me
Comfortable
Compact
0
Click a command to copy it
Done 0 /0
To review 0
On this sheet
01 Ring & nodes02 Replication & consistency03 Keys & data modeling04 Tables, types & TTL05 Queries & indexes06 Deletes, batches & LWTs07 Write & read path08 Repair, nodes & backups09 Monitor & tune
The model Cassandra hashes the partition key into a token . Nodes own ranges of tokens on a ring , so the token picks a row's nodes. Every node is equal, so any node can be the coordinator for a request. Nodes share cluster state through gossip . The replication factor (RF) sets how many copies exist. The consistency level sets how many replicas must answer. When W + R > RF, every read shares a replica with the latest write. Writes go to the commit log and an in-memory memtable . The memtable flushes to immutable SSTables , which compaction merges. A delete writes a tombstone . Run repair within gc_grace_seconds , 10 days by default, or deleted data can come back. With RF 3, QUORUM is 2. Any 2 replicas a read picks include one with the write. A ONE read can reach C before the hint does.
Ring & nodes how equal nodes share the data What Cassandra is Say what Cassandra is A distributed wide-column database. Every node is equal, and none is the master.
Say how it differs from a relational database It scales out by adding nodes. It has no joins or foreign keys, and no ACID across partitions.
Choose Cassandra over SQL For huge, write-heavy data and queries you know in advance. SQL suits joins and ad hoc queries.
Trap Don't call Cassandra schemaless. Every CQL table has typed columns, but adding a column is cheap.
The token ring Say how Cassandra picks a row's nodes It hashes the partition key into a token. The nodes that own that token's range store the row.
Find the nodes that hold one key nodetool getendpoints app users 42
Give each node many small token ranges num_tokens: 16 Virtual nodes (vnodes). 16 is the default since 4.0, down from 256.
Tip The default partitioner is Murmur3Partitioner . Hashing keys onto a ring of nodes is called consistent hashing.
Trap More tokens per node have a cost. More combinations of failed nodes can take part of the ring offline, and there are more repairs to run.
Coordinator and gossip Say what the coordinator does It forwards a client's request to the replicas, and replies once enough of them answer.
Check which nodes are up nodetool status UN means up and normal, and DN means down.
Say how nodes share cluster state Gossip. Every second, each node swaps state with a random peer and decides for itself who is down.
Trap Seed nodes only help new nodes join. They aren't masters, and any node can coordinate any request.
Replication & consistency how many copies, and how many must answer Replication strategies Say what the replication factor sets How many copies of each row exist. With RF 3, three nodes hold each row.
Keep 3 copies in dc1 and 2 in dc2 {'class': 'NetworkTopologyStrategy', 'dc1': 3, 'dc2': 2} Set it in the keyspace's replication option.
Replicate a test cluster {'class': 'SimpleStrategy', 'replication_factor': 3} It ignores datacenters and racks.
Tell Cassandra each node's datacenter and rack Choose a snitch with endpoint_snitch. Production clusters use GossipingPropertyFileSnitch .
Tip Use NetworkTopologyStrategy in production, even with one datacenter. It puts each datacenter's replicas on different racks.
Consistency levels, RF 3 in two DCs Latest Node down DC down
CONSISTENCY ONE Get the fastest reads and writes
CONSISTENCY LOCAL_QUORUM Read your writes within one datacenter
CONSISTENCY QUORUM Read your writes across the cluster
CONSISTENCY ALL Wait for every replica
Tip Latest means a read sees the last write when reads and writes use that level. For LOCAL_QUORUM, that holds only within one DC.
CAP and eventual consistency Place Cassandra in the CAP theorem At ONE, it's AP. It keeps answering during a network partition, but reads may be stale.
Say what QUORUM does in a network partition Reads and writes see the latest write, but fail on the side without a majority.
Say what an eventually consistent read is It may return an older value until every replica has the write. When replicas disagree, the newest timestamp wins.
Make every read see the latest write Wait for W write and R read replicas, where W + R > RF. With RF 3, QUORUM is 2, and 2 + 2 > 3.
Hinted handoff and read repair Catch up a replica that was down max_hint_window: 3h Hinted handoff. The coordinator stores missed writes as hints, for up to 3 hours of downtime.
Accept a write while every replica is down CONSISTENCY ANY For writes only. A stored hint counts, so the write is lost if the coordinator fails first.
Fix stale replicas during a read Read repair. The coordinator writes the newest value to stale replicas before it answers.
Tip A node down longer than max_hint_window gets no more hints. It stays out of sync until you run repair.
Trap At ONE, only one replica answers, so read repair never runs.
Keys & data modeling design each table around one query Partition key and clustering key Say what the partition key does Cassandra hashes it to pick the nodes. Rows that share it form one partition.
Say what the clustering key does It sorts the rows inside a partition, so a query can read a range in order.
Pick a good partition key Choose one with many distinct values, so data spreads evenly and partitions stay small.
Build a partition key from two columns PRIMARY KEY ((sensor_id, day), ts) The inner parentheses hold the partition key.
Store the newest rows first WITH CLUSTERING ORDER BY (ts DESC)
Trap You set the primary key and the clustering order when you create a table. Changing either means a new table and a data copy.
Design from the queries Start a data model List the app's queries first. Then design one table for each.
Replace a join Denormalize. Copy the data into every table whose query needs it.
Enforce a foreign key You can't. Cassandra has no referential integrity, so the app keeps tables consistent.
Name the common modeling mistakes Unbounded partitions, indexes on high-cardinality columns, and SQL-style normalization.
Trap Don't start from the entities. A table built around an entity rarely answers the queries the app runs.
One-to-many relationships Store a user's orders PRIMARY KEY (user_id, order_date, order_id) One partition per user, and one row per order, sorted by date.
Store the user's name once per partition name text STATIC A static column.
Keep a short list in the parent row order_ids set<uuid> A collection. Use one only when the list stays small.
Tip Separate tables also work. The app joins them with two queries, which costs two round trips.
Trap Cassandra reads a whole collection at once. A list that keeps growing belongs in its own table.
Large partitions and time series Name the partition size limits Keep partitions under 100MB. The hard limit is 2 billion cells.
Find a table's large partitions nodetool tablestats app.events
Split a partition that grows forever Add a time bucket, such as a day, to the partition key.
Expire old readings without deletes Use a TTL with Time Window Compaction (TWCS). It drops whole expired SSTables.
Trap Don't make the date alone the partition key. All of that day's writes then land on the same few nodes.
Tables, types & TTL schema changes, column types and expiry Tables and schema changes Add a column with no downtime ALTER TABLE users ADD phone text;
Drop a column ALTER TABLE users DROP phone; Reads hide it at once. Compaction removes the data later.
Delete every row in a table TRUNCATE users; Every node must be up.
Drop a table or a keyspace DROP TABLE users; DROP KEYSPACE app;
Check that every node has the same schema nodetool describecluster
Trap You can't change a column's type or rename a non-key column. Add a new column instead.
Data types Name the common column types text, int, bigint, double, boolean, timestamp, uuid, timeuuid and blob.
Store several values in one column set for sorted unique values, list for ordered ones, and map for key-value pairs.
Group named fields into one column type CREATE TYPE address (street text, city text); A user-defined type (UDT).
Tip Inside a collection, a UDT must be frozen and written whole. A non-frozen UDT column can change one field.
Time to live (TTL) Make a value expire in one day USING TTL 86400 Add it to an INSERT or UPDATE. The TTL is in seconds.
Give every new row in a table a TTL WITH default_time_to_live = 86400 By default, values never expire.
Tip Expired values turn into tombstones. Compaction removes them after gc_grace_seconds .
Trap A TTL belongs to each value you write. Updating a column resets its TTL.
Counters Add 1 to a page's view count SET views = views + 1 views is a counter column. You can only add or subtract.
Say what else a counter table can hold Only its primary key. A counter can't be part of the key.
Retry a counter update that timed out Not safely. Counters aren't idempotent, so a retry can count twice.
Tip Each counter update reads the current value first, so it costs more than a normal write.
Trap Counters can't have a TTL. Don't update a counter again after you delete it.
Queries & indexes what CQL reads fast, and what it refuses Query rules and ALLOW FILTERING Read one partition SELECT * FROM events WHERE user_id = ?;
Read a time range in that partition WHERE user_id = ? AND event_time > ?
Filter on clustering columns In the order you declared them. You can't skip one to filter the next.
Filter on a column outside the key ALLOW FILTERING Cassandra may read every partition, then drop the rows that don't match.
Tip Use ALLOW FILTERING only on small data, like one partition. Otherwise add a table keyed for the query, or an SAI index.
Trap An ALLOW FILTERING query slows as the table grows, even when it returns few rows.
Indexes and views Index a column (5.0+) CREATE INDEX ON users (country) USING 'sai'; A storage-attached index (SAI). It also handles numeric ranges.
Index a column before 5.0 CREATE INDEX ON users (country); A legacy secondary index. Each node indexes only its own data.
Find the 5 nearest vectors (5.0+) ORDER BY embedding ANN OF [0.1, 0.2] LIMIT 5 It needs a vector<float, n> column with an SAI index.
Tip Materialized views are experimental and off by default. For a busy query, keep a second table keyed for it.
Trap On 5.0, a plain CREATE INDEX still builds the legacy index. Add USING 'sai'.
Deletes, batches & LWTs tombstones, atomic writes, compare and set Deletes and tombstones Delete a row DELETE FROM users WHERE id = ?; Cassandra writes a tombstone, a delete marker with a timestamp.
Set how long tombstones stay WITH gc_grace_seconds = 864000 10 days is the default. After that, compaction can remove them.
Say when tombstones slow or break a read Every read scans past them. A read warns at 1,000 tombstones and fails at 100,000, by default.
Trap Repair within gc_grace_seconds . Otherwise a replica that missed the delete can bring the data back.
Batches Write to two tables so every write lands BEGIN BATCH APPLY BATCH; A logged batch, the default. Its batch log makes every write land eventually.
Skip the batch log BEGIN UNLOGGED BATCH A failed batch may then apply only partly.
Group writes to one partition It's atomic and isolated, and Cassandra skips the batch log.
Trap A batch has no rollback and no isolation across partitions. Other clients can see part of it.
Lightweight transactions Insert a row that may already exist INSERT INTO users (id, email) VALUES (?, ?); It silently overwrites the old values. INSERT and UPDATE are both upserts.
Insert only if the row is new IF NOT EXISTS An LWT. The result's [applied] column says if it ran.
Update only if a value is unchanged IF email = 'old@example.com' Compare and set. The replicas agree on it through Paxos.
Say what an LWT costs 4 round trips with Paxos v1, the default. Paxos v2 (4.1+) needs 2.
Tip LWTs are linearizable, so every client sees them in one order. Use them for unique usernames or stock counts.
Trap An LWT covers one partition. Cassandra 6.0, in alpha as of October 2026, adds Accord for transactions across partitions.
Write & read path what happens inside one node The write path write memtable SSTable commit log one replica A write goes to the commit log and the memtable. A full memtable flushes to an SSTable.Say what a replica does with a write It appends the write to the commit log and adds it to the memtable. Nothing is read first.
Say what a crashed node can lose Its last few seconds of writes, since the commit log syncs every 10 seconds. Other replicas still have them.
Tip Writes are fast because no file changes in place. SSTables never change, and compaction merges them later.
The read path Say how a replica reads a partition It merges the memtable with each SSTable that may hold it. The newest timestamp wins.
Skip SSTables that can't hold the partition Use each SSTable's bloom filter. Its no is always right, and its yes means maybe.
Use more memory for fewer false positives WITH bloom_filter_fp_chance = 0.001 The default is 0.01, or 0.1 with LCS.
Count the SSTables each read touches nodetool tablehistograms app users
Tip Cassandra 5.0 adds the BTI SSTable format. Its trie index replaces the key cache and index lookups.
Compaction Merge SSTables of similar size {'class': 'SizeTieredCompactionStrategy'} STCS, still the default. It suits heavy writes.
Keep each read to few SSTables {'class': 'LeveledCompactionStrategy'} LCS. It suits heavy reads.
Group SSTables by time window {'class': 'TimeWindowCompactionStrategy'} TWCS. It suits time series that expire with a TTL.
Pick a strategy for a new table (5.0+) {'class': 'UnifiedCompactionStrategy'} UCS. It can act like any of the others.
Tip Compaction keeps the newest version of each row and drops tombstones past their grace period.
Trap A growing backlog of pending compactions means each read touches more SSTables.
Repair, nodes & backups keep replicas in sync and change the cluster Repair Repair each token range once nodetool repair -pr Run it on every node.
Say what plain nodetool repair runs An incremental repair. It checks only data written since the last one.
Check all the data, repaired or not nodetool repair --full
Say how often to repair Every node, at least every 7 days. Automatic repair comes in 6.0, in alpha as of October 2026.
Tip Each replica builds a Merkle tree, a tree of hashes. Replicas stream only the ranges whose hashes differ.
Trap Don't rely on hints and read repair. They're best effort, and only nodetool repair compares all the data.
Add, remove or replace a node Add a node It bootstraps, streaming its token ranges before it serves requests.
Drop data a node no longer owns nodetool cleanup Run it on the old nodes after a node joins.
Remove a live node nodetool decommission It streams its data to the new owners first.
Remove a dead node nodetool removenode <host-id> The other replicas stream its data instead.
Replace a dead node with a new machine -Dcassandra.replace_address_first_boot=<ip> It takes over the same token ranges.
Tip If the dead node was down longer than max_hint_window, run repair after you replace it.
Back up and restore Snapshot a keyspace nodetool snapshot -t nightly app It hard-links the SSTables, so it's fast. Run it on every node.
Also keep each newly flushed SSTable nodetool enablebackup Incremental backups. They're off by default.
Restore on the same node nodetool import app users /backup/users It loads SSTables from any folder. It replaced nodetool refresh, deprecated in 4.0.
Restore into a cluster with another layout sstableloader -d 10.0.0.1 app/users
Delete a snapshot nodetool clearsnapshot -t nightly
Tip TRUNCATE and DROP TABLE take a snapshot first by default, so you can still restore the data.
Trap A snapshot sits on the same disk as the data. Copy it off the node, or one failed disk loses both.
Monitor & tune spot trouble early and fix slow nodes Monitor cluster health Find thread pools that are backed up nodetool tpstats Pending or blocked tasks show the overloaded stage.
Measure read and write latency nodetool proxyhistograms It shows latency at the coordinator.
Read metrics with CQL (4.0+) SELECT * FROM system_views.thread_pools;
Tip Cassandra exposes metrics on each node through JMX and virtual tables. Collect them with a tool like Prometheus and Grafana.
Trap DataStax OpsCenter works only with DataStax Enterprise. It can't monitor open-source Cassandra.
Troubleshoot slow requests See where one query spends its time TRACING ON Run it in cqlsh, then run the query.
Check for long garbage collection pauses Cassandra logs them. Long pauses slow every request on that node.
Record live queries to replay later (4.0+) nodetool enablefullquerylog --path /var/lib/fql
Tip The fix is often in the data model. Split large partitions, drop ALLOW FILTERING, and use no higher consistency than you need.
Tune for heavy writes Pick compaction for heavy writes On 5.0, UCS with a tiered setting. Otherwise STCS, the default.
Flush memtables less often memtable_heap_space: 2048MiB Bigger memtables use more heap.
Set how many writes run at once concurrent_writes: 128 About 8 per CPU core.
Speed up the commit log on spinning disks Give it its own disk, apart from the data.
Tip Write at the lowest consistency level the app accepts. ONE writes fastest.
Trap Each speedup has a cost. Tiered compaction slows reads, and a lower consistency level weakens guarantees.
Nothing matches. Try a shorter word, or clear the search.
Practice 41 interview questions Full answers, from beginner to expert.
Found this useful? Pass it on.
Share on LinkedIn
Share on X
Copy link
This sheet stays free. With Pro , you can:
Every answer on this sheet. Read the full answer to all 41 questions it links, not just the 5 free ones.My sheet. The cards you star and the ones you miss in Quiz me, from every sheet, on one page to quiz and print.PDFs. Download this sheet and My sheet, laid out for A4, with every question a link to its answer.The rest of Pro. Every answer in the question library, and 1,000 AI credits a month.
