What Makes TigerBeetle Worth a Look?
TigerBeetle is a replicated, highly available financial database with a fixed schema and a focus on performance, and it draws what looks like an outsized share of attention. Why all the buzz? What makes TigerBeetle interesting?
TigerBeetle: a replicated, highly available financial database with a fixed schema and a focus on performance. That more or less captures what the project is. Even so, TigerBeetle draws what looks like an outsized share of attention. Why all the buzz? What makes TigerBeetle interesting?
Let’s dig in!
TigerBeetle seen through SQL eyes
We’ll begin from a fairly conventional angle. Most readers likely have a strong SQL background, and relational databases shape how we judge other database systems (even when something is not a relational database, we call it “NoSQL”).
In contrast to a relational database, TigerBeetle’s schema is fixed and has just three “entity types”: ledgers, accounts, and transfers. Every entity type has a set number of columns, each of a set type. You can picture the schema as an ERP diagram:

The schema implements a familiar accounting concept: double-entry bookkeeping. Dating back to the Middle Ages, it rests on a simple rule: each transfer always involves two accounts, one debited and one credited. In other words, money (or whatever resource is being tracked) never vanishes and never materializes out of nowhere.
If you’ve never worked in accounting, the terms may not be very familiar. For this reason, TigerBeetle wrote a primer that brings you up to speed on accounting 101. It’s interesting and educational on its own, even if TigerBeetle itself doesn’t interest you much.
What is OLTP?
TigerBeetle presents itself as an OLTP database (online transaction processing) – a space traditionally held by SQL databases. OLTP stands in contrast to OLAP (online analytical processing, e.g., ClickHouse).
TigerBeetle, however, draws an additional distinction. On one side is OLGP (online general purpose), the category for PostgreSQL, MySQL etc.; on the other is “true” OLTP, dealing with real-time transactions, which is where TigerBeetle belongs.
Whether a database is OLGP or OLTP also shows in how it is typically used. In OLGP databases, reads usually outweigh writes. In OLTP, most of what you do is create new transfers. TigerBeetle is optimized for write-heavy workloads.
Consistency
A SQL database gives us a choice of isolation levels (repeatable read, snapshot isolation, etc.), and by picking one we implicitly decide which “phenomena” (such as phantom read, lost updates, etc.) we may run into.
TigerBeetle keeps things much simpler: you get strict serializability, with no alternatives. Transactions always run serially, one by one, and each one sees every effect of the transactions before it.
Working with data: inserting & querying
You talk to TigerBeetle not through SQL or a special query language, but through an API. Client libraries exist for the most popular programming ecosystems, and you can also simply use the bundled CLI client.
Every piece of data in TigerBeetle is immutable, so all you can do is insert (and query). There are no UPDATEs, DELETEs, or ALTER SCHEMAs, since the schema is fixed.
Inserting comes with three features that are essential for many TigerBeetle use cases.
To begin with, you can demand that an account’s balance never drops below 0. Any transfer that would break this rule gets rejected. Because transfers are applied serially to the current state, an accepted transfer means you can be sure the account balance permits it.
Next, transfers can be joined into a chain. TigerBeetle guarantees that a chain’s transfers are either all accepted or all rejected. Transfers in a chain can touch the same accounts or entirely different ones from various ledgers.
Finally, you can create “pending”, two-phase transfers that merely reserve an amount; such a transfer may carry a timer, expressed in seconds from when the reservation was made. A pending transfer can later be posted (finalized) or voided. Credit card pre-authorisations or time-limited seat reservations give a good intuition for how this works.
A key aspect of creating transfers is that every transfer has a unique ID, which the end-client should assign. The end client here means the browser or mobile app, not some intermediate API layer. Each ID should be stored (e.g., in the client’s local storage) and then reused in any retries. It acts as an idempotency key, guaranteeing you pay only once even on an unreliable network.
TigerBeetle within a bigger system
TigerBeetle aims for outstanding write performance and, as part of that, keeps “supporting” features to a minimum. What you get is a database focused on data safety (more on that below) and on writing as fast as it can, but with nothing for security or authentication; it assumes it runs in a trusted environment with trusted users.
For this reason, TigerBeetle should always sit behind a gateway of some sort. The gateway has two jobs: security and batching. First, it must ensure that every request it passes on is properly authenticated. Second, it should batch requests to get the best performance. Each client session can have only one request in flight, so while TigerBeetle works on one batch, the gateway should be collecting transfers for the next.
Although authentication belongs in the gateway, you have to make sure the gateway doesn’t turn into the system’s bottleneck. Running a SQL query to look up the user for every incoming transfer, for instance, is out of the question. Use lightweight approaches instead, such as validating a JWT token, or, if there’s really no other way, checking the user in a Redis cache.
On the read side, you can ask TigerBeetle for a particular transfer or a range of transfers, or get an account’s current balance. Anything beyond that requires building a projection, which can be hard to keep in sync by hand. Fortunately, TigerBeetle provides CDC data capture, which publishes every transfer to an AMQP queue (e.g., RabbitMQ) with at-least-once delivery.
So a reference architecture for a system in which TigerBeetle handles transactions might look like this:

On the “hot write-path”, the gateway should ideally be stateless. For everything else, it can and should rely on an OLGP database. So when a user account is created, you’d create an account with all the usual details in a SQL database, plus an account in TigerBeetle.
It may well be that every TigerBeetle deployment ought to come with a SQL database alongside it: the former takes care of high-contention writes, while the latter handles data, CRUD operations, projections, and every kind of read and query.
Use-cases
With a fixed schema, is TigerBeetle only suitable for financial applications? Not really: debits & credits can model plenty of things besides money!
Take ticket sales, which always put enormous pressure on the ticketing system for popular events (frequently bringing it down). Or rate limiting of API access.
The TigerBeetle docs include several recipes, but when you think about it, tracking credits in a serverless system, energy metering, and LLM token usage are all variations of one problem – tracking a limited resource and ensuring it never vanishes or gets fabricated. TigerBeetle’s use cases therefore reach well beyond finance.
How data replication and safety are designed
TigerBeetle is a replicated database guaranteeing that an accepted transfer is durably stored: it will never be lost (barring, of course, catastrophic data loss on every replica). At first glance, this may not seem especially new, since plenty of databases promise data safety via replication.
Yet once you dive into TigerBeetle’s design, you start to appreciate how many failure scenarios the team has considered and keeps testing the database against. They span random bit flips on disk and misdirected writes (which can apparently happen when data lands at the wrong offset), grey failures of disk & network (where everything works, only extremely slowly), right up to the sudden or gradual death of randomly selected nodes.
And looking closely at other databases, such resilience against all sorts of disasters is unmatched. We’ve progressed a lot since fsyncgate, but I doubt many other databases can claim this degree of resilience.
TigerBeetle protects data locally by storing checksums for every data block (kept apart from the data itself), organizing data as a tree, and hash-chaining everything. Hash-chaining enables quick verification of data consistency; you may recognize the idea from git or blockchain.
For safety of distributed data, TigerBeetle is a consensus-based replicated state machine. A single leader node processes all traffic, with no sharding or load-balancing. Consequently, scaling means adding faster memory or faster CPUs (“scale up”), not scaling out.
That’s intentional: the use cases TigerBeetle targets often involve data that doesn’t shard well – cases where a handful of “hot” accounts take part in most transactions. On top of that, keeping everything local makes consistency and strict serializability far easier to guarantee. What’s more, the entire TigerBeetle process runs on a single thread, using one CPU core! And it’s still blazingly fast! (Or perhaps – precisely for that reason?)

TigerBeetle recommends a 6-node deployment. That’s unusual, since the usual advice is an odd number of nodes so quorums form easily. The idea here is to spread across 3 cloud providers, located milliseconds apart, each running 2 nodes. That way, a complete outage at one provider won’t stop your system. In addition, a write quorum consists of the leader plus 2 other nodes, so as long as the leader is up, only half the nodes are needed. Electing a new leader, however, requires a majority.
Replication is synchronous, meaning that by the time you get a response, your data is guaranteed safe: written to disk and replicated across the cluster. TigerBeetle promotes aggressive batching (up to 8k transfers per request), both for requests and later during replication within the cluster.
Replication algorithm
Reading about a consensus-based replicated state machine might bring to mind algorithms such as Multi-Paxos or Raft. TigerBeetle, however, uses a different one: Viewstamped Replication (VR). It is less widely known, but it was created at the same time as Paxos, independently of it.
One could argue that all three approaches (Paxos, Raft, VR) share the same core algorithm. The devil, naturally, is in the details. Raft is the easiest to understand, but it also comes with the most constraints, particularly around unclean shutdowns and recovery. Paxos started out purely as a consensus algorithm and was later extended to multiple values as Multi Paxos, whereas VR works directly with a replicated log.
VR was probably picked over Paxos because it’s easier to implement while offering precisely the primitives the TigerBeetle team needed. It also performs better (with fewer round-trips).
Testing
TigerBeetle undergoes extensive testing using a few novel techniques.
The first is the VOPR (Viewstamped Operation Replicator), which provides Deterministic Simulation Testing (DST) for a TigerBeetle cluster. VOPR is built together with the database and runs non-stop, hunting for bugs in the codebase. When it finds one, you receive a random seed and an exact trace showing how to reproduce the issue locally.

VOPR supplies substitute implementations for every source of nondeterminism: the disk, the network, and the system clock. It can simulate a whole TigerBeetle cluster on one core and fast-forward time, squeezing what would be a month of TigerBeetle running into an hour. It can also inject all sorts of failures, such as lost messages or simulated bad sectors.
TigerBeetle has also been tested with Antithesis, a different take on DST that works at the Docker container level. Antithesis can likewise inject disk & network faults, but lacks the tight integration VOPR offers.
Lastly, Jepsen tests of TigerBeetle uncovered only two data-safety problems: missing query results and issues with a debugging API (both since fixed). The analysis points out that TigerBeetle shows exceptional resilience to disk failures. A few problems involving client or database crashes during upgrades were also found. Overall, though, comparing Jepsen’s findings across different databases, TigerBeetle’s results reflect a truly solid design.
Noteworthy engineering decisions
The team has made a great many interesting engineering decisions! TigerBeetle’s approach certainly isn’t for everyone, given how specific the use case is, but there’s always something to learn. A partial list:
- TigerBeetle is written in Zig, a systems programming language. Rust and C were both on the table, but Zig was likely chosen for its fine-grained memory control, ergonomics, lack of undefined behaviors (unlike C), and the precise feature set a low-level database project needs.
- All memory is allocated up front; nothing is allocated dynamically.
- Everything runs deterministically on a single core.
- All I/O is direct, skipping the kernel’s page caches and buffering.
- TigerBeetles keeps a “cluster clock” that guarantees timestamps always increase. If any node shows excessive time drift, that node crashes.
- The code follows Tiger style, which draws on NASA’s power-of-ten rules and aims at “getting it right the first time”. At the code level, recursion is forbidden, assertions are everywhere, only simple abstractions are permitted, methods may not exceed 70 lines, and more! At the design level, a lot of proactive thinking and research happens before any code is written.
TigerBeetle: the start of a new database generation?
TigerBeetle’s CEO and founder makes the case that two events in 2018 opened a new chapter in database development: fsyncgate (how databases deal with disk write failures and I/O buffering) and protocol-aware recovery after failures. Both influenced how TigerBeetle was designed.
He thinks we may be seeing a new kind of database emerge: one built over years rather than decades. This is made possible by advances such as DST, Direct I/O, io_uring, new systems programming languages (Zig, Rust), and explicit fault models, all of which speed up database development.
TigerBeetle may well be the lead goose of a new generation of domain-specific, blazingly fast, and durable databases.