Benchmarks · By the Numbers, OpenCypher

TETRAbase answers graph queries66x faster than Neo4j

The Linked Data Benchmark Council publishes the standard test for graph databases, the LDBC Social Network Benchmark: 21 queries over a simulated social network of people, posts and friendships. We ran it on TETRAbase and on Neo4j, the leading graph database, with the same data on the same server. TETRAbase answered all 21 queries 66 times faster on 177 million connections.

We also tested writes, and queries and writes running together. Neo4j won some of those tests, and the charts below mark each one.

  • 66x

    Faster than Neo4j

    Time to run all 21 queries on 177 million edges (SF10)

  • 13x

    Less CPU

    Processor time used by the same 21 queries

  • 10.3x

    More queries per second

    Eight clients querying at once, on 17 million edges (SF1)

  • 7.9x

    Less disk space

    Data on disk after the write tests. TETRAbase encrypts its data; Neo4j did not

  • 2.1x

    Less memory

    Peak memory while running the 21 queries on 177 million edges

  • 1.78B

    Edges queried in less time than Neo4j takes on 17 million

    TETRAbase on the largest dataset against Neo4j on the smallest

We tested TETRAbase once, on 1 November 2026. We tested Neo4j Community 5.26 on the same server in September and October. TETRAbase used no indexes and kept its data encrypted on disk.

01 · Speed at every size

TETRAbase pulls further ahead as the data grows.

LDBC publishes its data in standard sizes called scale factors. SF1 holds 17 million edges, the connections between people, posts and places; SF100 holds 1.78 billion. TETRAbase ran 29.5 times faster than Neo4j at SF1 and 66 times faster at SF10. We tested Neo4j up to SF10. TETRAbase went on to SF100 and answered all 21 queries in 11.3 seconds, less time than Neo4j took at SF1.

Dataset size 176,623,433 edges
  • 66.0x faster

    Time for all 21 queries

  • 13.0x less CPU

    Processor time

  • 2.1x less memory

    Peak memory

0.2 s1 s10 s100 s10M100M1BEdges, log scaleIf time grew with the dataTETRAbase 11.3 sNeo4j 113.7 s
TETRAbase's time grew 29 times while the data grew 103 times, from SF1 to SF100. The pale line grows in step with the data. We tested Neo4j at SF1, SF3 and SF10.

02 · Query by query

TETRAbase answered 20 of the 21 queries faster.

The 21 queries range from short lookups, such as a person's profile, to long searches through friends of friends. TETRAbase gained most on the long searches: it answered IC9, which finds recent posts by friends and friends of friends, 423 times faster. Neo4j answered one query faster at every size: IC7, which finds who recently liked a person's posts.

Dataset size TETRAbase faster on 20 of 21
  • IS1 3.8x
  • IS2 3.8x
  • IS3 3.9x
  • IS4 4.8x
  • IS5 5.5x
  • IS6 2.8x
  • IS7 1.6x
  • IC1 2.6x
  • IC2 32x
  • IC3 101x
  • IC4 11x
  • IC5 136x
  • IC6 71x
  • IC7 2.5x slower
  • IC8 4.3x
  • IC9 423x
  • IC10 10x
  • IC11 6.4x
  • IC12 28x
  • IC13 1.8x
  • IC14 9.2x

Each bar divides Neo4j's median time by TETRAbase's, on a log scale. Teal bars mark the queries TETRAbase answered faster; the grey bar marks the one Neo4j answered faster. Select a query to compare both times.

03 · Writes

TETRAbase matched or beat Neo4j on 13 of 18 kinds of write.

Both databases take writes in openCypher, the graph query language. We tested 18 kinds of write: creating records and connections, updating them, upserting (inserting or updating) and deleting. Each test wrote one row at a time, 1,000 rows from a list, or a range of 1,000 rows, first with 1 client and then with 32 clients at once. After every test we read each row back to confirm the database saved it. Neo4j created records in bulk and overwrote ranges of records far faster than TETRAbase.

Clients TETRAbase as fast or faster on 13 of 18
  • create-node.point.props 0.61x
  • create-node.point.bare 1.09x
  • create-node.block.props <0.01x
  • create-node.block.bare <0.01x
  • create-edge.point.props 1.30x
  • create-edge.point.bare 1.62x
  • create-edge.block.props 2.08x ✗
  • create-edge.block.bare 1.45x
  • update.point.blind 1.37x
  • update.point.incr 1.30x
  • update.point.row 1.29x
  • update.range.blind 0.05x
  • update.range.incr 1.47x
  • update.range.row 0.12x
  • upsert.point 1.12x
  • upsert.block 1.18x
  • delete.point 1.03x
  • delete.range 3.11x

Each bar divides TETRAbase's rows written per second by Neo4j's, on a log scale, with 200,000 rows loaded. Grey bars mark the writes Neo4j did faster. ✗ marks the test where three Neo4j writes failed with deadlocks.

04 · Reads and writes together

TETRAbase answers more queries; Neo4j writes more data.

Real applications read and write at the same time. We ran 8 clients repeating the 21 queries alongside 1, 4 or 16 clients writing, for 60 seconds each. TETRAbase answered 10.3 times as many queries as Neo4j with no writers, and 3.9 times as many with 16. Neo4j wrote about three times as much data in every test, and its queries slowed less when the writers started.

Show
  • 8 readers, no writers

  • 8 readers and 1 writer

    Queries took longer than with no writers: TETRAbase +113.1%, Neo4j +5.4%

  • 8 readers and 4 writers

    Queries took longer than with no writers: TETRAbase +147.9%, Neo4j +2.2%

  • 8 readers and 16 writers

    Queries took longer than with no writers: TETRAbase +177.2%, Neo4j +7.8%

  • 8 readers, after the writers stopped

    Queries took longer than with no writers: TETRAbase +13.0%, Neo4j +0.0%

Each figure counts complete runs of the 21 queries per second, across all 8 readers. Neither database returned a wrong answer: we checked 24,000 answers from TETRAbase and 3,750 from Neo4j.

05 · DataPower

DataPower scores the work a database does for the hardware it uses.

5 systems. Same data. Same operations. 2 CPU cores, 8 GB of memory.

How DataPower works, with all 15 test runs →

Measurements from Nov. 1, 2026. See the specs.

  • 520

    DataPower at 3 million data elements

    Quick test profile, one run per database

06 · How we tested

We ran both databases on the same server.

Both databases ran the same queries on the same data. Their setups differed in five ways, and three of those differences favoured Neo4j.

TETRAbaseNeo4j 5.26Favours
Queries and inputsSameSameNeither
Indexes for the queriesNone9 constraints and 8 indexes, the LDBC reference setupNeo4j
Constraints for the writes6 unique6 uniqueNeither
Saving writes to diskSaves every write before confirming it, and saves writes that arrive together in one stepSaves its transaction log on every writeNeither
Encryption on diskAlways onOffNeo4j
Memory settingsDefaultsTuned for each dataset sizeNeo4j
Server and clientsSame machineSame machineNeither
Test date1 November 202624 September 2026 for queries, 26 October 2026 for writesNeither
Server
AMD EPYC 7502P with 32 cores and 64 threads
Test date
1 November 2026, one run
Queries
The 21 Interactive queries of the LDBC Social Network Benchmark, unchanged, with the same inputs on both databases
Data
Five LDBC dataset sizes, SF1 to SF100, up to 282,637,871 nodes and 1,775,513,741 edges
TETRAbase
No indexes. Encrypts its data on disk and saves every write before confirming it
Neo4j
Community Edition 5.26.0 on OpenJDK 17, with the LDBC reference setup of 9 constraints and 8 indexes
Write tests
18 kinds of write with 1, 2, 4, 8, 16 and 32 clients, at 20,000, 50,000 and 200,000 rows. Each test warms up for 1 second, measures for 3, then reads every row back
Combined test
8 clients running queries alongside 0, 1, 4 or 16 clients writing, 60 seconds each

Limits of these results

  • Neo4j ran on other days. We tested Neo4j on the same server on 24 September and 26 October 2026, and kept those results.
  • Neo4j ran smaller tests. Neo4j ran the queries up to SF10, the combined read and write test at SF1, and the write tests at 200,000 rows.
  • One server. We used one server, with no cluster or replication, and ran the clients on the same machine as the database.
  • Short write tests. Each write test measured 3 seconds, too short to catch effects that build over minutes.
  • Few samples at SF100. In the combined read and write test at SF100, each query ran 2 to 6 times.
  • Medians. Each time is the median of repeated runs. A p99 time is the time that 99% of requests beat.

We share the raw results, Neo4j's stored results, the query inputs and the test harness on request.

Download the full report, 36 pages (PDF) ↓

Test TETRAbase on your own data.

A standard benchmark runs on someone else's data. Bring your own workload, and we'll compare TETRAbase with your current system.