Private Client · Africa
Building a Digital Bank for Cameroon: Mobile-First, Offline-Capable, Mobile-Money-Ready
Building a digital bank for a market where most users have low-end Android phones, intermittent internet, and use mobile money instead of bank accounts. Here's what we built and what we learned.
Measured results
- Account opening with KYC completed in under 5 minutes
- Offline-capable balance inquiry and queued transactions
- Integration with MTN Mobile Money and Orange Money
- 30,000+ active users in the first 6 months
Challenge
The blocker
A financial institution in Cameroon needed a digital banking platform for a market where most users interact with banking through mobile money, have intermittent internet, and use low-end Android devices.
Solution
The approach
We built a mobile-first banking app in Flutter with offline-capable transactions, integration with MTN Mobile Money and Orange Money, and a backend optimized for low-bandwidth communication.
Execution story
Cameroon's banking landscape is different from Europe or North America. Most people don't have bank accounts. They use mobile money — MTN Mobile Money and Orange Money — for everything from paying bills to sending money to family. Internet access is intermittent, especially outside Douala and Yaoundé. Most users have low-end Android devices with limited storage and RAM.
Our client — a financial institution in Cameroon — wanted to build a digital banking platform that would serve this market. Not a European banking app adapted for Africa, but a platform designed for the actual conditions on the ground.
The constraints
We started by listing the constraints, because the constraints drove every decision:
| Constraint | Implication |
|---|---|
| Intermittent internet | App must work offline for core functions |
| Low-end Android devices | App must be small, fast, and memory-efficient |
| Mobile money as primary financial tool | Must integrate with MTN and Orange Money |
| Low digital literacy for some users | UI must be simple and visual |
| Regulatory compliance (COBAC) | Full audit trail and KYC required |
| Low bandwidth | API responses must be small and compressed |
The architecture
Mobile app (Flutter)
We chose Flutter for the mobile app because:
- Single codebase for Android and iOS (though Android was 95% of the market)
- Small app size — Flutter apps are typically 15-20MB, compared to 40-60MB for native Android with equivalent functionality
- Good performance on low-end devices — Flutter compiles to native ARM code, which performs better than React Native on devices with limited RAM
- Offline support — Flutter's local storage options (SQLite, Hive, SharedPreferences) are well-integrated
The app was 18MB installed, which was important for users on devices with 16GB of storage and prepaid data plans.
Backend (.NET 8, PostgreSQL)
The backend was built in C# on .NET 8 with PostgreSQL. We chose .NET because the client's existing infrastructure was Microsoft-based and their team had C# experience.
The API was designed for low bandwidth:
- All responses were gzip-compressed
- Binary protocols (MessagePack) were used for high-frequency endpoints
- Pagination was mandatory on all list endpoints
- Field selection was supported (clients could request only the fields they needed)
A typical balance inquiry response was 280 bytes. A transaction history page (10 transactions) was 1.2KB. On a 2G connection, these responses loaded in under 2 seconds.
Mobile money integration
Integration with MTN Mobile Money and Orange Money was the most complex part. Both providers have APIs, but the documentation is inconsistent, the APIs have rate limits, and the error handling is non-standard.
We built an abstraction layer that:
- Normalized the API differences between MTN and Orange
- Handled retries with exponential backoff
- Provided idempotency for all financial operations
- Logged every transaction for regulatory compliance
The abstraction layer meant the rest of the app didn't know or care which mobile money provider was being used. Adding a third provider (if the client expands to another country) would be a configuration change, not a code change.
Offline capability
The most important feature wasn't flashy. It was the offline capability.
When a user opens the app without internet, they see their last known balance (cached locally). They can initiate a transfer, which is queued locally. When connectivity returns, the queued transfer is submitted automatically.
This sounds simple, but the implementation has edge cases:
- What if the queued transfer fails (insufficient funds, account closed)?
- What if the user queues multiple transfers that exceed their balance?
- What if the exchange rate changes between queuing and submission?
We handled these with:
- Optimistic UI: The app shows the transfer as "pending" (not "completed") until the server confirms
- Balance check on queue: The app checks the cached balance before queuing, and warns if the transfer might exceed the actual balance
- Failure notifications: When a queued transfer fails, the user gets a push notification (when they're back online) explaining why
KYC and account opening
Account opening needed to be fast (under 5 minutes) but compliant with COBAC (Central African Banking Commission) regulations. We built a flow that:
- Phone number verification — SMS OTP (works on 2G)
- Identity document capture — Photo of national ID or passport, with on-device quality checks (blur detection, glare detection)
- Selfie verification — Selfie with liveness detection (blink, head turn)
- Address verification — GPS coordinates + manual address entry
- Account creation — Backend creates the account and starts the compliance review
The on-device quality checks were important. If the ID photo is blurry, the compliance team rejects it, and the user has to start over. By checking quality on-device, we caught 80% of bad photos before submission, reducing the rejection rate from 35% to 7%.
The numbers
| Metric | Value |
|---|---|
| App size (installed) | 18MB |
| Balance inquiry response (2G) | 280 bytes, < 2s |
| Account opening time | < 5 minutes |
| KYC rejection rate | 7% (down from 35%) |
| Active users (6 months) | 30,000+ |
| Offline transaction success rate | 94% |
| Mobile money integration | MTN + Orange |
What we learned
Building for a market with different constraints forces you to make different decisions. The things that matter in Europe (beautiful animations, instant loading, rich visualizations) matter less than the things that matter in Cameroon (offline capability, small app size, mobile money integration, low bandwidth).
The teams that succeed in emerging markets are the ones who start with the constraints, not the features. If you start with "what features should the app have?" you end up with a European banking app that doesn't work in Cameroon. If you start with "what are the constraints?" you end up with an app that works for the people who need it.
The offline capability was the feature that users loved most. Not because it was technically impressive, but because it solved a real problem. In Cameroon, the internet goes down. When it does, people still need to check their balance and send money. An app that stops working when the internet stops working is useless. An app that keeps working — even in a limited way — is trustworthy.
That's what we built. An app that keeps working.