Splyt: Plans. Places. Paid

App Frame
App Icon

Inspiration

Every friend group has the same recurring moment: the bill lands on the table, someone pulls out their phone to do math nobody agreed on, and the group chat spends the next three days arguing about who ordered what. We've all been the person who fronted the bill and had to chase three friends for their share — or the person too embarrassed to ask.

Splyt started from a simple, personal frustration: splitting a bill shouldn't require a calculator, a screenshot of a receipt, and a week of "did you Venmo me yet?" messages. We wanted the money part of hanging out to be as effortless as the hanging out itself — set what you're spending, invite the table, and let the app handle who owes what, in real time, without anyone doing mental math at 1am.

What it does

Splyt turns any night out — dinner, a bar, a trip, a concert, or "we'll figure it out when we get there" — into a shared "Date Table":

One person sets the spend. Whoever gets there first sets the budget for the night (e.g. "$500 tonight") and invites up to 10 friends with a short code or link. Everyone picks their share. Friends join and choose an equal split, cover the rest, or a custom proportion — Splyt shows exactly who's carrying the biggest share of the night. Live, not after the fact. Location (with three privacy levels: never, one-time ping, or live-until-the-table-closes), photos of the menu and the spot, and reactions all sync in real time between everyone at the table. Add a round, recalculate instantly. Someone orders another round mid-night? Add the expense, pick how to split it, and every share recalculates live for the whole group — no more "wait, how much do I owe now?" Multi-currency, locked at the moment. Splitting a bill across currencies locks the exchange rate the instant the expense is added, so nobody argues about conversion later. The place, remembered. Splyt pulls real venue data from a Places API and layers its own "Splyt score" on top, based on your circle's actual visits — so you can rate the drinks and repeat a table you loved in one tap. Chat that disappears. Table chat is ephemeral — built to coordinate one night, deleted the moment the table closes. No password required. Sign in with Apple, Google, or go fully anonymous with an auto-generated handle — Splyt still settles real money between real friends either way, and you can link an account later without losing your history. How we built it

Splyt is built with Kotlin Multiplatform + Compose Multiplatform, sharing business logic and UI across iOS and Android from a single codebase — critical for a two-person(ish) build trying to ship on both stores inside the Shipaton window.

Native APIs for location, camera, and photo library access on each platform, wired through KMM's expect/actual pattern so the shared logic never has to know which OS it's running on. RevenueCat powers Splyt Plus, our subscription tier — full expense history and export, group stats, and photos that persist past the 30-day free-tier window. This was also the layer that made cross-platform subscription handling (App Store + Play Store from one shared paywall logic) actually manageable. On-device AI models handle lightweight financial analysis — categorizing expenses (food, ride, cover, etc.) and surfacing spend patterns (who's carried the group lately, your priciest nights) without sending financial data to a server for every inference. A hybrid backend (Firebase + Supabase) handles real-time sync for presence, location, chat, and live expense recalculation, while relational data (expense history, group stats) lives in Postgres. The entire UI system — color, type, motion, and 14 core screens plus dedicated empty/edge states — was designed as a single source-of-truth spec before a line of production UI code was written, so both platforms stay visually identical without drifting. Challenges we ran into Real-time proportional math is deceptively hard. Recalculating everyone's share live when a new expense lands mid-night — while keeping the UI feeling instant instead of janky — took several iterations of the state model before it felt right. Anonymous auth + real money is a trust problem, not just a technical one. We had to design around the fact that anonymous users still need their contributions to feel accountable to the group, without forcing a password at signup. Two backends, one source of truth. Splitting responsibilities between Firebase (real-time presence/chat/location) and Supabase (relational expense/history data) meant being deliberate about which system owns which piece of state, so nothing gets out of sync mid-table. Multi-currency without confusing anyone. Locking exchange rates at the moment of each expense — instead of a single rate for the whole table — meant more edge cases in the math, but it's the only version that's actually fair when a table runs for hours. Fitting a real feature set into 14 screens. We kept pushing ourselves to combine related flows (tabs and sheets instead of new screens) so the app stayed intuitive instead of sprawling. What we learned

Splitting a bill sounds like a solved problem until you actually build it for a live group of people moving around a city in real time — location privacy, ephemeral chat, proportional math, and multi-currency all turned out to be much deeper problems than "divide by N."

What's next

Expanding Splyt Plus with smarter on-device spend insights, more languages, and refining the monetization moments around real friction points (like history that's about to expire) instead of generic feature-gating.