Building My Side Project for 8 Years: The FUT Maidaan Story
Seven years of scrolling cluttered FUT apps taught me one thing: nobody was going to clean up the mess for me. So I built FUT Maidaan—and shipped it to both app stores as a solo developer.
Most developers work on side projects for a few months before moving on to the next idea.
I spent 8 years building the same side project (FUT Maidaan) while working my regular job.
Here’s why I stuck with one idea for so long and what it taught me about persistence, user experience, and building something from scratch.
The Problem That Wouldn’t Leave Me Alone
The story starts in 2016 when I was deep into FIFA Ultimate Team. Like millions of other players, I relied on third-party apps to check player stats, prices, and build my dream squad.
But every app I used frustrated me in the same ways.
The player cards were cluttered messes. Apps would show three different card styles - minimal, regular, and large - depending on screen space. But none of them displayed the information I actually needed clearly.
I wanted to see league, club, nation, position, name and rating at a glance. Instead, I got cramped layouts where critical details were barely visible.
BTW, Look at the ads. Just bloated through out the app.
The filters were even worse. These apps threw every possible filter at you, most of which no one ever used. Want to select a club after choosing a league? You’d have to navigate through the entire league selection again. Well, they are much improved in newer app but still user has to type in to the club name. Not a fast or intuitive way.
For example, I selected Premier League and I see all clubs to select from. Either I type in or scroll a long list of clubs.
The interface felt like it was designed by someone who had never actually played the game.
But the biggest problem wasn’t what these apps showed - it was what they didn’t show. No one was tracking market trends the way financial apps track stock indices. Players would rise and fall in value, but there was no way to understand the broader market movements across different positions.
I knew I could build something better. But knowing and doing are separated by years of work, false starts, and steady persistence.
The Seven-Year Struggle
The first roadblock hit immediately. Player data wasn’t freely available.
EA Sports had APIs until FIFA 22, but they were limited and didn’t include prices - that is the most crucial information for any FUT player. I built prototype after prototype using Android native and Flutter, each one getting scrapped when I couldn’t access the data I needed.
For years, this cycle continued. I’d get excited about a new approach, a new workaround, spend weeks building, then abandon the project when I couldn’t access the data I needed.
I accumulated many unfinished projects, each teaching me something new but none reaching completion.
The breakthrough came in 2023-24 when I finally found an API that provided both player data and pricing. It had rate limits and wasn’t perfect but it was enough to get started again.
Seven years after starting, I could finally build the app I’d been imagining.
Rethinking Everything From Scratch
But having the data was just the beginning. Now I had to solve the design problems that had bothered me for so long.
I threw out the traditional FUT card approach entirely. Instead of cramming information into card layouts, I created clean list tiles that displayed all essential information clearly.
The card colors became subtle rating box backgrounds and borders, giving visual distinction without sacrificing readability.
For the player detail pages, I eliminated the redundant information that plagued other apps. Why show the same stats twice?
I designed each page like a product page, using the card’s color scheme as an intelligent theme throughout the interface. Players could understand what type of card they were viewing without seeing the actual card cluttering the screen.
The filter system got a complete rethink. I removed every filter I’d never used in seven years of playing FIFA. The remaining filters became contextual - select a league, and you’d only see clubs from that league.
No more navigating through irrelevant options.
The Innovation That Solved a Real Gap
The feature I am most satisfied with was the index system.
Taking inspiration from stock market indices, I created separate indexes for forwards, midfielders, defenders, and goalkeepers. These indexes tracked market trends in each position, giving players insights no other app provided.
For the first time, you could see how the entire midfielder market was performing, not just individual players.
Building Solo: Every Hat, Every Decision
The technical architecture had to support 18,000+ players with complex filtering and real-time price updates. I chose Flutter for cross-platform development and Supabase for its unlimited read/write capabilities.
The mono-repo structure kept everything organized and maintainable.
My wife Preeti, who has a background in development and product management, collaborated with me on the design work. I drew the initial sketches and wireframes, but she developed the main color palette and created the logo entirely.
The logo was completely her vision - she took my rough concept of incorporating football elements and crafted the elegant F and M design where the F forms a player with a football. Her color choices ensured the app worked beautifully in both light and dark themes.
Building solo meant wearing every hat. I was the business analyst defining requirements, the product manager prioritizing features, the developer architecting the system, the designer crafting the interface, and the release engineer publishing to app stores.
The Real Education
The development process taught me more about persistence than any corporate project had before. When you’re building something completely on your own, every decision carries weight.
There’s no product manager to blame for poor requirements, no designer to blame for confusing interfaces. The responsibility is entirely yours.
Firebase Test Labs caught performance issues on low-end devices. Apple’s review process flagged copyright concerns on the second release, forcing me to navigate complex intellectual property questions as a solo developer.
Google Play Store required multiple submissions to meet their quality standards.
Each obstacle required careful problem-solving because I was responsible for finding the solutions. This wasn’t a client project with external deadlines and budgets. This was seven years of evenings, weekends, and consistent belief that I could build something better.
Launch and Beyond
The app launched with player listings, detailed player pages, search functionality and my innovative filter system. The index feature worked exactly as I’d envisioned, updating daily through scheduled Supabase edge functions.
The clean interface finally solved the cluttered mess that had frustrated me for years.
But launching was just the beginning. The roadmap includes player comparisons, AI-powered search, pack opening simulations, squad building, and even gameplay between users.
Each feature represents months of additional work, but the foundation is solid enough to support ambitious expansion.
What Seven Years Taught Me
Working evenings and weekends for seven years while maintaining a full-time job required consistent dedication. I’d hit points where I didn’t want to touch the code but motivation always returned.
The idea stayed with me throughout.
This experience taught me something valuable about building products. Most developers create smaller apps or quick projects. But there’s something deeply rewarding about building something substantial entirely yourself.
Every line of code, every design decision, every feature prioritization reflects your vision without compromise.
The app hasn’t made me rich or famous yet. User acquisition is its own challenge, requiring skills I’m still developing. But that misses the point.
The real value was in the building itself.
Seven years of thinking about user experience made me a better designer. Architecting a complex Flutter application from scratch made me a better developer. Managing every aspect of product development made me understand how software truly gets built.
Building FUT Maidaan taught me that persistence often matters more than talent, that understanding user needs beats adding features, and that building something entirely your own provides a unique kind of satisfaction.
The app exists because I wasn’t willing to accept that cluttered, poorly designed software was good enough. Seven years later, that decision led to both a better product and valuable learning experiences.
Taking the longer path often teaches you the most important lessons.
Building something this complex solo required architectural decisions that would either make or break the entire project. The mono-repo structure I chose became the foundation that allowed me to iterate quickly, maintain clean separation of concerns, and scale from a simple prototype to a production app handling 18,000+ players.
How do you architect a Flutter app so it can grow from MVP to a feature-rich platform without collapsing under its own complexity? The answer lies in understanding how to structure packages, manage dependencies, and create boundaries that prevent your codebase from becoming an unmaintainable mess.
In Next Post, I’ll walk you through the exact mono-repo architecture that powered FUT Maidaan. You’ll see how I organized features, core utilities, and design systems into separate packages. More importantly, you’ll understand the thinking behind each decision and how this structure enabled me to add major features without rewriting existing code.
Whether you’re building your first serious Flutter project or refactoring an existing app that’s become difficult to maintain, this architecture pattern will change how you think about organizing your code.