Still under construction — this write-up is still being added to
GetPesa App
A financial management app for MoMo — spending, balances and transaction history for money that otherwise only exists as SMS receipts.
- Role
- Design and development
- Stack
- Product designUI/UXReact NativeAndroid
The bet
MoMo sends a text for every transaction, and that text already contains everything a statement would: amount, name, fee, balance, reference, date. The whole app is one bet — read those texts, and the user never types anything.
Everything else follows from it. Most of the hard parts turned out to be the gap between the message existing on the phone and the message reaching the parser.
Capture
Two platforms, two completely different mechanisms, one shared queue. On Android a broadcast receiver listens for incoming SMS and works with the app closed, which is the entire point. On iOS there is no SMS API at all, so the user builds a Shortcut automation that hands matching messages to an app intent — worse than Android, and the only door Apple leaves open.
Both write to the same native queue, and the JavaScript side drains it without knowing or caring which platform filled it. A queue rather than a direct call into React because the receiver runs when there is no React tree at all — the app may be closed. It has to be able to catch something and hand it over later.
Only messages containing RWF are stored. The receiver sees every SMS on the phone — one-time codes, adverts, private messages — and keeping those would be both a privacy problem and a parser full of junk. It stays a currency test rather than a list of approved senders, because a list needs editing and a new build every time a sender appears, while anything unrecognised already lands as unknown for review. Visible, not lost.
The bug that took a real phone to find
Capture-on-arrival has a flaw I could not have found on my own device. ZTE, Xiaomi, Oppo, Vivo and Transsion all ship an auto-start manager that decides which apps may be woken by a system event, and an app not on its list is simply skipped. A nubia's own log said it plainly: the broadcast was blocked for the package before the process ever started.
The symptom was the worst kind. App open, transactions tracked; app closed, nothing. Every permission green, nothing misconfigured. And with only the permission to receive SMS, a message missed that way was missed forever — that permission sees messages in flight and cannot read the inbox, so opening the app later recovered nothing. The transaction sat in the phone's message list while the ledger quietly disagreed with the bank, which is the worst failure this kind of app can have, because it still looks like it is working.
The fix is a backfill: read the inbox, keep a high-water mark, and on every app open scan for money messages newer than it. Found messages go into the same queue the receiver uses, so the same parser and the same dedup handle them.
The shape matters more than the fix. It solves the whole class of problem rather than one vendor — each of them blocks differently and hides the toggle somewhere different, and you cannot ask people to go hunting for it. The scan never has to be precise, only generous, because dedup means anything the receiver already caught costs nothing. And the first run reaches back thirty days rather than everything: these inboxes hold thousands of messages, and importing years of history on first open is a surprising thing to do to someone's ledger.
The consequence I didn't plan: new users now land on a month of history instead of an empty screen.
Parse, dedup, store
A parser turns the text into a typed transaction, and anything it cannot read is stored as unknown rather than dropped — visible in a review queue instead of silently gone.
Dedup is the quiet workhorse. Every message is keyed, so the same transaction arriving twice — once from the receiver, once from a backfill scan, once from a manual paste — is stored once. That is what allows every other part of the system to be sloppy on purpose.
Everything is written to an on-device database first, so the app is fully usable with no network, ever. Syncing to the server is best-effort and its failures are swallowed: a round-trip to the cloud must never degrade the thing in your hand.
One small detail with outsized effect: a transaction is dated by when its message arrived, not when it was processed. A backlog drained in one loop would otherwise stamp six messages with the same second and read as duplicates.
Offline is the normal case
A phone with no data is a normal Tuesday in Rwanda, not an edge case. So the work scheduled after each capture carries no network constraint, deliberately.
It does two jobs and only the second needs a connection: first it parses into the ledger and checks the budget — pure local computation and a local notification — then it pushes to the server. Constraining the whole thing on connectivity meant that offline nothing ran at all. The transaction was safe, but no budget warning ever appeared, on exactly the phones where knowing sooner matters most.
Sending money
The app cannot move money — the carrier's USSD does. So it builds the exact code and hands it over, dialling directly on Android and falling back to the dialer on iOS, which will not let an app run USSD at all.
Two guards, both shaped by how mistakes actually happen. A near-miss check: if the number is one digit off someone you already pay, it says so by name. That one is not gated on amount, because a typo is a typo at any size, and it fires so rarely that it never becomes something people tap past by reflex. And a first-time check: a new number above a threshold gets one confirmation, while small sends to new people go straight through — confirming every one of them trains people to tap through without reading, which is exactly when a confirmation stops protecting anyone.
Pending intents are recorded before the handover, because once the carrier's screen is up this app is in the background and may not get another turn.
Launch has to be unconditional
The boot sequence loads translations, theme, budget, recents and entitlement — and it settles all of them rather than requiring all of them. The difference is the whole app. Wait on all and the first rejection means the continuation never runs, ready is never set, and the app renders nothing, forever. In a release build an unhandled rejection draws no red box and writes no log, so it presents as a white screen nobody can get past. One person's corrupt storage entry was enough.
Every loader there is optional state. Not one of them is worth refusing to start over. Failures are reported by name instead, so a silent degradation is still visible to me.
The same lesson arrived a second way. A crash came from reading an identifier off a notification response that Android returns as null for responses the app didn't schedule. The throw landed inside an effect, React unwound into native, and the process died — and because Android persists that response, every relaunch hit the same null. Crash, relaunch, crash three seconds later, forever; uninstalling was the only way out.
The pattern worth keeping: anything that can throw during boot or inside an effect takes the whole app down, and any bad state the OS persists makes it permanent.
The weekly budget, designed by a tester
This one didn't come from a roadmap. It shipped as a daily limit, and a tester said the obvious thing nobody in the code had noticed: a day is the wrong unit.
They were right, and the reasoning is worth keeping. A daily limit breaks on the first legitimately expensive day — school fees, a funeral contribution, a hospital run — and a limit that fires on a day you had no choice about is a limit you learn to ignore. A week absorbs that Tuesday and still notices a habit. It is also how people are paid and how they already think about money. The daily limit was deleted outright rather than kept as an option.
Monday to Sunday, deliberately. The app holds two models of a week: this one, and the calendar blocks that reports use — the 1st to the 7th, the 8th to the 14th, and so on. Blocks partition a month cleanly, which is right for a report and wrong for a budget: a month's last block can be three days, so a budget on that model hands someone a full week's money for a long weekend.
It is a target, not a control. GetPesa cannot stop a payment — the carrier moves the money — so nothing here blocks anything, and the vocabulary is 'left' and 'over', never 'denied'. Fees count toward spending, because 100 francs of fee is 100 francs that isn't in the wallet, and a budget that ignored them would quietly run over.
It also suggests the number, because asking someone to invent a weekly budget from nothing is asking them to guess. The suggestion is the median of their last twelve weeks — but it waits for two complete weeks before offering one. Quoting a figure drawn from a single week to someone eight days in is how a suggestion gets distrusted on first contact.
What it changed was retention. Before this, GetPesa was a ledger: accurate, useful and passive. You opened it when you wondered about something, and nothing ever asked for you back. The budget gave the app a reason to initiate — a hint on the send screen that speaks about the payment while you are deciding it, a local notification when you cross the line that fires with the app closed, a Monday reminder rewritten on every launch so a queued notification never quotes a stale total, and a weekly review that says what changed rather than what is merely biggest. That is the shift, from a thing you consult to a thing that tells you something. A ledger has no natural return visit; a budget has one every week.
The tension is still live in the code. Two components argue opposite sides in their own comments — one that a home screen shouldn't carry a permanent advertisement for an optional feature, the other that the people who would benefit most will never go looking for it. Both are right, and the contradiction is documented rather than quietly resolved.
The part worth generalising: the highest-value change in the app came from one tester's sentence about units. It cost a deletion and a rewrite, not a new feature.
What kept coming up
Never lose a transaction. Capture first, parse later, dedup always — every other choice bends toward this one.
Degrade, don't break. A failed loader, a missing native module, no network, a refused permission: each leaves the app running with less, never stopped.
Local-first. The device is the source of truth and the cloud is a backup, not the other way round.
Assume the OS is hostile. Vendor ROMs block broadcasts, kill processes and revert toggles, so anything that depends on being woken at the right moment needs a path that works when it isn't.
Say what failed. Silent degradation is how a bug survives a release.
Put it in real hands. The two biggest changes in this app — the weekly budget and the inbox backfill — came from a tester's sentence and one user's phone. Neither was reachable by reasoning about the code, and both took minutes to find once a real device was involved.
Still open
The queue drain runs its ingest in an unguarded loop and clears the queue afterwards, on a short interval with no error handling. If a message ever throws, the queue never clears and it retries forever — structurally the same failure as the crash loop above, and the next thing to fix.
There is no upper bound on a send amount yet.
And vendor blocking is invisible: the backfill recovers from it, but nothing tells the user, or me, that live capture has been silenced on that phone.
By the numbers
As of September 2026: 1,288 transactions captured, and Rwf 18,519,179 moved through the app in total. Rwf 46,960 of carrier fees rode along on top, which is exactly the money a budget that ignored fees would have quietly missed.
The number that matters to me is not any of those totals. It is that 1,288 messages landed on phones I do not own, in real network conditions, and became a ledger nobody typed.