One Architecture, Many Products: What You Can Build with a Local-First + Realtime Stack

The video demonstrates more than a single demo—it showcases a modern application architecture built around local-first state, offline writes, background sync, and realtime updates. Using Expo, Legend-State, and Supabase, the presenter walks through a pattern that is broadly applicable to many real-world products.

This article explains that methodology and explores the types of apps it unlocks, along with why they’re such a good fit.

The Core Methodology (Abstracted)

At its heart, the approach follows a simple but powerful sequence:

  1. Local state is the source of truth

  2. Writes happen instantly on the device

  3. Data syncs in the background

  4. Realtime updates propagate to other clients

  5. Authentication and permissions are layered in later

In other words:

Your app should feel fast and reliable even when the network is slow or unavailable.

This is the essence of local-first architecture.

Why Local-First Changes What You Can Build

Traditional cloud-first apps block on the network. Local-first apps don’t.

That difference enables:

  • Offline creation and editing

  • Optimistic UI updates

  • Reduced latency

  • Better mobile UX

  • Easier realtime collaboration

Legend-State handles local mutation and observation, while Supabase provides:

  • Postgres persistence

  • Realtime replication

  • Authentication

  • Row Level Security (RLS)

Together, they form a stack that’s ideal for data-heavy, user-facing apps.

Categories of Apps That Fit This Architecture

1. Productivity & Personal Apps

These are some of the best candidates because users expect them to work anywhere.

Examples:

  • Notes apps (Notion / Apple Notes–style)

  • Task managers and Kanban boards

  • Journaling apps

  • Habit trackers

Why they fit:
Users frequently create and edit content offline. Instant feedback matters more than strict consistency.

2. Collaboration & Shared Tools

Local-first doesn’t mean single-user. Realtime sync enables collaboration.

Examples:

  • Shared shopping lists

  • Team checklists or SOP tools

  • Brainstorming boards

  • Lightweight project trackers

Local updates feel instant, while Supabase Realtime keeps everyone in sync.

3. Field, Mobile & Edge-Case Apps

These apps require offline-first behavior.

Examples:

  • Field service reports

  • Inspections and audits

  • Medical or care notes (non-diagnostic)

  • Logistics or delivery tracking

When connectivity is unreliable, local-first is not optional—it’s essential.

4. Consumer & Lifestyle Apps

These apps benefit from seamless state syncing across devices.

Examples:

  • Reading trackers

  • Travel logs

  • Photo metadata/tagging tools

  • Media progress trackers (podcasts, courses)

The user experience improves dramatically when progress is never lost.

5. Lightweight Business Apps

Many internal tools don’t need complex distributed systems—just reliability.

Examples:

  • Expense trackers

  • Inventory counters

  • Small CRMs

  • Timesheet apps

Local-first enables fast data entry and later reconciliation.

6. Realtime-First Experiments

Some ideas are only practical with instant syncing.

Examples:

  • Live polls or voting apps

  • Turn-based multiplayer games

  • Shared timers or dashboards

  • Presence-aware apps

Supabase Realtime makes these surprisingly approachable.

What Makes an App a Good Fit?

This methodology works best when:

  • Users create or edit data frequently

  • Offline usage is valuable

  • Eventual consistency is acceptable

  • Fast UI feedback matters

  • The app runs on mobile (or mobile + web)

If your app feels worse with spinners and loading states, local-first is worth considering.

A Subtle but Powerful Advantage

Local-first architecture also improves developer experience:

  • Easier testing (state lives locally)

  • Fewer loading edge cases

  • Cleaner separation of concerns

  • Backend becomes synchronization, not control

Instead of fighting latency, you design around it.

Final Thoughts

The demo in the video isn’t about a single app—it’s about a shift in mindset.

By treating local state as primary and the backend as a sync layer, you unlock:

  • Better UX

  • More resilient apps

  • Faster iteration

  • Strong foundations for realtime features

Once you understand this pattern, you’ll start seeing opportunities everywhere.

If you’d like, I can:

  • Map this architecture to a specific app idea

  • Create a step-by-step build guide

  • Compare this approach to traditional cloud-first apps

Just tell me what you want to explore next.

Vibe Coding, SupabaseFrancesca Tabor