Introducing CognoDB: The Graph Database That Doesn't Make You Choose Between Fast and Durable
— 3 min read
Same query. Same code. Ten times slower than last year.
Nobody touched your Cypher. Your graph outgrew the cache, so every hop now gambles on a disk read — and one traversal rolls those dice a few hundred times. That's why the median still looks fine while the p95 falls apart.
The standard advice is to move the whole graph into RAM. That swaps a latency problem for a capacity ceiling and a crash you can lose writes to. Fast, or safe — pick one.
But in-memory engines aren't fast because RAM is magic. They're fast because they never miss cache. And that bet can be won on disk instead: halve what a graph costs to store, and you double how much of it sits in cache.
So the real question was never how much RAM you can buy. It's how small a graph can get on disk — and that's where CognoDB comes into the picture.
What Is CognoDB?
It's a graph database for connected data — accounts, devices, products, transactions and the relationships between them. It speaks Cypher over the Bolt protocol, the same query language and wire protocol as Neo4j, so existing drivers connect unmodified and there's nothing to rewrite. And it holds that graph, durably on disk, at roughly 70 bytes per edge.
That footprint is the whole design. Small enough that your working set stays inside the page cache as the graph grows, so the misses that were wrecking your p95 mostly stop happening. And because every byte is still on disk, a crash costs you nothing — you stop choosing between fast and safe.
An in-memory mode ships too, for the cases where you genuinely do want to trade safety for raw speed: caches, dev environments, ephemeral pipelines.
Why Use CognoDB? The Numbers, Not the Adjectives
An independent benchmark ran CognoDB against Neo4j, Memgraph and FalkorDB — the same Cypher statements over the same Bolt protocol, on identical hardware. No cherry-picked queries.
| Metric | CognoDB | Best of the rest |
|---|---|---|
| 2-hop traversal latency (p95) | 0.33 ms | Memgraph: 0.41 ms (in-memory) |
| Read throughput | 74,018 QPS | CognoDB's own in-memory mode: 59,601 QPS |
| Disk footprint | ~70 bytes/edge | Neo4j: ~642 bytes/edge (≈9× larger) |
| Durability | Disk-native by default | Memgraph & FalkorDB: at risk on crash |
The second row is the one to sit with. The fastest configuration in the test is the durable, disk-backed one — it beats CognoDB's own in-memory mode. That's the compactness argument turning up in the measurement, not a tuning fluke.
And the honest limit: if your graph fits in RAM forever, a pure in-memory engine will out-ingest it. CognoDB is built for graphs that keep growing — where a capacity ceiling eventually forces a migration you'd rather not schedule.
Built for the Graphs That Actually Matter to You
Three symptoms say this is already costing you:
- p95 drifting while p50 holds steady — the cache-miss signature, and it worsens on its own.
- Sizing machines around your graph instead of your traffic — a ceiling with a date on it.
- A store far larger than the data it represents — every multiple of footprint is cache you're not getting.
If that sounds familiar, it's usually because multi-hop traversal is your hot path: rings of connected accounts and devices in fraud and risk, friend-of-a-friend queries in recommendations, entities and facts behind AI retrieval, inherited permissions in identity and access, a part traced through every hop of a supply chain.
Try CognoDB Today
Load a slice of your real data, run the traversal that's been bothering you, and look at the tail. That's the only benchmark that settles anything.
→ https://cognodb.com/ — spin up an instance in minutes, no credit card required.
