How I Scaled My App to 200K+ Users – A Case Study of Haiyvee

Scaling a mobile application from a few thousand installs to 200K+ active users is a journey filled with technical challenges, business decisions, and countless iterations. In this case study, I’ll share how we built and scaled Haiyvee, a social and dating app, to handle high traffic while still delivering a smooth user experience.

From infrastructure choices to feature optimizations, this blog will serve as a practical roadmap for founders, developers, and startups planning to grow their apps beyond MVP stage.

1. Starting Point – The MVP Stage

Haiyvee started as a React Native mobile app backed by a Node.js + Express + MongoDB stack. Our initial goals were:

1. Build fast with limited resources.
2. Validate the core idea: real-time chat, media sharing, and nearby user discovery.
3. Keep costs low by using a single VPS server for app + database.

Early learnings

1. User engagement was high, but server performance degraded after ~2K concurrent users.
2. Media uploads (images, short videos) spiked bandwidth usage.
3. Lack of caching caused slow response times on popular features.

2. Scaling the Backend Infrastructure

Migration to AWS

To prepare for scale, we migrated the backend to AWS EC2 instances behind a Load Balancer (ALB) with Auto Scaling Groups.

1. Before: Single server, frequent downtime during spikes.
2. After: Multiple nodes scaled automatically based on CPU & memory metrics.

Database Optimizations

1. Migrated from a single MongoDB instance to a replica set with primary + secondaries.
2. Added 2dsphere indexes for location queries (nearby users).
3. Used Redis caching for frequently accessed data (profiles, feed posts).

Media Storage

1. Shifted to AWS S3 + CloudFront CDN for images & videos.
2. This reduced load on the app servers and improved global performance.

3. Handling Real-Time Chat at Scale

The most critical feature was real-time messaging. Initially, we used Socket.IO on a single server, which couldn’t handle scale.

Solution:

1. Deployed Socket.IO with Redis adapter for horizontal scaling.
2. Introduced Kafka for message queueing to ensure reliability under spikes.
3. Optimized event payloads (sending only required fields).

Impact: Smooth messaging experience even at 25K concurrent socket connections.

4. Optimizing for User Growth

Push Notifications

1. Integrated FCM (Firebase Cloud Messaging) for reliable notifications.
2. Used AI-based segmentation to avoid spamming and improve retention.

Performance Monitoring

1. Added New Relic + ELK stack for log aggregation.
2. Proactively detected memory leaks, query bottlenecks, and slow endpoints.

In-App Performance

1. Used React Native Reanimated 3 for buttery-smooth animations.
2. Optimized FlatList & pagination for large feeds.
3. Implemented lazy loading for media-heavy screens.

5. Security & Reliability

At 200K+ users, security became non-negotiable.

1. Implemented JWT with refresh tokens for authentication.
2. Added rate limiting + IP blacklisting at Nginx layer.
3. Encrypted media URLs with signed CloudFront links.
4. Regular penetration testing to patch vulnerabilities.

6. Growth Lessons Learned

What worked

1. Focus on core features (chat, nearby users, media).
2. Performance-first mindset – caching, CDNs, and horizontal scaling.
3. Community feedback – we iterated fast based on user reports.

What didn’t

1. Over-engineering early. Building microservices too soon slowed progress.
2. Ignoring analytics in the beginning—we had to rebuild tracking pipelines later.
3. Underestimating moderation—scaling also meant handling more spam & abuse.

7. Results – Where We Are Today

1. 200K+ installs across Android (India & global markets).
2. 20K+ daily active users at peak.
3. Average session length: 14 minutes.
4. Server response times: Improved from 900ms → ~120ms with caching & scaling.

8. Key Takeaways for Startups & Developers

1. Start simple but stay scalable – don’t over-optimize early, but prepare for growth.
2. Invest in observability – metrics & monitoring save hours of debugging.
3. Use cloud-native tools wisely – auto scaling, CDNs, caching are your best friends.
4. Don’t underestimate costs – plan AWS bills and optimize infra continuously.
5. User trust is critical – reliability & security build long-term retention.

Scaling Haiyvee to 200K+ users wasn’t easy, but it was possible with the right architecture choices, cloud infrastructure, and performance optimizations. For any startup looking to scale, the message is clear: start lean, focus on product-market fit, and prepare infrastructure to evolve as users grow.