Dawnwell

The Challenge

Habit tracking only works if the app is frictionless at 6 AM. That means it cannot show a spinner on open, cannot lose a check-in to a network error, and cannot overwrite a change made on a second device without warning. Those three constraints — instant open, offline writes, multi-device consistency — pull in different directions. A cloud-first architecture solves sync but requires a network. Optimistic UI solves latency but silently loses conflicts. The design had to make all three work together without reaching for a library (like CRDTs) that was more complex than a single-user sync problem needed.

The Approach

SQLite is the source of truth, not the server. The app reads from the local database on open — no network call, no loading state, no blank screen. Writes go to SQLite first; the UI updates optimistically before anything reaches Supabase. The sync engine runs in the background: push local changes before pulling remote ones, so edits never get overwritten by a pull that races ahead. Merge logic is deterministic across six rules covering every conflict case — last-write wins on timestamp, with all conflicts logged rather than silently discarded. Device-local fields (notification permission IDs, local-only settings) are marked SYNC-EXCLUDE at the TypeScript level, which enforces they never reach the network schema. Animations run on the native thread via Reanimated 4 JSI worklets, keeping the UI fluid even while Drizzle runs heavier relational queries on the JS thread.

The Outcome

Shipped solo to both the iOS App Store and Google Play as a production app. The check-in flow opens without network dependency — habit lists render from SQLite before any sync cycle runs. The LWW engine handles all multi-device conflict cases deterministically with no silent data loss. The design system (cool deep-blue palette, bottom-sheet forms, reduce-motion support, haptic feedback) was built as a custom token layer in code, not in a design file — so every component is consistent and portable. The architecture proved that a solo engineer can ship a production mobile app with real sync, real design, and real distribution without over-engineering the solution.