Dashboards lie. Whatever is on screen is the world as of the last poll — the refresh button is a confession that it isn't current, and the stale row between polls is where the wrong call gets made. Retool-class tools poll. A fast poll is still a poll.
In Vantage, open screens update by themselves. When a row changes anywhere in your organisation, every screen showing it catches up within about a second — pushed straight from the source, wherever the source can push. And whichever way freshness arrives, the local cache paints the screen instantly: no spinner standing in for data you already had.
If you built the stage-1 console, you have already watched this happen — tables that just stay right. This page is what's underneath, and how far it goes.
Same feed, two dashboards🔗
One scripted feed drives both panels below, live in this page. The right panel behaves like a Vantage screen: every change is pushed and lands in under a second, on its own. The left panel is the other kind of dashboard — it updates when someone presses Refresh. That someone is you now. Keep it current. And mind the timing: for a stretch of every loop the backend throws 503s, and if your click lands there, you get what a polling dashboard gets.
The feed is scripted; the button is real. The left panel shows whatever you last fetched, and the counter keeps score of how far behind you've fallen — seconds, then minutes. The right panel just stays right: through the outage it keeps the last known state and catches up on reconnect.
Both directions🔗
A live screen you can't act from is a wall monitor. In Vantage, the same layer that streams reads carries writes — from every device at once. Below, the same order is open in two places: someone at a laptop is typing delivery notes, and a warehouse phone marks the order shipped. The status flips on the desktop within a second of the tap. The details field, mid-edit, never loses a character: fields you have touched hold, fields you haven't keep tracking upstream. And if a save fails, nothing is discarded — a draft survives a failed save.
The tap and the typing run on one scripted loop; each cycle is a new order. The push behaviour is the real thing: an action from another device updates every untouched field within a second — and never the one you're typing in.
Honest freshness, per backend🔗
"Live" is a marketing word until someone tells you the mechanism. Not every backend can push, and Vantage never pretends otherwise — every connection states exactly what it delivers, up front:
Built to ride a bad backend🔗
Push is easy on a healthy network. The Launch Control example runs against a deliberately hostile API — injected latency, random 503s — because that is what production looks like on a bad day. Its grids ride straight through: rows never blank on an error, the last known state stays on screen, and when the backend recovers, the refresh catches up. The demo above plays that behaviour on a script; Launch Control does it against a real backend you can poke.
Vantage can also stand in front of the problem. Run it as a gateway over a poorly implemented third-party API: it polls the API once, at a rate you control, and fans every change out as push to all the services and screens behind it. The flaky vendor sees one polite client instead of twenty hungry ones — your rate limit is spent once, and everything downstream still gets notifications the moment something changes.
arrow_forwardNext rung: one console is live — now wire every system and partner your business runs on into the same fabric. Wire in a real-time data mesh →