Legacy Modernization of a Mobile Reading Platform: From Xamarin to Flutter
Overview of Our Client
Our client was a large digital publishing company providing authors with a platform for creating, publishing, and selling digital books.
For readers, the company offered iOS and Android applications combining an online bookstore, personal library, and feature-rich e-book reader. Users could purchase and download books, read offline, synchronize their reading progress across devices, customize fonts and backgrounds, use text-to-speech, create bookmarks and notes, and interact with authors and other readers.
By the time the modernization project started, the mobile product had been evolving for more than eight years. The applications had accumulated substantial business logic, platform-specific code, integrations, and legacy components.
- Region: Global
- Industry: Digital Publishing / E-books
- Timeline: ~18 months
Challenge
The mobile applications were originally built using Xamarin. When the technology approached the end of its lifecycle, the client decided to begin modernization early enough to complete the migration in a controlled manner.
The main problem was the maturity and complexity of the existing product. Over eight years, the applications had accumulated numerous user flows, integrations, platform-specific implementations, and technical debt. The reading engine itself was also a critical legacy component that required modernization.
At the same time, product development could not be paused during the migration, and a traditional Big Bang rewrite would have introduced significant technical and business risks. The roadmap included major new capabilities such as:
- Interactive books
- Embedded audio and video
- Community discussions and direct interaction with authors
- AI-powered recommendations
- Contextual translation
- AI summarization
- An on-device AI assistant for working with book content
Main Goals
To modernize the mobile platform without interrupting product development, we established the following goals:
- Complete the migration before Xamarin reached end of support
- Preserve existing functionality and user experience
- Move to a modern cross-platform technology stack
- Reduce accumulated technical debt
- Continue delivering new features throughout the modernization
- Minimize platform-specific development
- Improve application maintainability and testability
- Prepare the architecture for interactive, multimedia, and AI-powered functionality
Project Overview
Following a technical assessment, SCAND selected an incremental legacy modernization approach.
The existing Xamarin application remained the production version and continued receiving critical fixes and required updates, while a new Flutter application was developed in parallel.
The Flutter version was created as a new codebase with a modern architecture. Existing backend APIs, data contracts, authentication flows, product requirements, and accumulated knowledge of the application's behavior were reused where appropriate.
Rather than automatically converting C# code into Dart, existing user journeys were progressively recreated and improved on the new technology platform.
For each major component, we applied one of four strategies:
Retain → Refactor → Rewrite → Replace
Such an approach allowed us to preserve proven components where replacement provided limited value while redesigning the areas that restricted future product development.
Solution
SCAND delivered a modern Flutter-based mobile platform for iOS and Android that replaced the legacy Xamarin application.
The new solution introduced a modular cross-platform architecture with shared business logic and native integrations where required. The outdated e-book reader was replaced with the proprietary epuBear SDK, providing reliable EPUB rendering, pagination, navigation, and content processing.
The platform was also designed as a foundation for the client’s next-generation reading experience, supporting interactive books, multimedia content, community features, and future AI capabilities such as personalized recommendations, contextual translation, summarization, and an on-device AI assistant.
Core Capabilities
- Cross-platform mobile application: One Flutter codebase supporting iOS and Android.
- Modern e-book reader: epuBear SDK integration for EPUB rendering, pagination, navigation, and content processing.
- Digital bookstore and library: Browsing, purchasing, organizing, and accessing digital content.
- Offline reading and synchronization: Local access to books with synchronized reading progress and user data.
- Personalized reading experience: Custom fonts, backgrounds, bookmarks, notes, and text-to-speech.
- Interactive and multimedia content: Architecture prepared for interactive books, embedded audio/video, and richer digital formats.
- Modular architecture: Separated presentation, domain, and data layers for improved maintainability and extensibility.
- Native platform integrations: Swift and Kotlin components used where platform-specific functionality was required.
- AI-ready foundation: Architecture prepared for recommendations, translation, summarization, and on-device AI assistance.
- Automated quality controls: Regression and characterization testing supporting reliable releases across both platforms.
User Workflow
- Legacy Assessment: Existing Xamarin functionality, dependencies, business logic, and critical user journeys were analyzed.
- Target Architecture: A modular Flutter architecture was designed for shared iOS and Android development.
- Feature Migration: Application functionality was progressively recreated in Flutter while the Xamarin application remained operational.
- Reader Replacement: The legacy reading engine was replaced with the epuBear SDK and integrated into the new application.
- Testing & Validation: Migrated functionality underwent automated testing, regression testing, and controlled validation.
- Rollout: The Flutter application was introduced through beta testing and staged production deployment.
- Legacy Retirement: Once feature parity and production stability were achieved, the legacy Xamarin application was retired.
Technology Stack
To support cross-platform mobile development, e-book rendering, AI integration, and a controlled modernization process, we used the following stack:
Mobile Development
- Flutter
- Dart
- Riverpod
- go_router
- Dio
- Freezed
- Drift / SQLite
Reader & Native Integration
- epuBear SDK
- Swift
- Kotlin
- Flutter Platform Channels
- Dart FFI
AI & Machine Learning
- ONNX Runtime
- llama.cpp
- LiteRT (formerly TensorFlow Lite)
- OpenAI API
- Python
Quality Assurance
- flutter_test
- integration_test
- Mocktail
- Patrol
- Firebase Test Lab
DevOps & Monitoring
- GitHub Actions
- Fastlane
- Firebase App Distribution
- Firebase Crashlytics
- Sentry
Results
The phased legacy app modernization allowed the client to replace the Xamarin-based mobile platform before the technology reached end of support as well as continue product development throughout the transition. The main outcomes were as follows:
- 100% migration completed before Xamarin end of support
- ~90% shared codebase across iOS and Android
- ~30% shorter feature delivery cycle
- ~45% less time spent on regression testing
- 99.5%+ crash-free user sessions
- ~25% faster migration of repetitive components with AI assistance
Business Value
The project delivered much more than simple Xamarin to Flutter migration. The client received a modern mobile platform that enabled faster product development, provided a unified technology foundation for iOS and Android, and supported the next generation of digital reading functionality.
The incremental approach reduced the risks typically associated with legacy app modernization and allowed product development to continue throughout the transition.
Core Team
- Solution Architect: Designed the modernization strategy and target mobile architecture.
- Mobile Tech Lead: Coordinated Flutter cross-platform mobile app migration.
- Flutter Engineers: Rebuilt application functionality and developed the new shared mobile codebase.
- iOS / Android Engineers: Maintained native integrations and implemented platform-specific functionality in Swift and Kotlin.
- Backend Engineers: Supported existing APIs, data contracts, synchronization, and application integrations.
- AI Engineers: Integrated AI capabilities and supported local/on-device model workflows.
- QA / QA Automation Engineers: Built automated tests and validated feature parity, stability, and cross-platform behavior.
- DevOps Engineers: Supported CI/CD, mobile distribution, monitoring, and production releases.
- UX/UI Designers: Adapted existing user experiences to the new application architecture and modernized mobile interfaces.
Related Cases
- Java
- C#
- C/C++
- React Native
- Mobile
- AWS
- PostgreSQL
- Java