Building fast, modern applications is harder than ever. Your backend might be powerful, your UI might be beautiful—but if the data flowing between them is slow or clunky, your app feels slow.
TanStack DB changes that.
It’s a reactive, client-first data store that makes your frontend feel instant, smooth, and reliable—no matter how much data your app handles.
Why TanStack DB Exists
If you’ve built interactive apps before, you’ve probably run into familiar pain points:
You end up writing custom API endpoints for every page
Loading everything upfront makes your app slow and memory-heavy
State management gets messy, especially as your app grows
TanStack DB flips this model and gives you:
Just-in-time data loading — fetch only what’s needed, when it’s needed
Fast client-side querying — almost like having a tiny embedded database
Optimistic updates — your UI updates instantly, even on slow networks
With TanStack DB, your frontend stays fast and fluid—while your backend handles the heavy lifting behind the scenes.
How TanStack DB Makes Apps Feel Fast
At its core, TanStack DB combines a local query engine with real-time sync and optimistic updates.
Blazing-fast queries: Think sub-millisecond results, even with huge datasets
Real-time updates: UI changes the moment your data does—users never see stale views
Optimistic mutations: Edits look instant to the user, while the backend syncs in the background
It plays nicely whether you work with REST APIs, sync engines like ElectricSQL, or other data sources.
The TanStack DB Approach
Instead of “fetch everything” or “build an endpoint for every UI,” you:
Define collections: client-side sets of structured data (like a table in a database).
Run live queries: components react immediately as underlying data changes.
Make optimistic updates: UI updates before the server replies, rolling back if something fails.
Choose sync mode per collection: eager (load up front), on-demand (load as needed), or progressive (hybrid).
Key Features
Live Queries: Components subscribe to exactly the data they need, instantly re-rendering if anything changes.
Cross-collection Joins: Easily combine multiple sources, so your UI always shows up-to-date, joined data.
Local-First: Data lives client-side, so offline and near-instant interactions just work.
Example
Imagine a task app. With TanStack DB, you:
Define a “todo” collection.
Use a live query to show all incomplete tasks. Any update (even from another tab or device) instantly updates your UI.
Mark a task done? The UI updates now, and the backend call happens behind the scenes
No more manual syncing, no manual state juggling—everything feels alive by default.
const todoCollection = createCollection({
onUpdate: updateMutationFn,
})
const Todos = () => {
const { data: todos } = useLiveQuery((q) =>
q.from({ todo: todoCollection }).where(({ todo }) => todo.completed)
)
const complete = (todo) => {
todoCollection.update(todo.id, (draft) => {
draft.completed = true
})
}
return (
<ul>
{todos.map((todo) => (
<li key={todo.id} onClick={() => complete(todo)}>
{todo.text}
</li>
))}
</ul>
)
}
Using TanStack DB
TanStack DB works with:
REST APIs (via TanStack Query)
Sync Engines for real-time, distributed data (ElectricSQL, PowerSync, RxDB, more)
Local Storage for preferences or offline-only data.
Mix and match as you need—your app doesn’t care where the data comes from.
Schema: Your Data’s Safety Net
TanStack DB collections can use schemas (via Zod, Valibot, etc.) for:
Type safety (auto TypeScript inference)
Runtime validation (catch errors before bad data is stored)
Automatic defaults/transformations
This means robust, trustworthy data structures—just like a real database.
Installation
Each supported framework comes with its own package. Each framework package re-exports everything from the core @tanstack/db package.
npm install @tanstack/react-db
npm install @tanstack/vue-db
npm install @tanstack/angular-db
Check out the official docs for setup guides, tutorials, and detailed examples:
tanstack.com/db/latest/docs/installation#react
