It doesn't mean one write per fsync, and it doesn't mean readers wait. Readers never block writers in RushDB, because every query reads a pinned MVCC snapshot, and reads scale with cores. The single thing is the write path:
admission -> plan -> expand -> enqueue -> publish (derive -> WAL append + one fsync -> apply) -> ack
A writer takes the admission lock, plans its commit, and releases the lock before it waits for disk. The next writer plans right away, against an overlay that already contains the previous commit, even though that one isn't durable yet. Then whoever holds the publish lock drains every waiting commit as one group and fsyncs once for all of them. That's how ten commits share one fsync, so the line moves in groups. The write path docs have the full sequence.
Because of the catalog. The whole point of RushDB is that the database knows exactly what's in it: which labels, which properties, which types, which values, how many records carry each one, which relationships connect what. An agent reads that before it writes a query. If the numbers are approximately right, the agent is approximately right, and that's not a product.
Every commit updates those numbers. A pure function (no clock, no randomness, no global state) derives counters, value dictionaries and presence rows from each commit against the state right before it, and they're written in the same batch as the data. So commit N + 1 has to see what commit N did: does this property definition exist already, which ordinal is next, does this tenant exist. Planning is serialized because the catalog is a function of the order.
With one writer, a lot of hard stuff just isn't there:
- The catalog is exact at every snapshot.
- Commit indexes are dense, and the WAL position equals the commit index. Replay, point-in-time restore and replicas re-run the same derive function and land on identical bytes.
- No deadlock detection, because there are no locks to deadlock on. Native autocommit writes never fail with
write_conflict; they plan under admission.
- Two writes that bump the same counter never conflict, because derived rows aren't in anybody's write set.
With many writers you can have all of this too, IMO, but you pay in a different currency, like merge logic for counters, conflict retries, a consensus on order somewhere. Memgraph's post says it honestly. Transactions that touch the same node or relationship can still collide, and the client retries. For their workload that's the right trade. For a database whose job is exact counts, I didn't want the catalog to be the thing that retries.
Measured on one node (i9-12900H laptop, 20 threads, LUKS NVMe, Linux, October 2026, on storage format v5; 3.0 writes format 6), from our capacity planning runs, by number of concurrent writers:
| Writers | Single-record commits/s, 1 tenant | 50 tenants |
|---|
| 1 | 114 | 117 |
| 8 | 476 | 452 |
| 32 | 1,015 | 893 |
| 128 | 1,022 | 823 |
It flattens around 1,000 commits/s from 32 writers on. Each publish group of ~10 commits spends 6.6 ms in WAL append + fsync, 2.7 ms applying (3.7–5.0 ms over 50 tenants) and 0.5 ms deriving, one group after another. More writers after 32 don't help. That's literally the bottleneck from the Memgraph post, measured on our own engine.
Now batch. Eight writers sending 500 documents per commit: 12,600 records/s, batch p99 1.3 s. Same publisher, same fsync, same derive. Each commit pays the line once, however many records it carries.
So the deal is ~1,000 independent durable commits a second with 32 writers, or ~12× that in records if you batch.
We looked at the obvious fix, per-tenant sequencers. They'd still share one WAL and one publisher, so they can't raise the ceiling. On 2026-10-11 we wrote it down as a decision to accept it and batch. We reopen it only if a production workload needs more than ~1K independent durable single-record commits a second on one node. The levers are known (adaptive group size first, then overlapping one group's fsync with the next group's apply), they're just not worth the complexity yet.
I won't pretend the line is free. The worst case we found was one tenant bulk-loading 10M records while 50 light tenants commit single records. The light tenants' p99 went from 221 ms to 12 s, with a 62 s max. A one-record save waited behind everything the bulk tenant had queued. That's the single-writer argument in one number, and it came from our own harness.
We added a per-tenant bulk share in the scheduler (one tenant gets at most two ingest commits in the line while others wait), copy-on-write off on the data directory (the checkpoint fsync on btrfs was holding the writer for up to ~17 s), and history cleanup batches capped at 100 ms of work.
After that, beside a 2M bulk load running at 4,421 records/s, light tenants' p99 was 1.03 s (max 1.26 s). Beside the full 10M bulk load it came down from 12 s to about 2.0–2.4 s. Single runs on this laptop vary about 2×, so read those as "a second or two", not as a promise.
What's left is queueing. The publisher is ~98% busy during a bulk load, so a light commit still waits for the groups ahead of it. A fair publish queue (fill each group round-robin across tenants) would cut that wait to about one group. It's designed but not shipped, still cooking.
The other cost is about how you write code against it. A loop that saves one record per request gets 114 commits/s from one writer, and even 32 concurrent writers top out around 1,000/s. Batch writes, use multi-record transactions, or let the ingest endpoint take a whole document with its nested children as one commit. The 3.0 release notes and the capacity envelope have the rest of the numbers.
If your workload is thousands of independent, durable, single-event writes per second on one node, and you can't batch them, RushDB 3 is not your database. Telemetry firehoses, high-rate time series, a fraud graph that has to absorb every card swipe as its own transaction the moment it happens. We'd be the bottleneck, and no setting changes that.
For those, use something built for it. Memgraph's in-memory engine with fine-grained locking and streaming ingestion is a real option for live graphs. For time series at very high write rates, InfluxDB or TimescaleDB; for ledgers and inventory, Postgres or CockroachDB (our is RushDB right for me? page has the full list). Or put a log like Kafka in front and write to RushDB in batches, if what you need from us is the exact catalog and the queries on top, not per-event latency.
The most deployed database in the world has one writer. SQLite's docs say it in one line: "since there is only one WAL file, there can only be one writer at a time" (SQLite WAL). Nobody thinks that makes it a toy. It makes it simple to reason about, and simplicity is what you want under something that has to be correct.
RushDB is for agents and apps that need to know exactly what's in their data: write JSON -> linked records + exact catalog -> query with whatever language fits. Those workloads write in batches far more often than they write one event at a time. Agent memory is a burst per conversation turn. An import is a batch by nature. Sync jobs are batches.
For that shape, one line with group commit is enough, and it buys an exact catalog, identical replicas and no deadlocks. For a firehose, it's the wrong trade, and I'd rather say that here than have you find out in production.