| Stack | Role | Year | Status |
|---|---|---|---|
| Kotlin Multiplatform, Android, Ktor, PHP, Laravel, REST API | Lead Full-Stack & Mobile Software Engineer | 2026 | Hosted & Operational on Android (Rolled out 1 November 2026; iOS planned) |

Mobile Token Retrieval Experience
Customer-facing Kotlin Multiplatform mobile application (targeting Android and iOS, with Android completed and operational; iOS planned) and PHP/Laravel backend API for retrieving previously purchased prepaid electricity tokens. Rolled out on Android to all users on 1 November 2026.
Mobile Token Retrieval Experience is a hosted, operational customer-facing mobile application and backend API rolled out to Android users on 1 November 2026 and actively used in production. Architected around a Kotlin Multiplatform design targeting Android and iOS, the current production implementation delivers a complete native Android client with shared Ktor networking and domain logic, backed by a modular PHP/Laravel REST API. The system provides a reliable self-service channel for customers to retrieve previously purchased prepaid electricity tokens when standard SMS delivery channels are unavailable or delayed.
1. Overview
The Mobile Token Retrieval Experience is a hosted, operational customer-facing mobile application and backend API that was rolled out on Android to all users on 1 November 2026 and is actively used in production. The system provides an alternative self-service channel for customers to retrieve previously purchased prepaid electricity tokens when normal delivery channels (such as SMS) fail or are delayed. This system is strictly a token retrieval application and supporting backend API; it is not an electricity vending or payment processing platform. It focuses on reliable, low-friction access to existing token records on Android, with iOS planned on the architecture roadmap.
2. Engineering problem
When customers purchase prepaid electricity tokens, standard delivery channels can experience delays or delivery failures, or customers may misplace a previously delivered token. Without a self-service retrieval mechanism, customers must contact support to look up their meter history. From a systems engineering standpoint, the existing token-record system of record could not be queried directly from customer mobile devices. Exposing it directly would have introduced credential security risks, coupled the mobile client to internal upstream data formats and exposed the system of record to unthrottled external traffic. Additionally, customers frequently needed clarity between tenant/submeter token lookups, primary-meter token lookups and landlord portal workflows.
3. Architecture
The system is structured around three clearly separated tiers: - Mobile Application: Built on a Kotlin Multiplatform architecture targeting Android and iOS, with the Android client completed and deployed to all users on 1 November 2026 (iOS implementation is planned). Presentation logic, domain state, Ktor HTTP networking and API serialization models are shared in Kotlin, paired with Android platform integration and anonymous application instance identification. - Backend API: Built with PHP and Laravel as a modular monolith with domain-oriented separation between customer retrieval workflows and administrative functionality. - Upstream System Integration: Server-side HTTPS integration between the Laravel backend and the existing external token-record system, translating upstream records into normalized REST responses.
4. Mobile implementation (Android completed, iOS planned)
The mobile client architecture leverages Kotlin Multiplatform to centralize business logic, meter input validation, retrieval state transitions and Ktor HTTP networking models in shared Kotlin code. The current production delivery is exclusively implemented, tested and deployed for Android, integrating with Android platform services for clipboard access, screen lifecycle and anonymous device instance identification. While the shared codebase is structured to target both Android and iOS, the iOS client implementation has not yet been built or released and remains on the product roadmap. Implemented Android capabilities include: - Meter-number-based prepaid electricity token retrieval with client-side formatting. - Tenant/submeter and primary-meter lookup pathways. - Landlord guidance views to help property managers assist tenants. - High-contrast token presentation with one-tap clipboard copying. - Offline persistence of previously retrieved tokens via local storage. - Graceful handling of network timeouts and upstream 5-token window limitations.
5. Backend implementation
The backend is implemented in PHP using Laravel as a modular monolith with domain-oriented separation. Retrieval workflows, upstream integration adapters and administrative functionality are separated into distinct modules with explicit interfaces. The REST API exposes dedicated endpoints for meter token lookups. Request schema validation, per-instance rate limiting and consistent error formatting are enforced before any upstream call is made.
6. API integration
Rather than letting the mobile client understand the upstream token-record system, the Laravel backend acts as an anti-corruption and normalization layer. When a validated retrieval request arrives, the backend queries the external token-record system over HTTPS, maps the upstream response into a clean, consistent JSON contract and returns only the fields required by the mobile client. This normalization simplifies mobile client deserialization, prevents upstream schema quirks from leaking into mobile code and allows backend engineers to adjust upstream integration details without requiring a mobile app update. Capability Status Clarification: While immediate meter-based lookups, primary-meter retrieval, and tenant/submeter flows are fully implemented and live in production on Android, extended multi-month historical archive retrieval workflows are explicitly documented as blocked due to upstream system interface limitations that do not support the required date-range filtering and pagination operations.
7. Security considerations
Security boundaries were designed around untrusted client networks and upstream system protection: - Upstream credentials and integration secrets are kept strictly server-side within the Laravel environment and are never embedded in the mobile application. - All mobile-to-backend and backend-to-upstream communication is encrypted over HTTPS. - Request validation and rate limiting at the REST API boundary protect both the backend and the upstream system of record from malformed queries and automated abuse. - Anonymous application identification allows abuse monitoring and rate limiting without forcing customers to create accounts or submit unnecessary personal information.
8. Performance considerations
Customer token retrieval is time-sensitive, often performed when electricity units have run out. To keep retrieval responses fast and predictable: - Operational analytics and request telemetry are decoupled from the primary retrieval response so logging never blocks or fails token delivery to the customer. - Server-side response normalization trims redundant payload fields, reducing payload size over mobile networks. - Invalid meter formats are rejected early on both the client and API boundary, avoiding unnecessary upstream round-trips.
9. Production rollout
The Mobile Token Retrieval Experience is a hosted, operational production system on Android. Following end-to-end verification of the Android mobile client, the Laravel backend API and the server-side integration with the token-record system, the application was rolled out to all users on 1 November 2026 and is actively used by customers. The rollout currently serves Android devices, while the planned iOS client build remains in the architectural pipeline.
10. Technology stack
Mobile: Kotlin Multiplatform (architecture targeting Android & iOS), Android (completed implementation & deployment), Ktor HTTP client, kotlinx.serialization, Android platform integration (iOS planned). Backend: PHP, Laravel, Modular Monolith architecture, REST API. Integration & Security: Server-side HTTPS upstream integration, normalized JSON contracts, request validation, rate limiting, anonymous application instance identification.
11. My engineering contribution
I designed and implemented the Kotlin Multiplatform mobile architecture and the production Android application, alongside the supporting PHP/Laravel backend API. My responsibilities covered defining the gateway separation between the retrieval service and the existing system of record, building the shared Kotlin domain and Ktor networking layer, implementing the native Android user interface and platform integrations, developing the Laravel modular monolith and server-side upstream integration, enforcing request validation and rate limiting, and delivering the Android production rollout on 1 November 2026 (with iOS planned for future implementation).
Key Technical Terms
- Backend-Mediated System-of-Record Isolation:The mobile client never communicates directly with the upstream token-record system. A dedicated Laravel REST API holds upstream credentials server-side, validates meter requests and returns a normalized contract.
- Shared Kotlin Multiplatform Presentation & Domain Logic:Domain state management, input validation, Ktor HTTP networking and shared API serialization models are architected in common Kotlin code to target both Android and planned iOS platforms. The production release is fully implemented and deployed on Android with clipboard, lifecycle and anonymous instance identification.
- Platform Implementation Status: Android Live, iOS Planned:The client codebase uses Kotlin Multiplatform to establish cross-platform shared domain and networking foundations for Android and iOS. The Android client implementation is fully built, tested and operational in production; the iOS client implementation has not yet been built or deployed and remains planned for future execution.
- Non-Blocking Retrieval Telemetry:Operational logging and analytics are decoupled from the primary request-response path so a slow or failed telemetry write never delays or fails a customer token lookup.
Android Live
Rolled out on Android 1 Nov 2026 (iOS planned)
KMP (Android)
Android client live; shared domain logic & Ktor
Laravel API
Modular monolith mediating system-of-record calls
Server-Side
Upstream secrets isolated behind validated REST endpoints
Key Engineering Takeaways
Isolate legacy or external systems of record behind a dedicated backend API so mobile clients never hold upstream credentials or depend on raw upstream schemas.
Keep analytics and telemetry out of the critical response path so logging issues never block a user-facing retrieval request.
Design self-service utility workflows around the user context—clear meter validation, formatted token display and one-tap copying reduce friction when power is out.
Project Gallery

