In 2018, I started building LoaderApp.
At the time, it was a relatively simple mobile application. Like many side projects, I expected to work on it for a few months before moving on to something else.
Instead, I'm still maintaining and improving it in 2026.
Over the last eight years, the app has survived:
- Multiple React Native releases
- Android API changes
- iOS platform changes
- Dependency deprecations
- Store review policy changes
- Countless feature requests
- More bugs than I'd like to admit
Here's what I learned.
Choosing React Native Was the Right Decision
One of the biggest reasons LoaderApp is still alive today is React Native.
Maintaining separate native codebases would have required significantly more effort for a solo developer.
While React Native isn't perfect, it allowed me to:
- Ship features faster
- Share most business logic
- Support multiple platforms
- Iterate without a large team
The productivity gains outweighed the drawbacks.
Dependencies Are Your Biggest Long-Term Risk
When starting a project, adding a package feels free.
Years later, every dependency becomes a maintenance responsibility.
Some packages were abandoned.
Some broke after platform updates.
Others required major migrations.
If I could start over, I'd be much more conservative with dependencies.
Store Policies Change Faster Than Code
One thing many developers underestimate is how much app stores evolve.
Features that seem acceptable today may become problematic later.
Maintaining a long-lived application means continuously adapting to changing platform expectations.
Technical debt isn't the only debt. Policy debt is real too.
Backward Compatibility Matters
Users rarely care that you rewrote a subsystem.
They care that:
- Existing downloads still work
- Settings remain intact
- Upgrades don't break workflows
The longer an app exists, the more important migration paths become.
The Hardest Part Isn't Coding
The hardest part is continuing.
After the initial excitement disappears, maintaining momentum becomes the real challenge.
Most side projects die not because of technical problems, but because their creators stop working on them.
Longevity itself becomes an advantage.
What I'd Do Differently
If I started again today:
- Write more tests
- Reduce dependencies
- Build clearer abstractions
- Invest earlier in automation
- Spend more time on analytics
Many mistakes only become visible after several years.
Advice for Indie Developers
Don't optimize for launch day.
Optimize for year three.
Most technical decisions look different when you expect to maintain the project for nearly a decade.
A project that survives is often more valuable than a project that launches perfectly.
Closing Thoughts
LoaderApp is very different from the application I started building in 2018.
Some parts have been rewritten multiple times.
Some features have disappeared.
Others have become core functionality.
But the most important lesson remains the same:
Shipping is important.
Continuing to ship is what compounds over time.
Website: https://loaderapp.info
