Migrating Legacy Apps to Flutter

Legacy mobile applications built on native Java/Objective-C, Xamarin, or Cordova face mounting challenges — dual-codebase maintenance costs, difficulty hiring developers for aging frameworks, and inability to deliver the smooth 60fps experiences that users expect. Flutter's single-codebase approach delivers native performance on iOS, Android, web, and desktop while reducing development costs by 30-50%.

In 2025-2026, Flutter powers over 1 million published apps including major enterprise applications from Google, BMW, Alibaba, and eBay. Its Impeller rendering engine, robust plugin ecosystem, and hot reload development workflow make it the leading choice for legacy app modernisation. This guide provides a structured migration framework covering assessment, strategy selection, and production deployment.

Before migration, systematically evaluate your existing application:

• Feature Inventory: Document every screen, user flow, and feature — prioritise by business value and usage frequency. Features used by 80%+ of users are migration-critical; rarely-used features can be deferred or redesigned.
• Dependency Mapping: Identify all native libraries, SDKs, and platform-specific integrations (push notifications, in-app purchases, analytics, crash reporting). Verify Flutter equivalents exist in pub.dev or plan platform channel bridges.
• Data Layer Analysis: Document local storage mechanisms (SQLite, Core Data, SharedPreferences, Realm), data schemas, and synchronisation logic. Plan migration to Flutter-compatible solutions (sqflite, Hive, Drift).
• API Surface: Catalogue all backend API calls, authentication flows, and real-time connections (WebSockets, SSE). Flutter's Dio and http packages support all standard REST/GraphQL patterns.
• Performance Baselines: Capture current startup time, memory usage, frame rates, and battery consumption — these become comparison metrics for the migrated app.

Choose the migration approach that matches your risk tolerance and timeline:

• Add-to-App (Hybrid): Embed Flutter modules within the existing native app — new screens are built in Flutter while legacy screens remain native. Ideal for large apps where full rewrite is too risky. Use FlutterActivity (Android) and FlutterViewController (iOS) to host Flutter views.
• Incremental Migration: Gradually replace native screens with Flutter equivalents — module by module, starting with the least complex features. Both codebases coexist during transition. Risk is distributed across multiple releases.
• Full Rewrite: Rebuild the entire application in Flutter from scratch — ideal for smaller apps or when the legacy codebase is unmaintainable. Highest initial investment but cleanest architecture. Typical timeline: 3-6 months for medium-complexity apps.
• Decision Matrix: Apps with 50+ screens should use Add-to-App; 10-50 screens can use incremental; under 10 screens justify full rewrite. Team Flutter experience and business continuity requirements are deciding factors.
• Parallel Development: Maintain the legacy app in maintenance mode (critical bug fixes only) while building the Flutter version — avoid feature parity chasing that delays migration indefinitely.

Dart's syntax is familiar to both Java and Swift developers, simplifying translation:

• Object-Oriented Patterns: Dart supports classes, interfaces (abstract classes), mixins, generics, and inheritance — Java patterns translate almost 1:1. Swift's protocols map to Dart abstract classes with minor adjustments.
• Null Safety: Dart's sound null safety requires explicit nullable types (String?) — migrate nullable patterns from Java/Swift with compiler-guided refactoring. This eliminates null pointer exceptions at compile time.
• Async/Await: Dart's Future and Stream replace Java's CompletableFuture and Swift's async/await — asynchronous patterns are syntactically cleaner with Dart's native async/await keywords.
• Serialisation: Replace Gson/Codable with json_serializable and freezed packages for immutable models with automatic JSON serialisation — code generation via build_runner produces type-safe serialisers.
• Dependency Injection: Replace Dagger/Hilt (Android) or Swinject (iOS) with get_it service locator or injectable for compile-time DI — both integrate seamlessly with Flutter's widget lifecycle.

Select state management based on app complexity and team experience:

• Riverpod: The recommended default for new Flutter projects — compile-safe, testable, and supports dependency injection. AsyncNotifierProvider handles API calls with loading/error/data states automatically.
• BLoC (Business Logic Component): Event-driven architecture ideal for enterprise apps — separates UI from business logic with streams. Best for teams migrating from MVVM/MVC patterns in native development.
• Provider: Simpler InheritedWidget wrapper — suitable for smaller apps with straightforward state needs. Lower learning curve than BLoC or Riverpod.
• Architecture Patterns: Implement Clean Architecture with separate data, domain, and presentation layers — repositories abstract API/database access, use cases encapsulate business rules, and ViewModels/Notifiers manage UI state.
• Navigation: Use go_router for declarative, URL-based navigation — supports deep linking, route guards, and nested navigation essential for complex enterprise apps migrating from native navigation controllers.

Platform channels maintain access to native APIs during and after migration:

• MethodChannel: Request-response communication between Dart and native code — call native biometric APIs, hardware sensors, or proprietary SDKs from Flutter. Define channel names and method signatures as a shared contract.
• EventChannel: Stream continuous data from native to Dart — GPS location updates, Bluetooth device data, accelerometer readings, and push notification events.
• Pigeon Code Generation: Type-safe platform channel generation — define APIs in a neutral DSL, generate Dart/Swift/Kotlin boilerplate automatically. Eliminates string-based method names and manual serialisation errors.
• FFI (Foreign Function Interface): Call C/C++ libraries directly from Dart without platform channel overhead — ideal for performance-critical operations like image processing, cryptography, and audio manipulation.
• Plugin Packages: Wrap platform channel logic in reusable Flutter plugins — publish to pub.dev for team-wide consumption or keep as internal packages in a monorepo structure.

Data migration requires preserving user data during the transition:

• SQLite Migration: If the legacy app uses SQLite, the sqflite package reads existing databases directly — schema compatibility allows zero-loss migration. For schema changes, write migration scripts that run on first Flutter app launch.
• SharedPreferences: Flutter's shared_preferences plugin accesses the same underlying storage (NSUserDefaults on iOS, SharedPreferences on Android) — key-value data persists automatically across the migration.
• Realm to Hive/Drift: Realm databases require export-import migration — export to JSON, import into Hive (NoSQL key-value) or Drift (type-safe SQLite wrapper with code generation). Run migration during the first post-update app launch.
• Backend API Layer: Use Dio with interceptors for API communication — token refresh, retry logic, logging, and error transformation. Implement repository pattern to abstract API calls from business logic.
• Offline Sync: Implement offline-first architecture with local database + sync queue — operations queued during offline periods are executed when connectivity returns, with conflict resolution strategies.

Comprehensive testing ensures the migrated app meets or exceeds legacy quality:

• Unit Tests: Test business logic and data layer with Dart unit tests — mock dependencies with mockito or mocktail. Target 80%+ code coverage on domain and data layers.
• Widget Tests: Test individual UI components in isolation — verify rendering, user interactions, and state changes without running on a device. 10x faster than integration tests.
• Integration Tests: End-to-end tests on real devices using integration_test package — verify complete user flows across navigation, API calls, and platform interactions.
• Performance Profiling: Use Flutter DevTools to measure frame rates, memory usage, and widget rebuild frequency — compare against legacy app baselines to verify improvement.
• CI/CD Pipeline: Configure Codemagic or GitHub Actions for automated build, test, and deployment to App Store Connect and Google Play Console. Fastlane integration handles code signing and release management.

MDS provides end-to-end Flutter migration services — from legacy app assessment and architecture design through incremental migration, platform channel development, and production deployment with App Store/Play Store submission.