The Instant Serverless
Backend for
Postgres rebuilt from scratch in pure Rust. A backend is a task, not a process — mint one per user, agent, test, or PR. Millions per engine, $0 when idle.
Backed by
What Trubase gives you
Every capability below is a projection of three primitives the engine has natively: the log, the timeline, and the task.
Instant Branch
A branch is a new timeline record pointing at the parent's copy-on-write pages — a metadata write. A 1TB backend branches as fast as a 1KB one.
Scale to Zero
Not "minimum instance." Zero compute when idle: tasks drop, memory reclaimed, state persists on object storage. Traffic wakes it automatically.
Time Travel
Every backend remembers its history. Query any moment. Restore by branching from the past — recovery is a metadata write, not a rebuild.
100% Postgres
The bar: your drivers, ORMs, and tools work unchanged — measured by PostgreSQL's own 200,000-test suite, with the pass rate published publicly.
Transactional Everything
Queues and streams live on the same write-ahead log. Publish an event and commit the row in one transaction.
Offline Sync
The same engine compiles to the client. Offline is a branch on the device; reconnecting is a rebase.
How it works
No provisioning, no capacity planning, no teardown project. Request a backend, get a backend — and dispose of it just as easily.
Mint
Call the API or CLI. Mint fresh, or branch from a template or any existing backend. One line — a backend appears in milliseconds.
$ trubase mint --from template-apiConnect
Connect with any PostgreSQL client, ORM, or driver. Read, write, branch, dispose — or keep it forever.
$ psql postgresql://bk_7x9k2m.trubase.dev:5432Scale
Traffic wakes backends. Silence suspends them. Branch for every user, agent, test. Millions of backends, zero idle cost.
✓ suspended — tasks dropped, state persists, $0Why it's built this way
Every line is pure, safe Rust on Tokio's async runtime. No C dependencies, no FFI. Each backend is a lightweight async task — kilobytes of state machine instead of megabytes of OS process.
Built against PostgreSQL's own 200,000-test suite, with the pass rate published as a public scoreboard. The bar: your existing queries, ORMs, drivers, and migrations work without a single change.
Not "minimum instance" — actual zero. Tasks drop, memory is reclaimed, and data persists as cold bytes on object storage. Traffic wakes backends automatically.
Data lives on S3/R2 with hot caching. Storage is virtually unlimited and costs a fraction of EBS. No more provisioning IOPS or resizing volumes.
Queues, events, streams — they live on the same WAL. One atomic commit writes a row and publishes an event.
The same engine compiles to the client. Offline writes are a branch on the device; reconnecting is a rebase. Conflict resolution is automatic.
You build. It runs.
Legacy "serverless" databases wrap the same C engine — bolting on external page services, control planes, and connection proxies. Trubase rebuilt Postgres from scratch in pure Rust. The backend lifecycle — mint, branch, suspend, wake, dispose — is built directly into the engine.
When backends are engine primitives instead of orchestration, you can have millions of them. Each one isolated, each one cheap, each one instant.
let bk = Backend::mint(template).await;
bk.serve().await
}
A backend is a task, not a process.
Legacy PostgreSQL spawns one OS process per connection — each consuming 10-30MB. Trubase backends are lightweight Tokio tasks — kilobytes of state machine. Tokio's work-stealing scheduler distributes millions across every core.
Because backends are tasks over branchable timelines, you can hand one to every user, every agent, every workflow. Copy-on-write means branching duplicates zero data.
// Not a 30MB OS process
let tasks = spawn_backends(1_000_000);
join_all(tasks).await;
One backend per everything.
Every user gets their own backend — not a row in a shared table. Every AI agent gets its own isolated backend. Every PR gets a preview. Every test suite runs in complete isolation.
None of these are features. They all fall out of the same fact: backends cost nothing to mint or dispose.
per_agent → isolated backend
per_test → isolated backend
per_pr → isolated backend
Built for the agentic era
Agents mint and dispose of state at machine speed. These are the workflows a mintable backend unlocks.
Agentic state at scale
Every AI agent invocation gets its own isolated backend — a complete Postgres universe minted as a task. Branch from a template, let it read and write freely, dispose when the task completes.
Physical tenant isolation
Every tenant gets their own backend — not a row in a shared table. No tenant_id on every query. True physical isolation by default. Millions of tenant backends, each costing $0 when idle.
Workflow rollback for free
Branch at step 1. Run your pipeline. If step 5 fails — dispose the branch, state rolls back automatically. No saga pattern. No compensation transactions.
Preview environments that just work
Every PR gets its own preview backend. Branch from production. Test migrations against real constraints. Merge or close — the backend follows the PR.
Frequently Asked Questions
No. Trubase DB is a new database engine built from scratch in pure Rust that speaks the Postgres wire protocol. The compatibility bar is 100% of Postgres's observable behavior — measured by PostgreSQL's own 200,000-test suite, with the pass rate published publicly.
In legacy Postgres, each connection spawns a heavy OS process (10-30MB each). In Trubase, each backend is a lightweight async task on Tokio's runtime — just kilobytes. You can have millions of backends where you'd previously have hundreds of connections.
Branching uses copy-on-write at the page level over object storage. When you branch, Trubase creates a new timeline pointing at the same underlying data. Nothing is copied. A 1TB backend branches in milliseconds.
It scales to true zero. The async task drops, memory is reclaimed, and data persists as cold bytes on object storage. When traffic arrives, the backend wakes automatically. $0 compute cost while idle.
That's the bar it's built against: Trubase DB speaks the standard PostgreSQL wire protocol, so any client, driver, ORM, or tool that works with Postgres connects unchanged. Compatibility is measured by Postgres's own test suite and published continuously — the claim never exceeds the number.
Trubase is currently in pre-launch. Early access is free. Pricing will be based on compute time and storage, with true $0 when idle. No minimum instances.
Ready to build?
The instant serverless backend. Mint. Branch. Sleep. Sync.
Join WaitlistFree early access · No credit card required