Modernizing Android Development
Introduction
Summary
Cambridge Mobile Telematics (CMT) delivers a suite of white-label mobile applications for partners worldwide, each tailored to distinct branding, functionality, and user experience requirements. This ability to tailor applications to specific partner needs has long been a cornerstone of CMT’s product strategy.
Challenge
As the platform expanded, maintaining both the flexibility necessary for partner customization and the efficiency required for rapid feature delivery became increasingly challenging.
Plan
To address these challenges, the engineering team initiated a comprehensive modernization of the Android platform. The effort focused on evolving the codebase into a Kotlin-first, declarative, and reactive architecture combining modern Android frameworks with a modular foundation designed for scalability, consistency, and rapid development.
The modernization centered on four primary objectives:
- Establish a unified UI foundation
- Adopt reactive data pipelines
- Implement a modular architecture
- Streamline build and dependency management
Results
The result is a scalable, maintainable, and future-ready Android ecosystem that accelerates feature delivery and enables CMT to continue offering partner-tailored mobile experiences efficiently and reliably.
Why Kotlin-First, Declarative, and Reactive
CMT adopted a Kotlin-first strategy to unify Android development under a concise, expressive, and type-safe language optimized for modern platform evolution. Kotlin’s seamless interoperability with existing Java components enabled a gradual migration without disruptive rewrites, preserving stability while modernizing the codebase. Its first-class support in Android Studio, combined with an active ecosystem and continuous language evolution, makes it a strategic long-term foundation aligned with Google’s Android roadmap.
- Concise, Expressive, and Type-Safe by Design
Null safety and modern syntax reduce runtime errors, improve readability, and eliminate boilerplate across all architectural layers. - Smooth Migration from Legacy Systems
Full Java interoperability enabled incremental modernization without large-scale rewrites. - Modern Concurrency and Structured Asynchrony
Coroutines provide structured concurrency, improving lifecycle management, performance, and reliability. - Architectural Expressiveness
Sealed classes, extension functions, and data classes strengthen domain modeling and maintainability. - Declarative and Reactive Enablement
Kotlin forms the foundation for Jetpack Compose (declarative UI) and Flow (reactive data streams), enabling unidirectional state-driven architecture. - Modern Persistence Foundation
Kotlin powers Jetpack DataStore with kotlinx-serialization, delivering type-safe, versionable, and reactive local storage. - Platform Alignment and Long-Term Sustainability
The ecosystem alignment ensures CMT remains consistent with Google’s development direction, enabling faster, safer, and more consistent feature delivery across multiple partner-branded applications.
How we did it
UI Foundation: Jetpack Compose and the CMTUI Module
CMT’s Android platform supports a wide range of partner-specific visual identities, each requiring customized branding and layouts. Over time, XML-based layouts and manually bound views made it difficult to maintain consistency and reuse components across applications. To streamline UI development while preserving partner differentiation, CMT adopted Jetpack Compose as the core UI framework and introduced the CMTUI module, a shared design system and component library.
Compose’s declarative approach enables developers to define UI elements as composable functions, as each element can be themed and parameterized. Compose supports CMT’s white-label model, enabling design flexibility for partners without sacrificing engineering consistency, reducing boilerplate and making component behavior easier to test and maintain. The CMTUI module centralizes all core components—such as buttons, dialogs, cards, and typography—into a single, reusable library. Each component supports theme-based customization, enabling partner apps to maintain their brand identity while sharing a consistent underlying logic and behavior.
By combining Compose and CMTUI, CMT achieved both consistency and flexibility. Teams can build new screens by assembling pretested components, apply partner-specific themes through a configuration layer, and deliver updates faster across the product ecosystem. This approach has reduced UI development time by approximately threefold while ensuring consistent quality and accessibility across all white-label applications.
Reactive Data Layer: Kotlin Coroutines and Flow
The previous data architecture, based on callbacks and LiveData, introduced complexity in managing asynchronous operations and UI lifecycle events. As applications became more interactive and data-driven, maintaining responsiveness and consistency across modules required a more robust solution.
The engineering team adopted Kotlin Coroutines and Flow to implement a fully reactive data layer. This approach establishes unidirectional data flow between repositories, ViewModels, and UI components. ViewModels expose state via StateFlow, which Jetpack Compose automatically collects and renders, eliminating the need for manual observers and simplifying lifecycle management.
The combination of Coroutines and Flow provides structured concurrency, readable asynchronous code, and fine-grained control over data streams. This architecture enhances testability, eliminates race conditions, and ensures that data updates propagate instantly to the UI across all partner applications.
The result is a reactive, lifecycle-aware system that delivers higher stability, greater responsiveness, and a cleaner codebase aligned with modern Android best practices.
Modern Persistence with DataStore and kotlinx-serialization
Managing a diverse set of partner configurations, user preferences, and feature toggles required a more robust and scalable persistence layer. The legacy SharedPreferences model provided limited structure and lacked versioning, thereby increasing the risk of serialization errors and data inconsistency across different versions.
CMT replaced SharedPreferences with Jetpack DataStore integrated with kotlinx-serialization, providing type-safe, versionable, and reactive local data storage. Configuration data is now modeled as serializable Kotlin objects, enabling schema evolution without breaking existing preferences. DataStore’s Flow interface also allows for real-time updates—ensuring that any change in user settings or partner-specific configuration is immediately reflected in the UI.
This modernization reduced manual parsing and migration overhead, improved safety through compile-time checks, and standardized configuration management across the platform. The persistence layer now supports both reliability and adaptability, ensuring smooth evolution as the platform continues to grow.
Build and Dependency Management with Gradle Version Catalog
As CMT’s Android platform evolved, managing dependencies across multiple modules and product flavors became increasingly complex. Each module maintained its own library versions, resulting in version drift, longer upgrade cycles, and occasional build conflicts.
To improve reliability and streamline dependency updates, CMT implemented Gradle’s Version Catalog, consolidating all dependencies and plugin definitions into a single TOML configuration file. This system, supported by a custom build-logic plugin written in Kotlin DSL, provides a single source of truth for dependency management across the platform.
This approach ensures version consistency, simplifies upgrades, and strengthens CI/CD reliability. Since the adoption of the Version Catalog, dependency conflicts have been fully eliminated and build maintenance has become faster and more predictable. This modernization has simplified multi-variant build pipelines and improved release reliability across white-label products.
Modularization for Scalability and Efficiency
CMT restructured its Android codebase into a domain-oriented modular architecture to support parallel development and faster releases. Monolithic modules were decomposed into smaller, self-contained units, each encapsulating its own Configuration, Domain, ViewModel, and Data layers.
Core libraries such as :Core, :Common, and :SDK now provide shared functionality that can be reused across applications. This structure enables multiple teams to develop, test, and release features independently, while maintaining a consistent and stable platform foundation.
The modularization has reduced build times by approximately 30%, improved test isolation, and made it easier to scale the platform to support new partners and products without impacting existing implementations.
Results and Measured Impact
CMT’s modernization initiative delivered tangible improvements across performance, developer experience, and scalability. UI development time has been reduced by up to threefold through Compose and CMTUI; build times have improved by approximately 30% due to modularization; and boilerplate code has decreased by 40% with Kotlin’s expressive syntax and declarative patterns. Dependency conflicts have been eliminated following the introduction of Gradle’s Version Catalog, and onboarding time for new developers has been reduced significantly.
Beyond quantitative gains, the initiative has strengthened the platform’s ability to scale. Teams can now develop partner-specific features independently, manage configurations dynamically, and roll out updates with confidence. The resulting architecture combines flexibility for customization with consistency in performance and quality across all partner deployments.
The modernization has delivered measurable engineering and business outcomes: reusable components accelerate development, modular codebases improve testability, and the lightweight design ensures long-term maintainability.
| Benefit | Description |
| ♻️ Reuse | One-time setup used across many features |
| 🚀 Productivity | No reinventing the wheel per feature |
| 🧪 Testable | Each module is tested independently |
| 📦 Lightweight | Small, focused components |
Conclusion
CMT’s Android modernization initiative represents a strategic investment in scalability, maintainability, and engineering excellence. By adopting Kotlin-first, Jetpack Compose, Coroutines, DataStore, and Gradle’s Version Catalog, CMT has established an architecture that supports rapid innovation while maintaining strong alignment with Android’s modern development practices.
This Kotlin-first, declarative, and reactive architecture empowers CMT to deliver partner-tailored applications efficiently, maintain a unified codebase, and accelerate the release of new capabilities. It provides a durable foundation for future growth, positioning CMT’s Android platform to continue leading in performance, flexibility, and developer experience.