Pinned Tweet
Excited to announce TigerBeetle's $24 million Series A.
Led by @natalievais of @sparkcapital with participation from @AmplifyPartners and @Coil.
tigerbeetle.com/blog/2024-07…
TigerBeetle retweeted
Every time I dig deep into DB's and their architectures, @TigerBeetleDB always impresses me. I bow.
TigerBeetle retweeted
3. TigerBeetle’s architecture
Read how a database designed for financial transactions approaches contention, replication, durability, and retries.
github.com/tigerbeetle/tiger…
TigerBeetle retweeted
Just use @TigerBeetleDB
System design prompt: design Stripe payments ledger.
Start with requirements:
1) Immutable, auditable history. No UPDATE in place. Every balance change is an event.
2) Correctness over latency. Strong consistency per account. Idempotent writes.
3) Queries: current balance, balance at time T, list transactions, reconciliation/export.
4) Multi-currency, fees, refunds, disputes, chargebacks, holds.
APIs + data model:
- POST /entries (idempotency_key, account_id, currency, amount, type, external_ref)
- POST /transfers (from_account, to_account, amount, currency, ref)
- GET /balance?account_id=&as_of=
Tables:
- accounts
- journal_entries(id, ts, currency, metadata, external_ref)
- entry_lines(entry_id, account_id, amount, direction, available_vs_pending)
Balance is sum(lines) grouped by account+currency. Keep derived balance snapshots for speed, but treat them as cache.
Architecture:
- Write path: API -> validator -> append-only store (SQL with constraints) -> async projector builds balance snapshots and search indexes.
- Partition by account_id so all mutations for an account serialize on one shard.
- Use unique(idempotency_key, account_id) to make retries safe.
- Every transfer is double-entry: two lines, same entry_id, commit atomically.
Scaling + tradeoffs:
- Hot accounts: shard within account by sub-ledger (available/pending) or by currency, but keep a single ordering key.
- Read performance: periodic snapshots (eg every 1k entries) + replay tail.
- Exactly-once is a trap. Build at-least-once with idempotency + reconciliation jobs.
Failure cases to discuss:
- Partial writes: enforce DB transaction for entry + lines, or nothing.
- Duplicate requests: idempotency keys must survive deploys and cache evictions.
- Clock skew: ordering is DB sequence, not client timestamps.
- Backfills and reversals: never delete. Post compensating entries.
- Projector lag: balance endpoint can serve strongly consistent (compute from source) vs fast (snapshot) with clear staleness bounds.
TigerBeetle retweeted
A neat little trick I've been using at work to write cross-platform scripts that run on Windows (PowerShell) and Linux. Stolen from @TigerBeetleDB

ALT A screenshot of the `serve.ps1` file in the `commtrace-viewer` repository, showing a commit by `0x61nas` titled “chore(wasm): init wasm support.” The 12-line script contains a POSIX shell section and a PowerShell section, both configuring a local HTTP server to serve the CommTrace Viewer WebAssembly build from `build/wasm` on port 8081 using Python's built-in HTTP server.
TigerBeetle retweeted
Talking less agents, more distributed systems. Having a blast.
Day one of distributed systems therapy (the real DST) with @jorandirkgreef and the @TigerBeetleDB team in Brazil.
Consensus, Object Storage, Deterministic Simulation Testing on the Sugarloaf.
Muito bom 🇧🇷
TigerBeetle retweeted
Just use TigerBeetle.
Replying to @0xlelouch_
Solid breakdown. 🔥
One concern from the payment backend side: concurrent withdrawals.
Imagine an account has $100. Two $80 withdrawals arrive simultaneously. Both read the same balance before the async projector catches up.
Without atomic balance checks and serialization per account, both could succeed.
I’d keep balance validation and ledger writes in the same DB transaction, with row-level locking or conditional updates.
Async projections? Great for reporting. Not for authorizing withdrawals.
How would you handle this without sacrificing throughput?
TigerBeetle retweeted
Just use TigerBeetle
System design prompt: design Stripe payments ledger.
Start with requirements:
1) Immutable, auditable history. No UPDATE in place. Every balance change is an event.
2) Correctness over latency. Strong consistency per account. Idempotent writes.
3) Queries: current balance, balance at time T, list transactions, reconciliation/export.
4) Multi-currency, fees, refunds, disputes, chargebacks, holds.
APIs + data model:
- POST /entries (idempotency_key, account_id, currency, amount, type, external_ref)
- POST /transfers (from_account, to_account, amount, currency, ref)
- GET /balance?account_id=&as_of=
Tables:
- accounts
- journal_entries(id, ts, currency, metadata, external_ref)
- entry_lines(entry_id, account_id, amount, direction, available_vs_pending)
Balance is sum(lines) grouped by account+currency. Keep derived balance snapshots for speed, but treat them as cache.
Architecture:
- Write path: API -> validator -> append-only store (SQL with constraints) -> async projector builds balance snapshots and search indexes.
- Partition by account_id so all mutations for an account serialize on one shard.
- Use unique(idempotency_key, account_id) to make retries safe.
- Every transfer is double-entry: two lines, same entry_id, commit atomically.
Scaling + tradeoffs:
- Hot accounts: shard within account by sub-ledger (available/pending) or by currency, but keep a single ordering key.
- Read performance: periodic snapshots (eg every 1k entries) + replay tail.
- Exactly-once is a trap. Build at-least-once with idempotency + reconciliation jobs.
Failure cases to discuss:
- Partial writes: enforce DB transaction for entry + lines, or nothing.
- Duplicate requests: idempotency keys must survive deploys and cache evictions.
- Clock skew: ordering is DB sequence, not client timestamps.
- Backfills and reversals: never delete. Post compensating entries.
- Projector lag: balance endpoint can serve strongly consistent (compute from source) vs fast (snapshot) with clear staleness bounds.
TigerBeetle retweeted
Just use TigerBeetle.
System design prompt: design Stripe payments ledger.
Start with requirements:
1) Immutable, auditable history. No UPDATE in place. Every balance change is an event.
2) Correctness over latency. Strong consistency per account. Idempotent writes.
3) Queries: current balance, balance at time T, list transactions, reconciliation/export.
4) Multi-currency, fees, refunds, disputes, chargebacks, holds.
APIs + data model:
- POST /entries (idempotency_key, account_id, currency, amount, type, external_ref)
- POST /transfers (from_account, to_account, amount, currency, ref)
- GET /balance?account_id=&as_of=
Tables:
- accounts
- journal_entries(id, ts, currency, metadata, external_ref)
- entry_lines(entry_id, account_id, amount, direction, available_vs_pending)
Balance is sum(lines) grouped by account+currency. Keep derived balance snapshots for speed, but treat them as cache.
Architecture:
- Write path: API -> validator -> append-only store (SQL with constraints) -> async projector builds balance snapshots and search indexes.
- Partition by account_id so all mutations for an account serialize on one shard.
- Use unique(idempotency_key, account_id) to make retries safe.
- Every transfer is double-entry: two lines, same entry_id, commit atomically.
Scaling + tradeoffs:
- Hot accounts: shard within account by sub-ledger (available/pending) or by currency, but keep a single ordering key.
- Read performance: periodic snapshots (eg every 1k entries) + replay tail.
- Exactly-once is a trap. Build at-least-once with idempotency + reconciliation jobs.
Failure cases to discuss:
- Partial writes: enforce DB transaction for entry + lines, or nothing.
- Duplicate requests: idempotency keys must survive deploys and cache evictions.
- Clock skew: ordering is DB sequence, not client timestamps.
- Backfills and reversals: never delete. Post compensating entries.
- Projector lag: balance endpoint can serve strongly consistent (compute from source) vs fast (snapshot) with clear staleness bounds.
TigerBeetle retweeted
Replying to @Jacob_Parece @gakonst
I've built a block commit protocol for a JSON parser for fuzzing via DST. Tiger style is exponentially valuable.
json-scanner-playground.fly.…
TigerBeetle retweeted
We are actively rewriting software w/ TigerStyle & DST at Tempo. This is the role I am the most excited to hire right now. Please reach out. Need someone extremely AI pilled who also gets that "correct software" is the prerequisite to hillclimbing for performance.
TigerBeetle retweeted
The way @TigerBeetleDB documented all on youtube i loved it :) building components, discussion around databases there so much more to learn form it
youtube.com/@tigerbeetledb/p…
TigerBeetle retweeted
Day one of distributed systems therapy (the real DST) with @jorandirkgreef and the @TigerBeetleDB team in Brazil.
Consensus, Object Storage, Deterministic Simulation Testing on the Sugarloaf.
Muito bom 🇧🇷
TigerBeetle retweeted
If you were building a database from scratch today instead of 30 years ago (when most of the popular ones were built), you could pick any advancements in architecture, hardware, language, or research to implement. Where would you start? amplifypartners.com/blog-pos…
TigerBeetle retweeted
A Trillion transactions
tigerbeetle.com/blog/2026-03…
TigerBeetle retweeted
A very good one from @rbatiati
tigerbeetle.com/blog/2023-09…
TigerBeetle retweeted
The Mathematics of Consensus.
tigerbeetle.com/blog/2025-11…
Definitely @TigerBeetleDB . It’s a no brainer.



















