A leadership author's company
Leadership exercises on phone, desktop and web, shipped from one codebase for launch
A leadership author's company had a working web prototype built in Lovable and a Google Play deadline. We planned a native rebuild, tested it against wrapping the existing code in the first week, and packaged the client's own codebase for iOS, Android, Windows, macOS and Linux.
EdTechLeadership practice appModernized a live product
The challenge
A leadership practice app existed only as a web prototype on Supabase, and the launch needed a Google Play submission, with terms and privacy documents, by a fixed date.
What we did
We tested a React Native rebuild against wrapping the web code, chose the wrap, packaged it with Capacitor for phones and Electron for desktops, and kept the client's Supabase.
The outcome
One codebase now runs on web, iOS, Android, Windows, macOS and Linux with accounts and progress synced, and the Android app went to Google Play for the launch.
- Platforms
- Web, iOS, Android, Windows, macOS, Linux
- Codebase
- One, the client's own, no rewrite
- Sync
- Accounts and progress on every device
- Release
- Android app submitted to Google Play
The starting point
A leadership development app from a leadership author's company. Each day a user gets a short practice exercise, completes or skips it, writes reflections and reviews their history.
What had to change
The product existed only as a web prototype built in Lovable with Supabase behind it. The client needed real apps on phones and desktops, with progress in sync, and a launch that depended on a Google Play submission.
What could not break
- The Google Play submission had to go in on the client's deadline
- Accounts and progress stay in the client's own Supabase organization
- The same features on web, phone and desktop, from one codebase
- Everything released under the client's own store account and brand
The calls we made
Our first plan was a full native rebuild; we tested whether the working prototype needed rebuilding at all before committing to it.
- 01
Wrap the code, do not rewrite it
In the first week we built a React Native prototype and tested Capacitor on the existing web code side by side. The wrap kept every feature and left one codebase to maintain, so we chose it.
Ruled outOur own first plan: a React Native rebuild with a new Node.js and PostgreSQL backend on AWS.
- 02
Keep the data layer the client owns
Supabase already held accounts, exercises and progress in the client's own organization, so every platform signs in and syncs through it and no user data had to move.
Ruled outThe separate backend in that first plan.
- 03
Android first, desktop second
The launch depended on the Google Play submission, so phone builds, local notifications and the store release came first, and the Electron desktop builds followed once the store build was in.
How the system fits together
What we built
iOS and Android apps
The web codebase wrapped with Capacitor, with local notifications for the daily exercise and the store's app name and icon.
Desktop apps
Windows, macOS and Linux builds packaged with Electron from the same code.
Fixes for packaged builds
Issues that appeared only once packaged, such as images on the history page, clearing history and the first Android builds, fixed once in the shared code.
Store release and handoff
Android builds released through the client's own Google Play developer account, then project documentation so the client can keep releasing.
How it works
The user signs in
Accounts run on the client's Supabase, so the same login works on every device.
The daily exercise arrives
A local notification on the phone points the user to the day's exercise.
They act and reflect
The user completes or skips the exercise and writes notes.
Progress follows them
History saves to Supabase and shows up on web, phone and desktop.
A closer look
What changed
One codebase now runs as a web app, iOS and Android apps and Windows, macOS and Linux desktop apps, with accounts and progress synced. The client kept the code it already had, and the Android app went to Google Play for the launch.
- Six, from one codebase
- Platforms
- Android app submitted to Google Play
- Store
Under the hood
- Datics role
- Modernized a live product
- Packaging
- Capacitor for iOS and Android, Electron for Windows, macOS and Linux, all from one React, TypeScript and Vite codebase.
- Data
- Supabase authentication and database in the client's own organization.
- Device features
- Local notifications for the daily exercise on phones.
Data and retrieval
Apps and APIs
Also in the stack
How it shipped
Test both paths
A React Native prototype and a Capacitor wrap of the existing code, side by side, and a decision for the wrap.
Phones
iOS and Android builds, cosmetic fixes, local notifications and the first Android package.
Store release
Fixes found in the packaged builds, then the Android app submitted to Google Play with its terms and privacy documents.
Desktop and handoff
Electron builds for Windows, macOS and Linux, the final app name and icon, refreshed store builds and project documentation.
In the client's accounts
The client invited us into its Supabase organization and its Google Play developer account, so the data, the apps and the store listing stayed in its name.
Paced by the launch
Each step was planned backward from the store submission, and we stayed in constant contact with the client while the deadline closed in.
What this unlocked
With one codebase and the documentation we handed over, the client can change the app once and release it to every platform.
Related work
Have a product with the same kind of constraints?
Tell us what already exists and what you want it to do. We will tell you what it takes.