Every tab. Every refresh. Every session.
The browser can hold your application data, but most apps never let it. Each tab, refresh and session asks your server for data the browser had moments ago, and a dropped connection leaves your users with nothing to work with.
Local-first changes that. The browser keeps the data, and every tab shares it. An update in one tab shows up in the others at once, and changes made offline wait until the connection returns. Your server only moves when something actually changes.
Once your application loads the initial data envelope, Flux pre populates your local stores directly from disk before components even mount. Enjoy zero layout shifts and zero spinners on any return visit.
Tabs talk to each other with signals. An update made in one tab shows up in every other open tab immediately, with no refresh. A single elected tab makes the network request while the rest hydrate from local data, so ten tabs open still means one server hit.
When a disconnected browser returns online, the leader tab passes sync anchors to the adapter. Your server streams only the changes missed during the gap instead of running a heavy, full database re bootstrap.
Edits made offline flow through a resilient three layer fallback pipeline. Your data stays safe through unexpected tab closures, mobile browser crashes, and aggressive OS sleep cycles.
If a record changes on the server while a user edits it offline, a precise two pass handshake traps the collision before touching your ledger. Resolve conflicts cleanly on your own terms.
Enforce firm data boundaries on shared public machines. Private data channels, cache nodes, and queued mutations are scoped per authenticated identity and scrubbed the moment a user logs out.
Flux handles the complex web primitives behind the scenes: the background Service Worker layer, namespaced local cache lifecycles, and predictive asset warming. When a page mounts, data chunks arrive in a single bootstrap request so requests never stack up.
The one step left on your side is static: provide a standard manifest.json with your application identity and icons.
When the app keeps its data locally, tabs and return visits stop asking your server for what it already sent. Less load on your infrastructure, your database connections and your serverless functions follows from that.
Flux serves repeat reads from local data and lets one elected tab fetch for all the others, so duplicate requests never reach your gateway.
Illustrative model: assumes 15 reads per user per day without Flux and 1 with it. Your numbers will vary.
Every registered store reads its IndexedDB envelope in parallel before any component mounts — a 2000ms hard timeout guarantees the app never blocks on cache.
'user'-scoped stores resolve to keys namespaced per tenant in IndexedDB, structurally separate from global data — cleared on logout, self-healed on next boot.
One leader tab fires one network request per scope. Follower tabs hydrate from disk instead of duplicating the fetch.
Reconnects stream only what changed while offline, using per-channel sync anchors — never a full re-fetch of the dataset.
| Architectural Feature | Fetching Library | Persist Only | SW Toolkit | Sync Service | Flux Engine |
|---|---|---|---|---|---|
| Leader Election (Cross Tab Bootstrap) | Partial | ||||
| Live Cross Tab Updates (Signals, No Refresh) | Partial | Partial | |||
| Realtime Leader Delegation (1 Socket Across Tabs) | |||||
| Mutation Pipeline (Debounce and Coalesce) | Partial | ||||
| Two Pass Handshake Conflict Detection | Partial | ||||
| Universal Conflict Clearinghouse Register | |||||
| Dual Transport Job Tracker System | Partial | ||||
| Safari Blob Eviction URL Recovery | Partial | ||||
| Dynamic Route Offline Virtualization | Partial | ||||
| Per Channel Sync Anchors (Delta Only Reconnect) | Partial | ||||
| Multi Tenant Session Isolation (Structural + Boot Sweep) | |||||
| Database Agnostic Client Integration |
Flux doesn't replace Redis for distributed locks, server-side job queues, or server-side sessions. Those stay on your backend exactly as they are today.
The Mutation Pipeline shapes and conditions client-side traffic before it leaves the device, deduplicating spam clicks, coalescing rapid edits. It doesn't stop a direct API call from Postman or curl. Rate limiting and DDoS protection stay server-side.
Flux runs entirely in the browser. It has no role in how your own backend services talk to each other, and makes no server-to-server calls on your behalf.
Wire transfers and direct debits must stay synchronous and server authoritative , never queued. The offline queue is for UI-layer mutations like preference changes, profile edits, and KYC updates, not ledger transactions.
Flux isolates the client-side cache by userId once an identity exists, it never establishes that identity. Session and auth validation remain entirely server-side.
Every tier ships the same offline-resilient core. Start free, stay free on localhost and preview deployments, and pay only once you're shipping features to production.
Core IndexedDB engine, SNAPSHOT/COLLECTION_ALL caching, and the offline write queue, production-ready from day one.
The full mutation pipeline, conflict resolution, and complete multi-tenant session security, everything Flux does, on a single production domain.
Same engine as Starter, unlocked across multiple production domains with 5x the event quota, for teams running more than one app off one key.
Everything in Pro, uncapped, for teams running at scale.
Free on localhost and preview deployments (*.vercel.app, *.netlify.app, *.pages.dev) — no console watermark in any dev environment.
Add the core engine, the Next.js plugin, and a realtime adapter to your workspace dependencies.
Wrap your existing Next.js config to inject the service worker and pre-warm dynamic route chunks.
Mount FluxProvider around your app to run hydrate() and register the service worker on boot.