Introduction
Imagine your bot opens a position, the market reverses sharply, and you find out 5 seconds later — when the price has already hit your stop-loss. Delay in mobile monitoring directly translates into losses. We develop mobile applications that connect to your trading bot via WebSocket — latency under 200 ms, 25 times faster than REST polling every 5 seconds. Our experience shows that a properly implemented transport with exponential backoff and state synchronization ensures data freshness even on unstable networks. Our team of certified iOS, Android, and Flutter developers delivers the project turnkey in 5–7 working days. With over 5 years building high-performance solutions for the financial sector, this case is one of our typical projects.
How WebSocket Transport Works
REST polling every 5 seconds introduces up to 5 seconds of delay and unnecessary load. WebSocket maintains a persistent connection, delivering data by event. The bot backend emits events: position_opened, position_closed, order_filled, pnl_updated. Apple's official documentation for URLSessionWebSocketTask has been supported since iOS 13.
Comparison of approaches:
| Parameter | WebSocket | REST Polling |
|---|---|---|
| Latency | 200 ms | 5+ seconds |
| Network load | Minimal | High (requests every 5s) |
| Background operation | Requires push | Only when app active |
| Implementation complexity | Medium | Low |
On iOS, implementation via URLSessionWebSocketTask:
actor BotMonitorConnection { private var webSocketTask: URLSessionWebSocketTask? private let session = URLSession.shared var onEvent: ((BotEvent) -> Void)? func connect(botId: String, token: String) { let url = URL(string: "wss://api.example.com/bots/\(botId)/stream?token=\(token)")! webSocketTask = session.webSocketTask(with: url) webSocketTask?.resume() startListening() } private func startListening() { webSocketTask?.receive { [weak self] result in switch result { case .success(let message): if case .string(let text) = message, let data = text.data(using: .utf8), let event = try? JSONDecoder().decode(BotEvent.self, from: data) { self?.onEvent?(event) } self?.startListening() case .failure(let error): self?.scheduleReconnect() } } } private func scheduleReconnect() { Task { try? await Task.sleep(nanoseconds: 3_000_000_000) connect(botId: botId, token: token) } } } Why Exponential Backoff Is Critical for Mobile Trading
Mobile networks are unstable: subway, elevators, tower handoffs. If you simply try to reconnect every second, you risk draining the battery and blocking the socket. Exponential backoff increases the reconnection interval: 1s, 2s, 4s, 8s... up to 30s. After a successful connection, the interval resets. Additionally, after reconnection, the client requests the current state via REST (GET /bots/{id}/state) to catch up on missed events.
On Flutter with Riverpod, it's convenient to expose the connection as a StreamProvider:
@riverpod Stream<BotEvent> botEventStream(BotEventStreamRef ref, String botId) { final channel = WebSocketChannel.connect( Uri.parse('wss://api.example.com/bots/$botId/stream'), ); ref.onDispose(channel.sink.close); return channel.stream .map((data) => BotEvent.fromJson(jsonDecode(data as String))) .handleError((e) => ref.invalidateSelf()); } What to Do on Disconnection
The user must see a connection indicator: green (live), gray (reconnecting), red (offline). This is a key element of trust. We implement a step-by-step algorithm:
- On disconnect: wait 1 second, then attempt reconnection.
- On failure: double the timeout up to a maximum of 30 seconds.
- On successful reconnection: request the current state via REST.
- Update the UI with the indicator.
What Data Is Displayed on Screen
The app is divided into three main zones:
Open Positions. Pair, side (Long/Short), size, entry price, current price, unrealized PnL in % and USD. PnL updates on every pnl_updated event — we only redraw the changed row, not the whole list. On Android, DiffUtil in RecyclerView; on Flutter, ListView.builder with keys.
Event Feed. The last N events: "Opened position BTC/USDT long 0.01 BTC @ 67,430", "Order filled", "Stop-loss triggered". All with timestamps.
Session Metrics. Number of trades, total realized PnL, win rate. Updates on every position_closed. Event types in detail:
| Event | Description | Frequency |
|---|---|---|
| position_opened | New position opened | On event |
| position_closed | Position closed | On event |
| pnl_updated | PnL update | Every 500 ms |
| order_filled | Order executed | On event |
Push Notifications for Critical Events
WebSocket is the primary channel for the active screen. But when the app is backgrounded, events are delivered via FCM/APNs: stop-loss triggered, bot error, significant PnL change. Push notifications don't replace real-time but complement it. We configure filtering to avoid spam: only events marked as critical by the backend.
Trust and Experience
Our engineers hold Apple (iOS) and Google (Android) certifications. With 5+ years in the field, we have delivered over 20 projects for the financial sector, including trading terminals, portfolio monitors, and bot dashboards. Every app undergoes code review, load testing, and security checks.
What's Included in the Work
- WebSocket client with exponential backoff reconnection
- Connection status indicator (live/reconnecting/offline)
- Open positions list with live PnL (efficient updates)
- Event feed with auto-scroll
- REST state synchronization on reconnect
- Push via FCM/APNs for background alerts
- Documentation and integration guide
Timeline and Cost
Development time is 5–7 working days. If the backend already sends WebSocket events, the mobile part takes 4–5 days. Cost is calculated individually after analyzing requirements and architecture.
Contact us to discuss your project. Our specialists will evaluate your bot's logic for free, propose an optimal architecture, and provide an accurate estimate. Get a consultation today.