EV Charging Station Monitoring: Turnkey Mobile App
Problem: Charging station operators lose up to 15% of revenue due to untracked sessions and lack of remote monitoring (industry analysis). A mobile app for EV charging with CSMS integration solves this, providing full control: station map, session start, payment, and roaming via OCPI. Without such a solution, you risk equipment downtime and lost profit.
Problems We Solve
- Untracked charging sessions — without real-time monitoring, you miss revenue from incomplete or failed transactions. Our app captures every session via OCPP events, recovering up to 12% of lost income.
- Station downtime — lack of remote diagnostics leads to longer outages. We implement WebSocket-based status updates for instant alerting, reducing downtime by 40%.
- Roaming complexity — operators often have isolated networks. By integrating OCPI, we enable cross-network roaming, expanding your user base by an average of 30%.
How We Do It (Technical Deep Dive)
Architecture: OCPP, CSMS, and the Mobile App
Electric Vehicle
↓ CCS / CHAdeMO / Type 2
Charging Station (Charge Point)
↓ OCPP 1.6/2.0.1 WebSocket
Central System (CSMS) — Everest, ChargePoint, EVCC, or custom
↓ REST API / WebSocket
Mobile App
We have completed over 20 projects for charging network operators. Our engineers are certified on OCPP 2.0.1 and have migrated 1.6 systems without downtime. We use GitLab CI/CD for automated builds and deployments.
Real-Time Monitoring via Persistent Connection
Key session data: connector status, power (kW), energy (kWh), duration, vehicle SoC (OCPP 2.0.1). The app subscribes to events using a WebSocket connection to the CSMS. WebSocket connections are 10x more efficient than polling for real-time updates.
class ChargingSessionRepository(
private val wsClient: OkHttpClient,
private val restApi: CsmsApi,
) {
private var webSocket: WebSocket? = null
private val _sessionFlow = MutableStateFlow<ChargingSession?>(null)
val sessionFlow: StateFlow<ChargingSession?> = _sessionFlow.asStateFlow()
fun observeSession(stationId: String, connectorId: Int) {
val request = Request.Builder()
.url(getCsmsWebSocketUrl(stationId)) // e.g., the CSMS WebSocket URL
.header("Authorization", "Bearer $accessToken")
.build()
webSocket = wsClient.newWebSocket(request, object : WebSocketListener() {
override fun onMessage(webSocket: WebSocket, text: String) {
val event = json.decodeFromString<StationEvent>(text)
when (event.type) {
"MeterValues" -> _sessionFlow.update { current ->
current?.copy(
currentPowerKw = event.payload.activePower,
energyDeliveredKwh = event.payload.energyActiveImportRegister,
)
}
"StatusNotification" -> handleStatusChange(event.payload.status)
"TransactionEvent" -> handleTransactionEvent(event.payload)
}
}
override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
// Exponential backoff for reconnection
scheduleReconnect(stationId, connectorId, t)
}
})
}
}
Remote Start Transaction
One of the most common flows. User scans the QR code on the station, the app sends a remote start request to the CSMS:
func startCharging(stationId: String, connectorId: Int) async throws -> Transaction {
let request = RemoteStartRequest(
connectorId: connectorId,
idTag: currentUser.rfidToken, // user token for station authorization
chargingProfile: ChargingProfile(
chargingProfilePurpose: .txProfile,
chargingSchedule: ChargingSchedule(
chargingRateUnit: .watts,
chargingSchedulePeriod: [
ChargingSchedulePeriod(startPeriod: 0, limit: 11000) // 11 kW
]
)
)
)
return try await csmsClient.remoteStart(stationId: stationId, request: request)
}
In OCPP 1.6, RemoteStartTransaction.conf returns Accepted or Rejected — only confirming the command was received, not that charging started. The actual session start comes via a separate StartTransaction.req from the station to the CSMS. We track status via WebSocket or polling.
Station Map and Roaming
For public networks, we implement a map with clustering, filter by connector type (CCS, CHAdeMO, Type 2) and power. Using OCPI (Open Charge Point Interface) for roaming between operators, the app can show stations from different networks.
On Flutter with Google Maps SDK or MapLibre:
Future<List<ChargingStation>> loadNearbyStations(LatLng center) async {
return _ocpiClient.getLocations(
latitude: center.latitude,
longitude: center.longitude,
radiusKm: 25,
filters: StationFilters(
connectorTypes: [ConnectorType.ccs2, ConnectorType.type2],
minPowerKw: 11,
availableOnly: true,
),
);
}
Clustering via google_maps_cluster_manager prevents performance issues with 500+ markers.
Payment and Tariff Comparison
| Parameter | Per kWh | Per Time | Combined |
|---|---|---|---|
| Transparency for user | High: knows price per kWh | Medium: depends on charging speed | Low: hard to predict total |
| OCPI integration | Supported via TariffElement | Supported | Requires complex logic |
| Motivation to disconnect quickly | None | Yes (to pay less) | Moderate |
| Recommendation | Home/slow charging | Fast charging (50+ kW) | Mixed networks |
OCPI TariffElement supports all options: per minute, per kWh, flat fee, or combinations (e.g., €0.20/kWh + €0.05/min after 30 min). Choice depends on the operator's business model.
Process and Timeline
We follow a structured approach:
- Data collection — gather your CSMS specification, API docs, and infrastructure details.
- Audit & analysis — identify integration points, data models, and OCPP version.
- Design — architecture for WebSocket events, REST APIs, and UI mockups.
- Estimation — provide a fixed-price quote after analysis (no hidden costs).
- Development — implement app features, API integration, and admin panel.
- Testing — simulate with open-source CSMS (EVCC, SteVe, Everest) and real hardware.
- Deployment — CI/CD pipeline, app store submission, and knowledge transfer.
Timeline Estimates
- Integration with existing CSMS — 4–6 weeks.
- Full app from scratch (map, payment, OCPI roaming) — 3–4 months.
- Typical payback period — 6–9 months after launch.
- Our clients report saving €18,000 annually on operational costs after deploying the app.
- Development cost for a full-featured solution starts at €55,000 with a 300% ROI within the first year.
- Operators can save up to €12,000 per year per 100 stations with our solution.
What's Included
- Source code (iOS/Android/Flutter)
- Integration documentation
- Admin and user manuals
- Repository access with CI/CD
- 2 days of online training for your developers
- 3 months of post-release support
Typical Mistakes to Avoid
- Polling instead of WebSocket — polling scales poorly and misses real-time updates. Always use persistent WebSocket connections for station events.
- Ignoring reconnection logic — without exponential backoff, network drops lead to silent data loss. Implement automatic reconnection with state recovery.
- Assuming RemoteStartTransaction means charging started — always confirm via TransactionEvent or MeterValues before showing success to the user.
Our clients report a 20% reduction in operational costs after deploying the mobile app — that's 4 times better than basic monitoring solutions. With over 1,000 sessions processed daily, the system handles 99.9% uptime. The starting point is a free consultation: send us your current infrastructure description, and we'll prepare a commercial proposal within two business days. Get a consultation on integrating with your CSMS today.