Mobile Money Wallet

Overview

A mobile money wallet: an app that lets people hold a balance, send and receive money, pay merchants and bills, and cash in and out through a network of local agents. This is a real fintech product, not a demo, and in this domain correctness is everything: balances, commissions, KYC and agent operations all have to be exact and clear to non-technical users. I was brought in to rebuild it, and I owned the work end to end, from the mobile experience down to the backend that moves the money.

What the wallet does

The product covers a full mobile money feature set:

• Wallet and transfers: hold a balance, send and receive money person to person, with transparent fee estimation
• Cash in and cash out: deposits and withdrawals, including withdrawal by QR code (scan, polling, expiry)
• Merchant payments: pay a merchant by scanning a QR code, with clear success and failure states
• Bill payments: pay partner billers directly from the app
• Agent / reseller network: agents perform deposits and withdrawals on behalf of customers, earn commissions, track their earnings on a dashboard, and cash out their balance
• KYC: identity verification with document upload
• Security: OTP, PIN and biometric authentication
• Beneficiaries: saved contacts for faster transfers

The product I inherited

This was not a small app to patch. It was a full mobile money product that looked finished but could not be trusted with real money. A technical and UX audit surfaced problems across the entire stack.

On the app:

• The overall UX was poor: no main navigation (everything routed through the home screen), no real feedback when an action succeeded or failed, and raw English error messages surfaced untranslated in a French app.
• The onboarding was clumsy and, worse, broken: users could register, then were immediately locked out at login by a client-side rule that rejected the very password they had just chosen. They were trapped.
• Fake hardcoded transactions (foreign marketplaces, other countries) were shown to every user on the home screen, inside a financial app, next to a generic "Hello, User" because the profile never loaded.
• The money flows were dead ends: send, deposit and withdraw each spun an infinite loader, with no error, no timeout and no retry.
• Whole parts of the product simply did not exist. The merchant payment experience and the entire agent side (cash-out, commissions, earnings) had zero screens. This was missing product, not missing polish.
• No design system: three UI libraries mixed together, no visual identity, no typography scale, and poor Android rendering.

On the backend:

• A fintech backend running on MongoDB, with no transactional atomicity for money operations.
• Account balances drifting out of sync across different flows.
• Transfers recording the operation against the wrong party and the wrong account.
• In-memory filtering, missing query-level counts, and almost no automated tests.

Fixing a live product at this scale, across both the app and the backend, is harder than starting from scratch: everything has to keep working while it is rebuilt underneath.

What I rebuilt

The mobile app

• Rebuilt the whole experience on a real design system and visual identity, replacing the three mismatched UI libraries, with a proper typography scale, consistent theming, coherent tab-based navigation and correct Android rendering. The app went from confusing to clear.
• Reworked the onboarding and fixed the core: redesigned the sign-up flow, removed the login trap, replaced the fake hardcoded data with real API-backed content, and turned dead-end loaders into flows with proper loading, empty, error and retry states and translated messaging.
• Designed and built the entire agent experience from scratch, which did not exist before: agent cash-out, and a commissions and earnings dashboard for tracking revenue.
• Designed and built the entire merchant payment experience from scratch, which also did not exist: pay-by-QR with clear success and failure states.

The backend

• Migrated the backend from MongoDB to PostgreSQL, because a database with no transactional guarantees is the wrong foundation for money. I wrote the migration plan, built a typed Drizzle data-access layer (schema, migrations, dependency injection), and moved the domain services and HTTP layer from Mongoose onto it.
• Restored correctness: real transactional atomicity for money operations, query-level filtering and counts instead of in-memory work, and balances synchronized across every flow.
• Fixed the money bugs: corrected the transfer attribution and account-reference errors, and reworked the fixed fee-tier logic.
• Made it testable and deployable: a unit and integration test suite against a real PostgreSQL database (86% line coverage), and CI rewired to run in parallel against real PostgreSQL, with migrations applied automatically on deploy.

Result

The wallet went from not fit for production to trustworthy end to end: a coherent, professional mobile app with reliable flows and honest data, on top of a relational backend with real transactional guarantees, consistent balances and a genuine test suite.

Tech

• Mobile: React Native + Expo, React 19, TypeScript, Redux Toolkit, secure device storage, biometric and PIN auth, Sentry, Fastlane and EAS, Jest
• Backend: NestJS + TypeScript, migrated from MongoDB / Mongoose to PostgreSQL + Drizzle ORM, integration tests on real PostgreSQL, CI on GitHub Actions

My role

I was brought in as a freelance senior developer and rebuilt this mobile money wallet across the stack, from my own audit through to delivery. I owned the mobile app end to end, and on the backend I led the migration off MongoDB and hardened everything that handles money. The original backend was built by another team. Taking a live fintech product from broken to production-grade, app and backend at once, is exactly the kind of work I do.