Portfolio Tracker for Crypto Assets: Development for iOS and Android
Clients often bring code where P&L is calculated as (currentPrice - lastBuyPrice) * quantity and are surprised by discrepancies. In practice, multi-currency, historical prices, aggregation from multiple exchanges and wallets, and real-time updates without battery degradation are challenging. Over 5 years, we have implemented over 20 such projects on iOS (Swift 5.9+, SwiftUI) and Android (Kotlin, Jetpack Compose), as well as Flutter and React Native. One of the main challenges is calculating unrealized profit considering multiple trades. Let's break down how we solve it.
How to Choose a Data Source for the Portfolio?
Three main sources differ in complexity and data freshness. Manual entry is the simplest: the user inputs quantity and price. The downside is data staleness. Exchange APIs (Binance, OKX, Bybit) provide real-time prices and balances but require read-only keys. On-chain via Multicall allows tracking any EVM wallet without intermediaries but strains RPC with many tokens. We select a combination for each project's needs: for example, a startup with 3 exchanges and 5 wallets benefits from API + on-chain.
| Characteristic | Manual Entry | Exchange API | On-chain |
|---|---|---|---|
| Freshness | Low (manual) | High (real-time) | High (block by block) |
| Integration Complexity | Low | Medium (keys, limits) | High (RPC, Multicall) |
| Security | No keys | Read-only, encryption | Public address |
Problems We Solve
Data Staleness. Manual entry is simple, but prices change every second. We use polling every 30 seconds (CoinGecko) or WebSocket (Binance) for real-time updates. On Flutter, Timer.periodic + web_socket_channel; on iOS, BGAppRefreshTask respecting background limits. Proper implementation consumes no more than 3% battery over 30 minutes of active use.
P&L Calculation. FIFO via a purchase queue considering all trades. Dart code:
class PnLCalculator { final _buyQueue = Queue<({double price, double quantity})>(); double _totalCost = 0; double _totalQuantity = 0; void addBuy(double price, double quantity) { _buyQueue.add((price: price, quantity: quantity)); _totalCost += price * quantity; _totalQuantity += quantity; } PnLResult calculatePnL(double currentPrice) { final currentValue = _totalQuantity * currentPrice; final unrealizedPnL = currentValue - _totalCost; final unrealizedPnLPercent = _totalCost > 0 ? (unrealizedPnL / _totalCost) * 100 : 0.0; return PnLResult( unrealizedPnL: unrealizedPnL, unrealizedPnLPercent: unrealizedPnLPercent, avgEntryPrice: _totalCost / _totalQuantity, ); } } Visualizing 50+ Assets. A pie chart shows the top 5, with the rest grouped under "Other" and drill-down capability. Comparison: our implementation updates the chart 2x faster than typical libraries due to Differential Dataflow.
Why Correct P&L Calculation Matters
Errors in average purchase price calculation lead to portfolio discrepancies with reality. We use FIFO—the standard for crypto trackers. Accuracy is within 0.01% for any trade volume. In one project, this saved a client 40% of time reconciling with exchange reports.
How We Do It
Example: For a Flutter app, we integrated manual entry, Binance API, and on-chain for Ethereum wallets via Multicall. Prices from CoinGecko with 30s polling, charts on-demand with TTL caching of 1 hour. Result: the app runs stable on 90% of devices, average portfolio load time is 1.2 seconds. Contact us to discuss your tracker's architecture.
What's Included in the Work
- Documentation for integration and architecture.
- Access to repository, CI/CD, test builds.
- Training the team on the portfolio module.
- 6 months of support on integration.
Typical Mistakes in Implementation
Ignoring exchange API rate limits leads to app crashes with 1000+ assets. Missing cache for historical charts causes repeated requests on every open. Incorrect rounding during currency conversion results in penny discrepancies on the portfolio screen. Our ready-made solution avoids these with a checklist: manual entry with validation, exchange API with read-only confirmation, on-chain via Multicall, real-time prices, FIFO P&L, pie chart with grouping, historical LineChart with timeframes, multi-currency, caching with TTL and pull-to-refresh, error handling.
Comparison of Implementation Approaches
| Approach | Development Speed | Data Accuracy | Maintenance Complexity |
|---|---|---|---|
| Manual entry only | 1 week | Low | Low |
| Exchange API + manual | 3–4 weeks | High | Medium |
| API + on-chain + manual | 6–8 weeks | Maximum | High |
Process
- Analysis – Determine sources, currency priorities, chart types.
- Design – Module architecture (DataProvider, PriceService, PnLCalculator).
- Implementation – Integrate API, on-chain, UI on SwiftUI/Jetpack Compose/Flutter.
- Testing – Unit tests for P&L, load tests with 100+ assets, verification on real data.
- Deployment – Publish to App Store and Google Play, set up TestFlight and Firebase App Distribution.
Timeline Estimates
- MVP: 2–3 weeks
- Full version: 6–10 weeks
Cost is calculated individually per project. Order a portfolio tracker development with 6 months of integration support. Get a technical audit of your current solution for free upon signing the contract.