After a year at SiVasDescalzo learning the basics of mobile development, I joined ManoMano in 2022. It was a completely different company: a DIY and home improvement marketplace with millions of users across several European countries.
I entered as a Junior Developer. Three years later, I left as a Senior.
This is the story of how I learned to truly scale a mobile application.
The Context: A Big App, A Big Problem
ManoMano is Europe’s leading DIY marketplace. When I arrived:
- Millions of users monthly active
- Massive catalog: Thousands of products from multiple suppliers
- Multi-country: France, Spain, Italy, Germany, UK, Belgium
- Large team: ~10 mobile developers coordinating features
The app worked. But it had problems.
The Problem: Android Was Slow
Very slow.
The numbers were clear:
- Initial load time: 5 seconds on mid-range Android devices
- App size: Excessively large, affecting downloads
- User experience: Frustrating, especially on slow connections
For an e-commerce app, where every second counts for conversion, this was critical.
Why Android specifically? The diversity of Android devices (from low-end to flagships) and the variety of OS versions made optimizing for everyone a continuous challenge.
My Evolution: From Junior to Senior
Year 1: Learning the System
My first year was all about absorbing:
- Large app architecture: Modules, features, complex navigation
- Team work: Coordination with 10 developers, code review processes
- The business: How a European-scale marketplace works
I worked on features like any junior:
- Screen implementation
- Bug fixes
- Small UI improvements
But the most valuable was understanding how the complete system worked.
Year 2: Specializing in Performance
My second year was where I found my niche: performance and animations.
I realized I could:
- Identify bottlenecks
- Optimize unnecessary renders
- Implement fluid animations without compromising performance
The team needed someone to specialize in this. I volunteered.
The results started coming:
Android Load Time Optimization:
- Before: 5 seconds
- After: 2 seconds
- Improvement: 60%
How?
- Lazy loading of non-critical modules
- Image and asset optimization
- Removal of unnecessary libraries
- Strategic code splitting
App Size Reduction:
- Reduction: 70% of original size
- Impact: More downloads, less friction
How?
- Elimination of unused dependencies
- Aggressive asset compression
- Dynamic assets where it made sense
- Complete bundle audit
Year 3: Technical Leadership
My third year was about consolidation:
- Implementation speed: I had become fast without sacrificing quality
- Complex features: Capable of leading end-to-end projects
- Mentorship: Helping new juniors understand the system
The Monitoring System: Prevent, Don’t React
One of my key contributions was the automatic performance monitoring system.
The concept was simple but powerful:
- Automatic metrics: Every screen tracked its render time
- Defined thresholds: Each screen had a maximum acceptable limit
- Automatic alerts: If a screen exceeded the threshold, an alert was triggered
- Review process: The team reviewed why it happened and if it was acceptable
This system allowed us to:
- Detect regressions before reaching production
- Maintain performance over time
- Make informed decisions about performance trade-offs
We no longer reacted to user complaints. We prevented problems before they existed.
Features I Implemented
Over three years, I worked on projects of varying complexity:
1. Wishlist
Complete system for users to save favorite products:
- Cross-device synchronization
- Price change notifications
- Wishlist sharing
2. Home Revamp
Complete redesign of the main screen:
- New, more modern layout
- Personalized dynamic sections
- Optimized performance (biggest challenge: loading many products without lag)
3. Cart Revamp
Improved checkout experience:
- Clearer UI
- Fewer steps to payment
- Better handling of promotions and discounts
4. VAT Management System by Country
Complex feature due to European regulations:
- Dynamic calculations by country
- Correct prices in multiple currencies
- Edge cases and validations
5. Offers and Eco-friendly Catalogs
- Flash offer system
- Eco-friendly product filters
- Visual badges for sustainable products
Business Impact
My specialization in performance and implementation speed had direct impact:
Adaptability to Scope Changes: In a large company, product requirements change constantly. My ability to pivot quickly without compromising quality became valuable.
Reliability: The features I delivered worked. In production. For millions of users. Consistently.
Sustained Performance: The monitoring system ensured optimizations lasted. It wasn’t just “fix and forget”.
The Demanding Environment: The Best School
ManoMano had two extremely demanding tech leads.
Their code reviews were legendary:
- Rejected PRs: If your code didn’t meet standards, back to the drawing board
- Iterative feedback: “This can be better” really meant “redo it”
- Design patterns: You were expected to use best practices, not quick solutions
- No exceptions: Junior or senior, standards were the same
At first it was frustrating. Why reject a PR that works?
Over time I understood: working wasn’t enough. It had to:
- Be maintainable
- Follow project patterns
- Be well tested
- Be efficient
This demanding environment prepared me for the future. It taught me to be demanding with myself.
Today, when I review my own code, I hear the voices of those tech leads: “Can this be better? Then make it better”.
Lessons Learned
1. Technical Excellence Requires Discipline
It’s not enough to write code that works. You have to write code that:
- Works today
- Works tomorrow
- Is easy to maintain by others
- Is efficient
This discipline doesn’t come naturally. It’s learned in environments that demand it.
2. Performance Is a Feature
Users don’t see your code. They see if the app is fast or slow.
A slow app with all the features in the world loses to a fast app with fewer features.
Performance isn’t a “nice to have”. It’s critical.
3. Specialization Has Value
In a large team, being “the one who knows X” has enormous value. In my case:
- Performance optimization
- Fluid animations
- Bottleneck identification
This made me more valuable to the team and accelerated my growth to senior.
4. Systems Prevent Problems
The performance monitoring system was more valuable than a thousand one-off optimizations.
Good systems scale. One-off solutions don’t.
5. Growth Comes from Demand
Working in a demanding environment, with tech leads who don’t accept mediocrity, exponentially accelerated my growth.
If all your PRs are easily approved, you’re probably not growing fast enough.
Final Results
After three years at ManoMano:
- ✅ Load time: 5s → 2s (60% improvement)
- ✅ App size: 70% reduction
- ✅ Monitoring system: Implemented and working
- ✅ Multiple features: Wishlist, revamps, VAT system, offers, catalogs
- ✅ Promotion: From Junior to Senior Developer
- ✅ Preparation: Ready for the next challenge
ManoMano was my MBA in scaled mobile development.
Final Thoughts
Scaling an app isn’t just about technology. It’s about:
- Processes: Code reviews, CI/CD, testing, monitoring
- Team: Coordination, communication, shared standards
- Mindset: Thinking about millions of users, not individual use cases
- Excellence: Never settling for “it works”, always seeking “it works well”
ManoMano taught me all this. But more importantly, it taught me that demanding environments, though tough, are where real growth happens.
If SiVasDescalzo was my introduction to mobile development, ManoMano was my master’s degree.
And it prepared me perfectly for what would come next: being the mobile expert at a startup that desperately needed one.
Looking to grow as a developer? Seek demanding environments. Seek tech leads who reject your code. Seek complex problems at scale. Growth doesn’t come from comfort.