CognoDB Benchmarks: How Its New ALSG-D Engine Outruns Badger and Neo4j on Real Graph Workloads

Most database benchmarks compare apples to oranges — different drivers, different durability guarantees, different query paths. The CognoDB team took a stricter approach: every engine in these tests was driven over the same Bolt wire protocol, with the same driver, the same Cypher statements, the same batch sizes, and the same seeded workload. The only variable is the storage engine underneath.

The results make a strong case that CognoDB's new ALSG-D engine is currently one of the fastest ways to store and traverse a real-world graph.

The headline numbers: real Pokec graph, single writer

The first test loads the full soc-Pokec social network — 1.6 million nodes and 30.6 million directed edges — through a single Bolt session, comparing ALSG-D against a Badger (LSM) backend at identical durability settings, on the same machine, back to back.

Why the gap? Each edge insert needs two node lookups plus a duplicate check. On an LSM store, every one of those is a point read — block decompression, record deserialization, cache misses. ALSG-D instead resolves endpoints through an id-index and appends to a sharded in-RAM delta layered over a memory-mapped CSR base. Traversals become lock-free array walks at roughly 121 nanoseconds per hop, which is where the 10.7x tail-latency win comes from.

Notably, a single writer is ALSG-D's weakest configuration — there is no group-commit amortization at one session. Under 40 concurrent sessions the edge-ingest gap widens from 3.8x to 5.3x.

Five engines, one protocol

A second benchmark round put five configurations through identical ingestion, traversal, and serving workloads on 1M Pokec edges: ALSG-D in both durability postures, a pure in-memory store, the Badger backend, and a fairly provisioned Neo4j 5.26 (8 GB heap, 4 GB page cache, fresh store).

Three findings stand out:

1. ALSG-D in bulk posture beats everything — including the pure in-memory store. A disk-backed engine outrunning a hash-map store on every axis validates the packed-CSR layout thesis.
2. In the durable, apples-to-apples comparison against Neo4j, reads aren't close. ALSG-D wins 2-hop p95 by 6.5x (0.319 ms vs 2.087 ms) and expand-2 p95 by 2.8x. Durability costs reads nothing, because reads never touch the commit path.
3. Durable ingest is a tie (+7% to +20% for ALSG-D) — on spinning-disk hardware with ~130 ms fsyncs, both engines are disk-bound, not engine-bound.

The honest caveat

One axis went the other way: on durable mixed serving throughput with 40 concurrent clients, Neo4j's mature group commit won 2,043 QPS to 1,397. CognoDB's team names it plainly — concurrent durable writes on slow-fsync hardware are Neo4j's remaining stronghold, and commit pipelining is the top item on the roadmap to close it. Benchmarks that admit a loss are the ones worth trusting on the wins.

What it means in practice

For bulk loads, event-stream ingestion, and read-heavy serving — which describes most production graph workloads — the data points one way: CognoDB's ALSG-D engine is the fastest configuration tested on ingest, traversal latency, and storage footprint, often by multiples rather than percentages. A read-heavy service pays almost nothing for full durability, since sync and nosync postures deliver the identical 0.119 ms 2-hop median.

Fast where it matters, honest where it isn't yet — that's a benchmark report worth reading, and an engine worth watching.