• 

  Usage summary

• 

  Plan recommender feature

• 

  Pro Plan offering page

• 

  Leaderboard / detailed usage

• 

  Burn rate and peak usage period

• 

  App icon

PlanDee

Inspiration

In emerging markets like Nigeria, mobile data is expensive and telecom pricing is confusing. Carriers offer hundreds of overlapping bundles with tricky conditions—like night-only data, social-app quotas, and short validity periods. Most smartphone users end up overpaying, wasting unused bonus data, or losing money to pay-as-you-go airtime billing simply because tracking granular usage across multiple SIMs is manually impossible.

I built PlanDee to solve this: converting raw Android network statistics into clear, actionable telecom recommendations—helping everyday users pick the exact data plans that match their actual habits and save money.

What It Does

PlanDee tracks on-device data consumption and automatically matches users with the cheapest telecom plans:

• Automated Data Auditing: Monitors data usage per app, separating foreground activity, background drain, Wi-Fi usage, and off-peak (night) data windows.
• Smart Tariff Matching: Compares real user consumption against updated pricing catalogs across MTN, Airtel, Glo, and 9mobile to find the most cost-effective bundles.
• Runout & Expiry Alerts: Tracks daily burn rates to warn users before their data runs out or switches to expensive direct airtime billing.
• 1-Tap USSD & Purchase Actions: Generates pre-formatted dialer codes (USSD) and payment links to renew or switch plans in seconds.

How I Built It

I architected PlanDee as a native Android app backed by a lightweight Go microservice:

• Android App (Kotlin & Jetpack Compose): Native Android app using NetworkStatsManager to query byte-level network usage per UID, with WorkManager handling periodic background collection. UI state is driven by StateFlow streams following MVVM architecture.
• Backend Service (Go & PostgreSQL): Built in Go for fast response times. PostgreSQL stores carrier tariff catalogs, user usage summaries, and recommendation records.
• Optimization Engine: I framed plan selection as a multi-constraint Knapsack / Dynamic Programming problem in Go. Instead of guessing, my backend evaluates single plans and multi-bundle combinations against the user's budget, night usage ratio, and top app categories to find the global minimum cost.

$$\text{DP}(b, t) = \min_{p \in \mathcal{P}} \Big( \text{Price}(p) + \text{DP}\big(\max(0, b - \text{UsableBytes}(p)), \, \max(0, t - \text{Validity}(p))\big) \Big)$$

Challenges I Ran Into

• Sanitizing Android Network Telemetry: Android's raw NetworkStatsManager queries include kernel traffic, system daemons, and uninstalled app UIDs. I built a filtering pipeline to isolate real user apps.
• Jetpack Compose Performance: Parsing network logs and loading app icons initially caused UI stutter when executed on the main thread. I resolved this by moving telemetry aggregation to background coroutines (Dispatchers.IO).
• Multi-Constraint Optimization: Factoring in night-owl bonuses and app-specific allowances increased combination complexity. I optimized state transitions in Go to keep recommendation responses under a few milliseconds.
• In-App Purchase Testing: Testing subscription tiers locally without an active Google Play Console setup required building a mock repository layer and fallback entitlement handlers.

Accomplishments I'm Proud Of

• Sub-Millisecond Plan Matching: Built a Go recommendation engine that evaluates hundreds of tariff plan combinations under strict budget limits in less than 1 ms.
• Clean, Responsive Dashboard: Created a lightweight Jetpack Compose UI with intuitive charts that display usage breakdowns cleanly without lagging.
• Real-World Savings: Built an end-to-end working tool capable of saving smartphone users 15% to 30% on monthly mobile data expenses.

What I Learned

• Transitioning to Modern Android: Moving from core Java fundamentals to modern Kotlin, coroutines, StateFlow, and Jetpack Compose state management.
• Applied Algorithm Design: Implementing dynamic programming for a real production backend rather than just textbook exercises.
• Android OS Internals: Working directly with Linux UID network accounting, system usage buckets, and modern background execution constraints.
• System Design & Pragmatism: Designing clean API contracts between dynamic backend pricing catalogs and mobile client execution logic.

What's Next for PlanDee

• Direct In-App Bundle Purchases (VTU): Integrating direct payment gateways (Paystack/Flutterwave + VTU APIs) to let users buy data directly inside the app.
• Usage Forecasting: Adding time-series forecasting to predict heavy usage spikes before they happen.
• Dual-SIM Smart Routing: Automatically detecting dual-SIM slots to route recommendation advice per SIM card slot. A rollout for most of the features listed on the Pro Plan

Built With

• admob
• compose
• go
• kotlin
• revenuecat