Your web and mobile apps are only as fast as the network between them and your backend. Every screen round-trips a database that's hundreds of milliseconds away, so lists arrive with a spinner, data goes stale the moment it lands, and every team ends up rebuilding the same caching, retry and state-sync plumbing by hand.
Vantage puts a reactive facade API in front of your data — a small service you deploy close to your users that keeps a live local copy of the data, answers reads instantly from it, and streams every change back into your app as it happens. Your frontend stops polling and starts reacting.
That live layer is Dio (the cache) and Scenery (the reactive views) — the same engine behind Vantage UI, open-source Rust with a full guide today.
Where it sits in your stack🔗
Your web & mobile app
unchanged frontend — it renders from a cache and watches for changesVantage facade API
Dio cache · Scenery views · deployed at the edge, close to your usersYour data
SQL · SurrealDB · MongoDB · REST · GraphQL — however far awayThe facade is a plain Rust service, so you run it wherever your users are — one per region, at the edge — while your database of record stays put. The distant round-trip happens once, in the background; your app talks to something milliseconds away.
What your frontend gets🔗
The screen paints from the local cache the moment it opens — no waiting on the backend for the first frame.
Every open view holds a watch connection; when data changes, the update arrives on its own — no polling loop to write.
The facade fetches details for the rows the user is actually looking at, so a million-row list stays cheap.
How the reactive layer works🔗
Each connected client opens a Scenery — a standing view onto the Dio's cache — and drives it in one repeating loop. It's the same loop whether the consumer is a desktop grid, a terminal, or a browser tab across the network.
The client declares what it shows
Open a page, and it hands the facade a viewport — "these are the rows on screen." Nothing more.
It paints instantly from cache
Rows appear straight from the Dio's local copy, with … standing in for details still pending. No frozen prompt, even on a cold start.
Hydration follows attention
The Scenery fetches details only for the viewport rows. Scroll, and the window moves with the user; off-screen rows never cost a download.
Changes stream back
Each landed value streams to the client as a watch event — the cell flips from … to a number the moment its data arrives, and every open tab stays current.
Closing the view withdraws its work
Disconnect, and the Scenery's queued fetches are dropped. A closed tab stops pulling data — the load matches what's actually being watched.
Under many viewers at once, the Dio coordinates the fetches: one flight per row. Two clients watching the same page share a single download, fanned out to both; clients on different pages interleave fairly, so neither starves behind the other's backlog.
On the wire, and in the frontend🔗
The facade answers a plain GET with a snapshot from the cache, and the same URL with ?watch=true keeps the connection open and streams changes as Kubernetes-style NDJSON — one line per change:
{"type":"ADDED", "object":{"index":3,"filename":"…","rows":null, "latest":null}}
{"type":"MODIFIED","object":{"index":3,"filename":"…","rows":143676,"latest":"20260531"}}The frontend reads that stream straight off fetch — no client library, and the rows fill themselves in:
const res = await fetch(`/api/files?offset=${offset}&limit=${LIMIT}&watch=true`)
const reader = res.body.getReader()
// …split the stream on '\n'…
const event = JSON.parse(line)
setRows(rs => ({ ...rs, [event.object.index]: event.object }))The table renders immediately, and each cell flips as its value lands. Paging away aborts the fetch, which closes the connection, which drops the Scenery server-side — the whole lifecycle, for free.
A gradual path, not a rewrite🔗
You don't cut over all at once. Stand a Vantage facade up in front of the databases you already have, move one screen onto it, and let the rest keep hitting the old backend. Migrate at your pace, then delete the legacy tier behind it — no risky big-bang.
The facade is backend-agnostic — read from one store and write through another while you migrate, without your clients noticing.
No more hand-rolled caching, retry and state-sync in the client — the facade does it once, correctly, for every screen.
High-performance modern Rust that runs on your own infrastructure — fully open-source and forever in your control.
constructionThe framework — Dio, Scenery and the watch adapter — ships open-source on crates.io with a full guide today; build the reactive facade now. Generating and hosting these facades for you — geographically distributed as a managed service — is on the roadmap.