Cassandra in 2025: A Year in Review

Cassandra in 2025: A Year in Review

Grab your eggnog, settle into your favourite chair, and gather 'round the distributed cluster, folks. It's time to look back at an absolutely cracking year for Apache Cassandra! Pour yourself something festive, because we've got a lot to celebrate.
‍

Introduction: The Cassandra Renaissance

Cast your mind back a few years. The database landscape was noisy. NewSQL this, serverless that, and everyone's cousin was launching a "revolutionary" database that would solve all your problems (spoiler: it usually didn't). In all that noise, some people (perhaps unfairly) started to wonder if Cassandra's best days were behind it.

Well, 2025 came along and said, "Hold my beer. Actually, hold everyone's beer."

Apache Cassandra didn't just have a good year. It had a full-blown comeback tour worthy of a rock legend returning to the stage after everyone thought they'd retired. We're talking standing ovations, encores, and fans rushing the stage (metaphorically speaking... please don't rush your database clusters).

Cassandra never actually went away. It was always there, quietly powering some of the world's most demanding workloads at companies you definitely use every day. But 2025? This was the year everyone remembered why they fell in love with this distributed powerhouse in the first place.

And we're here for every single node of it.

Community Over Code 2025

If there's one thing that defines the Apache way, it's the mantra "Community Over Code." And nowhere was this more evident than at the Community Over Code conference, the Apache Software Foundation's flagship event that brought together developers, operators, architects, and database enthusiasts (we say "enthusiasts" because "nerds" feels too limiting for such brilliant people) from every corner of the globe.

The Cassandra track this year was stacked. We're talking wall-to-wall brilliance, standing-room-only sessions, and the kind of hallway conversations that remind you why in-person conferences still matter.

‍

The Talks That Had Everyone Buzzing

Every talk brought something valuable, but a few really captured the spirit of where Cassandra is heading.

Johnny Miller & Joaquin Casares: "Beyond the Command Line"

Johnny Miller and Joaquin Casares teamed up for what became one of the most practically useful sessions of the entire conference: "Beyond the Command Line: Modern Tools for Cassandra Development".

If you've ever struggled with cqlsh (and let's be honest, who hasn't?), this talk was a revelation. Johnny and Joaquin walked through the evolution of Cassandra developer tooling, from the early days of command-line-only interfaces to the modern landscape of GUI tools, AI-powered assistants, and high-performance drivers.

The highlights? A live demo of AxonOps Workbench showing just how much easier life can be when you have a proper visual interface for your clusters. They also showcased CQLAI, demonstrating how AI can help developers write better CQL queries by understanding your actual schema. And for the Python developers in the room, Johnny unveiled the async Cassandra Python driver (perfect for FastAPI and other async frameworks).

The Q&A ran long because everyone wanted to know: "Wait, this is all free and open source?" Yes. Yes it is.

Bloomberg's Road to Cassandra 5.0

Andres Beck-Ruiz and William Nguyen from Bloomberg delivered one of the most anticipated talks: their journey upgrading to Cassandra 5.0 at massive scale.

And when we say massive, we mean it: 5 petabytes of data, 5,500 nodes, across 350 clusters. This isn't a toy deployment. This is Cassandra in the wild, doing real work for one of the world's most demanding financial data platforms.

The performance numbers they shared had the room buzzing:

• Trie memtables: ~50% write throughput improvement out of the box
• P99 latencies: Dropped to low single digits
• Storage Attached Indexes (SAI): Doubled throughput and halved latency compared to legacy secondary indexes

Perhaps most useful for operators everywhere: they discovered you can upgrade with 2 rolling restarts instead of 3. That's a significant operational win for anyone managing large clusters.

Netflix: Cassandra at Planet Scale

Cheng Wang and Joshua Lopes from Netflix presented their operational excellence journey, and the scale numbers were staggering:

• 2,500+ clusters (up from 900 in 2022)
• 58,000 nodes (up from 22,000 in 2022)
• 20+ petabytes of data (up from 12 petabytes)
• 38 million requests per second (up from 12 million)

That's not growth. That's explosion. And they're handling it with a relatively small team, thanks to sophisticated automation and tooling.

Their migration to Cassandra 4.1 is nearly complete, with 5.0 on the roadmap. The key takeaway? At Netflix scale, operational tooling isn't optional. It's survival.

Patrick McFadin: Imagining the Next 10 Years

Patrick McFadin delivered a visionary keynote that had everyone thinking about Cassandra's future. Where is this database heading over the next decade?

His vision includes CQL evolving toward SQL syntax (because why make developers learn yet another query language?), object storage as a first-class citizen, HTAP (hybrid transactional/analytical processing) capabilities, and a unified API gateway. The goal? Make Cassandra "the easiest database to migrate into."

Bold words, but if the community can deliver on even half of this vision, Cassandra's best years are definitely ahead of it.

Alex Petrov & Ariel Weisberg: Accord Deep Dives

Two talks that had the distributed systems nerds glued to their seats: Alex Petrov's deep dive into Accord internals and Ariel Weisberg's practical guide to living with Accord.

Alex, author of Database Internals and Cassandra PMC member, walked through the missing implementation details that aren't in the academic paper. He even unveiled a new interactive visualization tool for understanding Accord's transaction flows and Lamport diagrams. For anyone preparing for Accord's rollout, this talk is essential viewing.

Ariel, who's been working on Accord for over three years, covered the practical operator concerns: how to enable Accord, the migration lifecycle from Paxos to Accord (and back!), new nodetool commands, and what to expect performance-wise during migration. The key reassurance? Accord is off by default. You can upgrade to 6.0 without using it, then adopt it when you're ready.

The Community Spirit

But beyond the headline talks, what made Community Over Code special was the feeling in the room. There's something special about being surrounded by people who actually get why distributed databases matter. People who've been paged at 3 AM for cluster issues. People who've had to explain to their CTO why "just add more RAM" isn't always the answer. People who light up when you mention consistent hashing or vector clocks.

The hallway track was just as good as the main stage. Impromptu whiteboard sessions breaking down complex problems. Vendors who actually listened instead of just pitching. Core contributors who took the time to answer questions from newcomers. This is what open source community looks like at its best.

If you've never attended a Community Over Code or ApacheCon event, put it on your calendar for next year. The technical content is world-class, but the connections you make are invaluable.

Cassandra 5.0

Now for what everyone's really been on about this year. The field reports from Cassandra 5.0 deployments have been rather impressive (in the best possible way).

Cassandra has always been powerful. It's always been capable of scale that makes other databases break into a cold sweat. But sometimes that power came with complexity. Sometimes you needed to be a bit of a wizard to get the best performance out of it.

Cassandra 5.0 changed that equation dramatically.

JDK 17 + Shenandoah GC

Garbage collection has historically been the bane of many a Cassandra operator's existence. Those GC pauses that would spike your P99 latencies. Those moments where everything would freeze for just long enough to trigger alerts and wake up your on-call engineer.

The combination of JDK 17 and the Shenandoah garbage collector has been nothing short of revolutionary for Cassandra deployments. We're not using that word lightly. This is a genuine paradigm shift.

GC Pauses: From Nightmare to Non-Event

Remember those stop-the-world pauses that would randomly appear in your metrics, turning beautiful latency graphs into something resembling a heart monitor during a jump scare? With Shenandoah GC on JDK 17, those are effectively gone.

We're talking low single-digit milliseconds GC pause times. Teams are reporting that GC has essentially become a non-factor in their operational concerns. The garbage collector does its work concurrently, in the background, while your queries keep flowing smoothly.

One team we spoke with said they had to adjust their monitoring dashboards because their old alerting thresholds were never being triggered anymore. Their "high GC pause" alerts had become so obsolete they were generating noise about the lack of alerts. What a problem to have!

‍

Latencies

The impact on latencies has been dramatic:

• P50 latencies that were already good are now excellent
• P99 latencies that used to spike unpredictably are now consistent and low
• P999 latencies (yes, the really extreme tail) have improved to the point where teams are actually comfortable looking at them

We've heard reports of clusters where the P99 read latency dropped by 40-60% after upgrading to Cassandra 5.0 with JDK 17 and Shenandoah. These aren't synthetic benchmarks in controlled lab environments. These are production workloads with real traffic patterns and real data.

The predictability factor cannot be overstated. It's not just that latencies are lower; it's that they're consistent. You can make promises to your product team about performance characteristics and actually keep them.

Throughput

With the GC overhead reduced so dramatically, clusters are handling more throughput without breaking a sweat. The resources that used to go to garbage collection are now available for actually serving requests.

Teams report:

• Increased queries per second on the same hardware
• Lower CPU utilization during normal operations
• More headroom for traffic spikes
• Better overall resource efficiency

One particularly memorable story came from a team running a high-throughput time-series workload. After upgrading, they realised they could handle their projected growth for the next two years without adding nodes. That's not just a performance improvement. That's a CFO-approved cost optimisation.

Storage Attached Indexes (SAI)

Cassandra 5.0 also brought Storage Attached Indexes (SAI) to general availability, and the community has been exploring the possibilities ever since.

SAI provides a more flexible indexing option that integrates tightly with Cassandra's storage engine. This opens up query patterns that were previously difficult or inefficient, without sacrificing the performance characteristics that make Cassandra Cassandra.

Want to query by a non-partition key column without denormalizing your data model into seventeen different tables? SAI makes that possible. Want to support search-style queries alongside your normal Cassandra workloads? SAI has you covered.

The early adopters have been reporting positive results, and the feature continues to mature.

Vector Search

With the AI revolution in full swing, vector search capabilities in Cassandra 5.0 have been getting a lot of attention. The ability to store and search vector embeddings directly in Cassandra opens up new use cases around similarity search, recommendation engines, and AI-powered applications.

Teams that were previously running separate vector databases alongside Cassandra are exploring consolidation. One database to rule them all? Not quite, but for workloads where vector search is complementary to existing Cassandra use cases, the operational simplicity of keeping everything in one place is compelling.

Real-World Feedback: The Verdict Is In

The most telling indicator of Cassandra 5.0's success isn't the feature list or the benchmark numbers. It's the vibe in the community.

We've seen teams post about their migration experiences, and the sentiment is overwhelmingly positive. Comments like:

• "Our on-call rotations have gotten boring because nothing breaks anymore"
• "I actually look forward to showing our latency dashboards in meetings now"
• "My SRE team asked if I'd secretly replaced Cassandra with something else"

When your dat
abase becomes boring because it just works, that's the ultimate compliment.

What's Cooking for 2026? The Road Ahead

The Cassandra project isn't resting on its laurels. The community is actively working on what comes next, and the roadmap discussions have been exciting.

JDK 21 and Generational ZGC: The Next Performance Leap

If you thought JDK 17 with Shenandoah was impressive, wait until you see what's coming with JDK 21 support (CASSANDRA-18831).

The headline feature? Generational ZGC. And the Cassandra-specific benchmarks are frankly ridiculous:

• 4x throughput compared to non-generational ZGC
• 75% less memory for the same workload
• Pause times still under 1 millisecond
• No more allocation stalls under high concurrency

That last point is crucial. With single-generation ZGC, once you hit around 75 concurrent clients, the garbage collector can get overwhelmed. Allocation stalls happen when objects are being created faster than the GC can reclaim memory. Generational ZGC solves this by splitting the heap into young and old generations, collecting short-lived objects more frequently. Young objects die young (the "weak generational hypothesis"), so why scan the whole heap every time?

The result? Cassandra stays performant even when your traffic spikes. Your P99.999 latencies stay sane. Your ops team stays happy.

JDK 21 support is in progress, and we're looking forward to seeing these gains in production clusters in 2026.

Cassandra 5.1: Refinement and Polish

Cassandra 5.1 is in active development, focusing on building upon the solid foundation of 5.0:

• Performance refinements: Because there's always room to be faster
• Operational improvements: Quality-of-life enhancements for operators
• Bug fixes and stability: Polishing the edges based on real-world feedback
• SAI enhancements: Continued improvements to Storage Attached Indexes
• Vector search maturation: Building on the vector capabilities introduced in 5.0

The goal with 5.1 is to take everything that makes 5.0 great and make it even better. It's the "we listened to your feedback" release.

Cassandra 6.0 and Accord

And then there's the one everyone's whispering about in the hallways at conferences: Cassandra 6.0 and the game-changing Accord consensus protocol.

If you attended the Accord talks at Community Over Code (or watch the recordings, which you really should), you'll understand why this is such a big deal. Accord brings multi-partition ACID transactions to Cassandra with just one WAN round trip in the common case. That's not a typo. Strictly serializable, multi-key transactions, at distributed database speed.

Here's what makes Accord special:

• Leaderless consensus: Any replica can coordinate transactions (no single point of failure)
• Fast path: Most transactions complete in a single WAN round trip
• No coordination for non-conflicting transactions: Better throughput under load
• Strict serializability with real-time ordering: If transaction A finishes before B starts, they execute in that order

The best part? As Ariel Weisberg emphasised in his talk, Accord is off by default. You can upgrade to 6.0 without using it, then adopt it incrementally, per-table, when you're ready. You can even migrate back to Paxos if needed. No cliff edges, no all-or-nothing migrations.

Alex Petrov even built an interactive visualization tool for understanding Accord's transaction flows. The community is serious about making this accessible.

Will we see Cassandra 6.0 with GA Accord in 2026? The community has been working on this for years, and GA is "coming up" (as Alex quipped, "it's been coming up since 2021, but hopefully not for long anymore"). Fingers, toes, replication factors, and consistency levels crossed!

The CEP Process: Community-Driven Innovation

One of the healthiest aspects of the Cassandra project is the Cassandra Enhancement Proposal (CEP) process. Major changes are proposed, discussed, debated, and refined in the open. Anyone can participate. The best ideas win.

Looking at the CEP tracker, there's plenty to be excited about beyond Accord:

• CEP-39: Cost Based Optimizer - smarter query planning
• CEP-36: Configurable ChannelProxy - external/object storage support (hello, S3!)
• CEP-38: CQL Management API - better operational interfaces
• CEP-43: CREATE TABLE LIKE - quality of life improvement (already in trunk)
• CEP-4: EXPLAIN - finally, query execution plans
• CEP-5: JOINs - yes, you read that right
• CEP-6: Change Data Capture v2 - improved CDC

If you want to see where Cassandra is heading, watching the CEPs is like having a crystal ball. And if you have ideas? Submit your own proposal. That's the beauty of open source.

AxonOps: Making Cassandra Awesome

Time for a bit of shameless (but well-deserved) self-promotion. At AxonOps, we've spent the year on a mission to make Cassandra not just manageable, but actually enjoyable to work with.

Cassandra is brilliant. It really is. But historically, the tooling around it hasn't always matched that brilliance. We're changing that.

AxonOps Workbench: Free, Open Source, and Actually Useful

First up: AxonOps Workbench, our open source desktop application for Cassandra development.

The Problem We Solved

Every Cassandra developer knows the pain. You've got a cluster to explore, data to query, schema to understand. Your options used to be:

1. The command-line cqlsh (functional, but not exactly pleasant)
2. Various third-party tools (often abandoned, outdated, or just not quite right)
3. Building something yourself (nobody's got time for that)

We built Workbench because developers deserve better.

What You Get

AxonOps Workbench provides:

• A proper GUI for exploring your clusters: Connect, browse keyspaces, examine tables, understand your data model visually
• Query execution with results that make sense: Syntax highlighting, query history, exportable results
• Schema visualisation: See your data model laid out in a way that actually helps you understand relationships
• Multi-cluster support: Because nobody runs just one cluster anymore
• Cross-platform: macOS, Windows, Linux. We've got you covered

And here's the best bit: it's completely free and open source. No "free tier with limitations." No "contact sales for enterprise features." Just download it and use it.

Why open source? Because we believe that great developer tools shouldn't be gatekept. When developers have good tools, they build better applications. When they build better applications on Cassandra, the whole ecosystem benefits. Rising tide, all boats, etc.

The community response has been wonderful. Contributions coming in, feature requests that help us prioritize, and most importantly, people actually using it in their daily workflows.

Get Involved

Workbench is on GitHub. Star it, fork it, contribute to it, or just download it and make your Cassandra development life a little bit better. We're actively developing it and welcoming contributors.

CQLAI: Your AI-Powered Cassandra Copilot

2025 was the year AI became impossible to ignore, and we asked ourselves: how can we bring AI capabilities to Cassandra development in a way that's actually useful (not just buzzword-compliant)?

The answer is CQLAI.

What Is CQLAI?

CQLAI is like having a Cassandra expert sitting next to you while you work. It provides AI-powered assistance for:

• Writing CQL queries: Describe what you want, get valid CQL back
• Understanding your data model: Ask questions about your schema in natural language
• Query optimisation suggestions: "Here's why this query might be slow, and here's a better approach"
• Learning Cassandra concepts: "Explain what a partition key is like I'm five"
• Troubleshooting assistance: "Why might I be getting this error?"

The Magic of Context-Aware AI

What makes CQLAI special is that it understands your context. It's not just a generic AI that kind of knows what Cassandra is. It knows your schema, your data model, your specific situation.

Ask it "write a query to get all orders for customer X" and it will generate a query that actually works with your tables. Ask it "why is this query slow?" and it will analyse it against your data model and explain the issue.

Practical, Not Gimmicky

We were very intentional about making CQLAI practical. It's not there to show off AI capabilities; it's there to make you more productive. Every feature was added because it solves a real problem developers face.

The feedback from users has been that it actually saves them time. Less context-switching to documentation. Fewer "how do I do this again?" moments. More time actually building things.

AxonOps Platform: Enterprise-Grade Management Without the Headaches

For teams running Cassandra in production, the AxonOps Platform provides comprehensive management capabilities that take the operational burden off your shoulders.

Monitoring That Makes Sense

Cassandra exposes a lot of metrics. Like, an overwhelming amount. JMX metrics coming out of every orifice (can a database have orifices? Work with us here).

The problem isn't getting the data; it's making sense of it. Which metrics actually matter? What should you be looking at day-to-day versus during an incident? What's normal versus what's a warning sign?

AxonOps provides:

• Curated dashboards that surface the metrics that actually matter
• Intelligent aggregation across your clusters
• Historical trending so you can spot issues before they become emergencies
• Custom dashboards for when you need something specific
• At-a-glance cluster health so you can answer "is everything okay?" in seconds

Our monitoring is built by people who've operated Cassandra clusters. We know what you need to see because we've needed to see it ourselves.

Alerting for Better S/N Ratio

Nothing erodes trust in monitoring faster than alert fatigue. When your pager goes off constantly for non-issues, you start ignoring it. When you start ignoring it, you miss the real problems.

AxonOps alerting is designed to:

• Alert on things that actually need attention
• Provide context so you know what's happening and why
• Reduce noise through intelligent thresholds and deduplication
• Integrate with your existing tools: PagerDuty, Slack, email, webhooks. We play nice with everyone

Our users report dramatic reductions in alert noise after switching to AxonOps. Fewer alerts doesn't mean less visibility. It means better signal-to-noise ratio.

Backup Management: Sleep at Night Again

Backups in Cassandra are... let's say "an adventure." Snapshots, commitlog archiving, point-in-time recovery... there's a lot to coordinate, and getting it wrong can be catastrophic.

AxonOps handles:

• Automated backup scheduling: Set it and forget it (but not completely, we'll tell you if something goes wrong)
• Backup verification: Because a backup that doesn't restore isn't a backup
• Point-in-time recovery: Get back to exactly where you need to be
• Cloud storage integration: S3, GCS, Azure Blob. Your choice
• Retention policies: Manage storage costs without manual cleanup

The peace of mind alone is worth it. Knowing that your backups are happening, verified, and restorable changes how you sleep at night.

Repair Scheduling That Just Works

Repairs in Cassandra are necessary for data consistency, but scheduling them manually is a pain. Too frequent and you're wasting resources. Too infrequent and you're risking data issues. Overlap repairs and you've got a bad time.

AxonOps repair scheduling:

• Distributes repair load intelligently across your cluster
• Prevents overlap and resource contention
• Adapts to your cluster size and topology
• Tracks progress so you know where you are
• Alerts on failures so issues don't go unnoticed

Set your repair policy, and let AxonOps handle the details. Focus on the things that actually need human judgement.

Visual Cluster Topology

Sometimes you need to see what's going on, not just read metrics. AxonOps provides visual representations of your cluster topology:

• See your data centers and racks laid out clearly
• Spot imbalances in token distribution
• Identify problem nodes at a glance
• Understand data flow during operations

A picture is worth a thousand log lines.

NEW in 2025: Nodetool Scheduling & Automation

Here's something we're particularly excited about that landed this year: nodetool scheduling and automation.

The Problem With Nodetool Operations

Cassandra's nodetool is powerful but primitive. Need to run a command? SSH into a node. Need to run it on multiple nodes? SSH into multiple nodes. Need to schedule it? Set up cron jobs. Need to know what happened? Hope you logged it somewhere.

This is fine for small clusters and occasional operations. It's not fine for large deployments or regular maintenance. It doesn't scale, it's error-prone, and it's impossible to audit.

The AxonOps Solution

With AxonOps nodetool automation:

• Schedule operations from a central interface: cleanup, compact, flush, scrub — whatever you need
• Target specific nodes or roll across the cluster safely
• Set schedules (one-time, recurring, maintenance windows)
• Full execution logs: See exactly what happened, when, on which nodes
• Complete audit trails: Know who scheduled what, for compliance or just sanity
• Success/failure tracking: Get notified if something goes wrong
• Output capture: Review the nodetool output without SSHing anywhere

For teams with compliance requirements, the audit trail alone is huge. "Who ran nodetool compact on that production node?" is a question you can now answer definitively.

For operators, it means less toil. No more "I'll just SSH in and run this quick command", which inevitably gets forgotten, undocumented, and causes confusion later.

For capacity planning, seeing all your scheduled operations in one place helps you understand what's happening across your cluster estate.

This is operational maturity for Cassandra, and we're proud to offer it.

K8ssandra Integration: Cloud-Native, Meet Enterprise-Grade

The container revolution came for databases, and Cassandra embraced it. K8ssandra provides a great way to run Cassandra on Kubernetes, with operators for deployment, configuration, and basic lifecycle management.

AxonOps now integrates seamlessly with K8ssandra, bringing our full management capabilities to Kubernetes-deployed clusters:

• Same great monitoring for your Kubernetes Cassandra pods
• Same alerting that works with your existing workflows
• Same backup management adapted for the K8s environment
• Same repair scheduling that understands your topology
• NEW nodetool automation that works with your Kubernetes deployment

Running Cassandra on Kubernetes doesn't mean you have to compromise on operational tooling. AxonOps gives you the best of both worlds: cloud-native deployment with enterprise-grade management.

Why This Integration Matters

Teams moving to Kubernetes often worry about losing visibility and control. With AxonOps + K8ssandra:

• Your existing AxonOps workflows continue to work
• Your monitoring dashboards look the same
• Your on-call procedures don't need to change
• Your compliance requirements are still met

It's Kubernetes-native deployment with the operational maturity that production workloads demand.

A Festive Toast to the Cassandra Community

As we wrap up 2025 and look toward 2026, we want to raise a glass to everyone who makes the Cassandra ecosystem what it is.

To the Apache Cassandra PMC and Committers

Thank you for your tireless work stewarding this project. The countless hours spent reviewing patches, debating architecture, writing documentation, and making tough decisions. Cassandra 5.0 is a triumph, and it's because of your dedication.

To the Contributors

Every bug fix, every feature, every test case, every documentation improvement. Open source thrives because people give their time and expertise. Whether you've contributed one patch or a hundred, you've made Cassandra better.

To the Community Members

The Stack Overflow answers at midnight. The blog posts explaining complex topics. The conference talks sharing hard-won knowledge. The Slack messages helping newcomers. The community is the project's greatest asset.

To the Operators

The unsung heroes. The people who get paged at 3 AM. The ones who've developed an almost supernatural sense for when a cluster is "feeling off." You keep the world's data available, and we salute you.

To the Driver Maintainers

The client driver maintainers who make sure every language can talk to Cassandra reliably. Java, Python, Node.js, Go, and beyond. You're the bridge between applications and data.

To the Ecosystem Projects

K8ssandra, Stargate, and the constellation of projects that extend and enhance Cassandra. You make the ecosystem richer and give users more choices.

And to YOU

Yes, you, reading this blog post. Whether you're a long-time Cassandra veteran or just discovering what this database can do, you're part of this community now. Thank you for being here.

Welcome, 2026! Here's to What's Next

What a year 2025 has been.

Cassandra has definitively answered anyone who questioned whether it still had relevance. The performance improvements in 5.0 have been game-changing. The community is more vibrant than ever. The roadmap is exciting.

The database that some wrote off as "complicated" has proven that it's actually "powerful." The one they called "past its prime" is demonstrating it's just getting started. The workloads that seemed impossible are now routine.

And with AxonOps in your corner, managing it all becomes less of a chore and more of a joy. We're here to make Cassandra awesome: for developers with Workbench and CQLAI, for operators with our management platform, and for everyone who believes that great databases deserve great tooling.

So here's to 2026. May your clusters be healthy, your latencies be low, your throughput be high, and your consistency levels be exactly what you need them to be.

May your GC pauses be imperceptible, your repairs complete on schedule, and your backups restore perfectly every time you test them (you are testing them, right?).

May your schema migrations go smoothly, your queries be efficient, and your data models be elegant.

And may the distributed systems gods smile upon your workloads.

Happy New Year from all of us at AxonOps!

P.S. If you haven't tried AxonOps yet, what are you waiting for? New year, new tools, new levels of operational confidence. Start 2026 right. Your Cassandra clusters (and your on-call schedule) will thank you.

P.P.S. Seriously, download Workbench at least. It's free. It's open source. It'll make your life better. Promise.

Get Started

• AxonOps Platform: https://axonops.com | Full management and monitoring
• Apache Cassandra Documentation: https://axonops.com/docs/data-platforms/cassandra/ | Reference Documentation for Apache Cassandra
• AxonOps Workbench: https://github.com/axonops/axonops-workbench | Free, open source developer tool
• Apache Cassandra: https://cassandra.apache.org | The database that started it all
• K8ssandra: https://k8ssandra.io | Cassandra on Kubernetes done right
• Community Over Code 2025 Cassandra Track: YouTube Playlist | Watch all the talks mentioned in this post

Tags: Apache Cassandra, Cassandra 5.0, Cassandra 5.1, Cassandra 6.0, Accord, Community Over Code 2025, AxonOps, AxonOps Workbench, CQLAI, JDK 17, Shenandoah GC, Database Performance, Bloomberg, Netflix, SAI, Storage Attached Indexes, 2025 Year in Review, NoSQL, Distributed Databases, K8ssandra, Open Source

‍