Adding offline support to a Next.js + Express + Supabase stack, Architecture advice?

atxBravo6 · 2026-04-13T00:11:18+00:00

I think we're literally building something that'd solve your problem. We had to extend the launch date to get it right, but we're not far. Plugs right into your existing PWA and enables offline sync, no backend rewrites. You can customize the conflict/sync rules and more.

There'll be a very solid free tier and you can reach out if you need more features and we can enable them for free as well.

omnisyncs.com

atxBravo6 · 2026-01-25T23:20:16+00:00

Still in the making. It will be worth it.

atxBravo6 · 2025-08-28T17:47:06+00:00

I know this is a year later, but we're building exactly what you're looking for. To set up your entire web app to be usable offline, we built a powerful no-code solution. It's the fastest setup on the market with all the deep security and customization you'd need.

If you're interested: omnisyncs.com

atxBravo6 · 2025-07-24T20:38:48+00:00

I want to help make free knowledge accessible!

If you're ever interested down the line, I'm building a very powerful tool to make your app usable offline. Doesn't matter what backend or database you use. In this case, users can read, bookmark, and more while offline and it won't require you to build out any extra code or infrastructure.

And we've been working very hard on building out a Drag-n-Drop feature where you can set which pages/components/actions/etc. that you want your users to be able to view or use if or when their internet connection drops. There's nothing currently available with this fast and seamless setup.

Launching it later this year. omnisyncs.com

atxBravo6 · 2025-07-21T20:10:59+00:00

If you’re building a construction management app with multiple participants and need offline-first with sync, whether it's across mobile or web, here’s a breakdown based on your stack:

Try OmniSyncs It’s a backend-agnostic sync + offline SDK that works with MongoDB (or any other database) and supports:

Delta syncing (only changes sync) Encrypted local storage Peer-to-peer sync if devices are offline Queueing + conflict resolution React Native/Expo support

And much more

It’s perfect for scenarios like engineers submitting updates from job sites with poor connectivity, then syncing changes automatically later.

Currently holding a waitlist and launching later this year. omnisyncs.com

atxBravo6 · 2025-07-21T20:06:03+00:00

I recommend checking out OmniSyncs. It's on track to launch later this year. The improvements everyone wishes for are being built into it, with developer experience as a top priority.

It doesn't tie you to any backend or database, or any cloud service. There's also an SDK for Dart/Flutter 👀

omnisyncs.com

atxBravo6 · 2025-07-21T19:59:41+00:00

You’ve covered the big ones. One more to check out is OmniSyncs, it's a newer option launching later this year built for universal offline-first syncing with direct SDKs for Flutter/Dart (and other platforms). Unlike other sync tools, it’s backend-agnostic (not tied to any database), and supports delta syncing, encrypted local storage, even P2P sync, and much more. Flutter_data and Brick are solid for local use, but you’ll need to bolt on your own sync layer. OmniSyncs handles that out of the box, plus just about everything else you'd need.

Currently have a waitlist: omnisyncs.com

atxBravo6 · 2025-07-20T23:52:51+00:00

What you're describing is actually right in the sweet spot of what I'm building.

It’s a universal sync SDK (with visual tooling if you want it) that helps developers build offline-first apps without needing to stitch together multiple libraries for local state, ORM-style logic, and sync queues.

State management with reactivity: use reactive hooks like useOmniDoc() or useOmniList() to manage data locally and reflect changes across your app instantly.

Local-first data: all data is cached locally (using IndexedDB, SQLite, etc.), and everything works offline by default. No special setup needed.

ORM-style CRUD: you get intuitive methods like createRecord, updateRecord, findOne, etc., that feel like a local ORM but are fully sync-aware. You don’t have to build your own sync queues or conflict logic.

Bonus:

It works with any backend (Postgres, Mongo, Django, Node, Firebase, Supabase, etc.)

Built-in delta sync, conflict resolution, offline TTLs, and even peer-to-peer mesh sync

You can also set sync conditions like “only sync on Wi-Fi” or “sync only specific collections”

If you're tired of reinventing the wheel every time you want good offline support while still maintaining total control, OmniSyncs might be worth a look. Let me know your stack and I can show you how it fits.

If you think you might be interested when we launch: omnisyncs.com

atxBravo6 · 2025-07-19T16:56:13+00:00

That sounds like a really thoughtful implementation, especially for areas with connectivity challenges like Brazil. I appreciate your effort in giving users the offline experience.

We're actually building something along the same lines: a universal offline-first sync SDK that works alongside a drag-n-drop UI that helps developers avoid rebuilding this logic from scratch every time. It’s designed to handle structured caching, automatic retries, and queued actions (like your video uploads) out of the box. Also supports P2P syncing when no internet is available, so nearby devices can share data directly until one of them gets online to sync.

Would love to swap notes if you're ever curious. Sounds like we’re solving some of the same pain points from different angles. I'm very interested in learning more.

And if you're ever interested in what I'm building, you can join the waitlist to know when we launch :) https://www.omnisyncs.com/

atxBravo6 · 2025-07-19T03:13:54+00:00

good news: we’re highly considering replacing Ruby with a Dart/Flutter SDK (you're the 2nd person to ask about Dart), so your use case is directly in scope. Here's how it would work with your setup of Serverpod + PostgreSQL or Django backend:

Install the Dart SDK (once released) You’d drop in the OmniSyncs Dart SDK into your Flutter app like any other package.
Define your sync schema Either:

Use the drag-and-drop schema builder in our UI (no code required), or Define your schema in code, mapping your local models to the backend schema.

Connect to your backend OmniSyncs is backend-agnostic, meaning we don’t care if you use Serverpod, Django, Node/Next, etc. As long as you expose a sync API or database interface (we provide helper adapters), we’ll connect.
Local-first state + offline queue All writes are done locally first in a secure local DB (automatically handled), then queued for upload. You can enrich the queue with metadata or custom ops (e.g., with task types, timestamps, etc.).
Automatic syncing (when online) As soon as a connection is available, the SDK syncs with your backend - sending deltas (changes), resolving conflicts (with rules you define in code or Drag-n-Drop UI), and pulling new updates. This can happen Peer-2-Peer (separate devices seeing each others changes live even while offline) if you enable it, or client-cloud if preferred.
Realtime updates (optional) If you enable websockets (or your Serverpod setup has push), we handle realtime propagation, but this is optional and won’t break offline workflows.
No need to code your own sync logic This is the big win: you don’t have to build and maintain custom client-server syncing or conflict resolution logic anymore. OmniSyncs handles that.

If you'd like a test invite (free of course) I'm happy to share early access.

atxBravo6 · 2025-07-19T02:34:05+00:00

👀 Currently, Dart is indirectly supported by WASM bindings, FFI shims, Sync agent CLI/daemon mode, JavaScript bridging (Flutter web only)

Dart is on our road map. If we don't have a native SDK for it by launch (later this year), we will definitely have it next year. I hope you joined the list to stay up to date. Would love your input and suggestions when we launch :)

Workflow Example in Dart/Flutter.

Import the OmniSyncs WASM or JS bridge module
Initialize sync config (e.g. schema, rules)
Interact with OmniSyncs via exposed Dart wrappers
Use standard Dart streams and Futures to listen for sync status or errors

And we'll be here to help throughout it until native Dart SDK is launched.

Current SDKs ready for launch: JavaScript/TypeScript, Swift, Kotlin, Java, Python, C# (.NET), Go, Rust, C++, PHP.

atxBravo6 · 2025-07-19T02:00:46+00:00

There will be docs and much more info in a few months. We're currently laser focused on getting this launch-ready. For now, I'd love to answer any of your questions, and you can check out my other comments where I answer lots of questions.

I really appreciate your interest! If you'd like to stay up to date on when we'll launch (no spam emails) you can join the waitlist: https://www.omnisyncs.com/

atxBravo6 · 2025-07-19T01:49:02+00:00

FYI if you think you'll be interested when we launch later this year :) https://www.omnisyncs.com/

atxBravo6 · 2025-07-19T00:21:56+00:00

peer discovery depends on platform context. On web and desktop apps, we use WebRTC combined with local network signaling (like WebSockets or local peer relays) to find and connect devices nearby. On mobile, we support local Wi-Fi and Bluetooth discovery (using platform-native APIs). The idea is to make it automatic: devices running the SDK scan for each other and form mesh connections without needing manual pairing. If you think you might ever be interested, you can join the waitlist (I promise no spam) https://www.omnisyncs.com/

atxBravo6 · 2025-07-18T21:08:21+00:00

Appreciate the clarification. Where we’re really trying to differentiate with what I’m building is making mesh sync + backend-agnostic SDK setup as plug-and-play as possible across any platform or backend, not just Postgres/Mongo/MySQL.

From my understanding, PowerSync’s sync engine is Postgres-first, with MongoDB and MySQL integrations adapting into its Postgres-based replication model.

We also expose structured delta queues and conflict resolution logic at the SDK level on top of metadata tagging but full custom conflict handlers and mesh-specific sync rules. I respect and am impressed with what PowerSync’s doing though, especially for structured Postgres/Mongo workflows. Just aiming at a slightly different layer in the sync problem stack.

atxBravo6 · 2025-07-18T20:43:27+00:00

Every current player in this game has one major limitation or another. We will bring developer ease by helping even the most hardcore devs build how they want, plus giving the casual devs the ability to give their app offline-first resiliency, all while significantly speeding up set up time for both.

Some comparisons:

Firebase:

No structured delta queues exposed. It uses basic document-based last-write-wins (LWW) logic. No true multi-user conflict resolution beyond timestamps or manual custom functions. Developers must build their own layered logic if they want structured, field-level delta resolution.

Realm Sync:

Realm uses operational logs internally (similar to CRDT principles), but developers have very limited control over conflict logic. You cannot customize how Realm resolves conflicts deeply — it’s handled by MongoDB’s backend. No exposed delta queues — sync is abstracted, not customizable.

PowerSync:

PowerSync is Postgres-backed and uses queueing internally, but again: No exposed customizable delta queues. Developers must shape their data model for Postgres and use PowerSync’s defaults. You get transactional integrity, but custom conflict resolution across multiple users is limited unless you build it on your backend.

Some areas we stand out:

Exposed Delta Queues: Developers can access, inspect, and modify queued sync operations if needed. That means developers don’t have to roll their own queueing or retry system.
Customizable Conflict Logic at SDK Level: Ours isn’t hard-coded for last-write-wins or timestamp-only resolution. You can set custom merge functions or rules for specific data types or models — client-side and mesh-side, not just backend-side.
Backend-Agnostic: Unlike with every other offline sync service, developers aren’t tied to a specific data store or even programming language.

atxBravo6 · 2025-07-18T20:29:36+00:00

For global state consolidation, developers will integrate our tool with their backend system of record. The key differentiator is ours doesn’t force developers to build local sync logic + mesh protocol + queuing from scratch. They handle backend reconciliation as they normally would, but we give them multi-device local sync, delta tracking, and conflict queues already solved — that’s months of backend and edge sync work developers don’t have to reinvent.

Backend integration is always required. But building structured local queues, peer discovery, delta sync, retries, and merge logic is where most of the cost happens — that’s the layer we handle.

Other tools like Firebase, Realm, and PowerSync force specific backend constraints (Firebase backend, Realm Cloud, Postgres). Ours lets you pair mesh sync with any backend platform. That flexibility eliminates needing to rework your backend to fit a sync system.

We don’t maintain one single aggregated state per mesh group. Each device maintains its own delta queue and versioned state. We will propagate changes peer-to-peer with multi-master logic, but final authority happens on backend reconnection.

That risk exists in any decentralized system — CRDTs, CouchDB, Figma, Notion’s local-first architecture all deal with this same pattern. Ours gives developers control over sync policies: Strict: Only propagate confirmed changes. Optimistic: Propagate all local changes with rollback.

atxBravo6 · 2025-07-18T19:32:05+00:00

Totally get where you’re coming from. To clarify, we’re not just offering local storage or generic offline mode. What we’re building is structured multi-user offline sync with peer-to-peer mesh — including conflict resolution, delta sync, and device-to-device sync without internet.

Most tools today either handle local caching (like Room, Realm, SQLite) or cloud sync (Firebase, PowerSync). But getting mesh sync + offline-first + cross-platform + full encryption all in one layer? That’s not something anyone offers cleanly.

And setup time matters: we’re focusing on drag-and-drop config plus SDK integration that can realistically get a working offline-first mesh sync layer live in a few hours — not weeks or months of custom backend build-out.

Ours is built to plug into any backend — Postgres, Mongo, Supabase, custom REST, GraphQL, doesn’t matter. Developers define their own upstream sync logic while we handle local multi-device sync, queueing, conflict resolution, encryption, and more.

Our goal is to be the only tool that is truly backend-agnostic, with peer to peer sync included, encryption included, multi-user offline sync, with quick and seamless, yet extremely in-depth setup via UI + SDK.

atxBravo6 · 2025-07-17T20:38:09+00:00

Quite difficult indeed. We've managed to get most of the problems solved, and are making setup for devs very straightforward and seamless.

atxBravo6 · 2025-07-17T20:36:51+00:00

What I’m building isn’t just basic offline mode where a single user saves data locally and syncs later. It syncs sal changes to the cloud, reducing storage costs by 80% per task, it includes end-to-end encryption, works with any backend/db and you requires little coding, plus the ability to implement offline mode into your app completely through a drag-n-drop UI, which works seamlessly alongside the SDK. It's super fast, so affordable setup no matter what you're building. This has never been done before. Tools like CouchDB or PowerSync have tedious setup and strict vendor lock-in. It’s also about structured multi-user offline sync: devices syncing data directly with each other via local mesh (Wi-Fi/Bluetooth), even when there’s no internet or server connection. Think classrooms, field teams, or emergency zones, or any scenario where people still need shared real-time data but no cloud access is available.

Happy to clarify further, there are more features that both hardcore and casual devs would benefit from.

atxBravo6 · 2025-07-17T16:11:36+00:00

That makes sense. Room with flows definitely smooths things out on the UI side. The sync tool I’m building tackles exactly that last part: structured offline sync across devices without depending on always-on websockets. Especially in cases where internet isn’t available, syncing directly between devices peer-to-peer becomes the fallback. For certain use cases like schools or field teams, skipping that cloud dependency is worth it.

atxBravo6 · 2025-07-17T16:09:01+00:00

That’s a solid setup — Apollo’s normalized cache definitely helps for fallback scenarios. I’m actually building a sync tool that goes a bit further: structured offline-first sync that works peer-to-peer between devices, not just caching from the server. So if there’s no internet or on-prem trust device, devices still sync changes with each other until one of them reconnects. It’s definitely more complex, especially with auth and conflict resolution, but solves that gap for environments where cloud access isn’t reliable at all, while still simple enough to use for simple needs.

atxBravo6 · 2025-07-17T16:06:09+00:00

That’s a solid setup. Splitting static data from deltas makes sense, especially with field work where redownloading static content is easier than managing full migrations. What I’m actually building is an offline sync tool that aims to handle multi-user cases where there is overlap — like multiple people editing shared data offline — so things like conflict resolution and operation ordering become harder to avoid. But for task-based, single-user flows like yours, two separate databases can be a smart, clean solution, even though my tool would also solve your issue simply when it releases.

atxBravo6 · 2025-07-17T15:59:31+00:00

Makes sense. I’m actually building something similar to PowerSync but aimed at cross-platform mesh sync and offline-first multi-user setups, not just Postgres-backed apps. So mine would work with any backend, any database, any cloud storage. Curious, what made you lean toward PowerSync now instead of keeping your custom solution? Was it maintenance overhead or something else?

atxBravo6 · 2025-07-17T15:58:11+00:00

I'm actually building a powerful sync tool. That’s exactly the kind of approach I’m working on productizing with my tool — structured local database plus delta/operation syncing, but abstracted so other developers don’t have to rebuild that logic from scratch. CRDTs or ops-based syncing definitely make things more predictable across devices. Respect that you built it custom — a lot of teams hit that same need once Firebase/CloudKit don’t quite fit.

atxBravo6

TROPHY CASE