This post reflects personal learning and experimentation. It does not represent commercial offerings or services.
The Xcode project sat there on a Sunday night. Four months of work. SwiftUI views that had finally been gotten right after countless Stack Overflow searches. CoreData models. A published app with 50 actual users.
And it was about to be deleted.
Not archived. Not "maybe someday." Deleted. Starting over in a language where no production code had been written before.
Was this insane? The app worked. People were using it. Four months of learning SwiftUI, finally paying off - and it was about to be thrown away?
Then the analytics dashboard revealed something. Half the website visitors were on Android. Every single one of them clicked "Get it on Google Play" and found... nothing.
Xcode was closed. A new terminal opened. flutter create gitawisdom was typed.
It was the scariest engineering decision that had ever been made. It was also the best one.
The Decision: Rewrite vs Maintain
Two codebases = double maintenance
Option 1: Keep iOS native, build Android native. Every feature ships twice. Every bug is fixed twice. Every UI change is made twice.
- SwiftUI + Kotlin = 2x work forever
- Feature drift between platforms
- Testing complexity doubles
Half the market is unreachable
The iOS app was working, but it was capped. It could only ever reach iOS users. Half the potential audience was clicking "Get it on Google Play" and finding nothing.
- Android users = lost opportunity
- India market is Android-heavy
- Every day without Android = lost users
One critical question was considered: Does this unlock a new market? The answer was clearly yes. Flutter rewrite meant one codebase, both platforms, double the reach without double the work.
The Options That Were Considered
Three Paths Forward
Option 1: Keep iOS native, build Android native → 2x codebases, 2x maintenance forever Option 2: Keep iOS native, build Android in Flutter → Weird split, inconsistent architecture Option 3: Rewrite everything in Flutter → Throw away working code, but 1x maintenance
On paper, option 1 seems "right" - keep what's working, add what's missing. But as a solo developer, two native codebases means every feature ships twice, every bug is fixed twice.
The Sunk Cost Question
3-4 months of iOS work
The iOS app was real work. SwiftUI views, CoreData models, Combine state management. Walking away felt like waste.
- Working authentication
- Complete UI implementation
- Published in App Store
Prototype, not product
Reframe: The iOS app wasn't wasted - it was a prototype that proved the concept. Now it was time to scale the learnings.
- Product knowledge carries over
- UX decisions are validated
- Backend stays the same
What Actually Happened
The technical translation
6 weeks of focused work. Not starting from zero - translating concepts that were already understood.
- SwiftUI → Flutter widgets
- Combine → Riverpod (upgrade)
- CoreData → Hive (simpler)
- Supabase client → same
The product foundation
Everything that matters for users transferred directly. The rewrite was faster because it wasn't about inventing - it was about translating.
- Same backend (zero changes)
- Same UX flows
- Same content structure
- Same brand/colors
The Results
Within a month of the Flutter version launching on both stores, Android downloads caught up to iOS. Every feature built now reaches twice as many users with the same effort.
When NOT to Rewrite
Platform-specific features
- Heavy HealthKit/ARKit usage
- Custom platform widgets
- Deep OS integration
- Performance-critical graphics
Wrong timing
- Still finding product-market fit
- Have a team (2 native devs = fine)
- iOS-only market (enterprise)
- No Android demand signal
GitaWisdom is a content app with standard UI. There's no reason it needs to be platform-specific. The decision was clear once the right question was asked.
Key Lessons
Framework choice is a force multiplier
The right framework decision echoes forever. One codebase vs two is not 2x difference - it's the difference between sustainable and exhausting.
Reach beats perfection
A Flutter app on both platforms reaches more users than a "perfect" native app on one. The question isn't "how much was invested?" It's "what does the future require?"
The Moment That Made It Worth It
Three weeks into the rewrite, a wall was hit. Flutter's widget tree made no sense. Hot reload kept crashing. SwiftUI's declarative syntax that had finally been understood was missed.
A text was sent to a developer friend: "I think I made a huge mistake."
He replied: "Probably. But you're 3 weeks in. Might as well see it through."
Not exactly inspirational. But he was right. The emotional cost of starting over had already been paid. Quitting now meant having neither a working iOS app nor a Flutter app.
Week 4, something clicked. Flutter's composition model started making sense. By week 5, progress was faster than it ever had been in SwiftUI. Week 6, submissions were made to both app stores.
The moment that made everything worth it came a month after launch. The analytics showed: iOS downloads and Android downloads were nearly equal. 50/50 split.
Every feature built now reaches twice as many users with the same effort. Every bug fix. Every improvement. That's not a one-time win - it compounds forever.
Was the rewrite scary? Yes. Were there doubts? Constantly. Would it be done again?
In a heartbeat.
The sunk cost fallacy is powerful. Months had been spent on the iOS app and it was hard to walk away from. But this wasn't walking away - it was moving forward. Sometimes the best decision is to start over with everything learned.
* * *
Next: Once the Flutter app was ready, it needed approval. That took 6 rejections and was nearly a breaking point . And for the full origin story: how GitaWisdom came to be.