When a healthtech startup approached us to build their telemedicine platform, they had ambitious growth targets. Here is the case study of how we architected, built, and scaled the application from zero to 50,000 active users in just four months.
The Challenge
The client needed a platform connecting patients with healthcare providers for virtual consultations. Key requirements included:
- Real-time video consultations with sub-second latency
- HIPAA-compliant data storage and transmission
- Appointment scheduling and payment processing
- Patient records management with lab report uploads
- SMS and email reminders to reduce no-shows
Architecture Decisions
Frontend: We chose Next.js with Tailwind CSS for the patient web app and React Native for the mobile apps. The shared TypeScript layer allowed us to maintain consistency across platforms while building native mobile experiences.
Backend: Node.js microservices on AWS ECS, with each service handling a specific domain:
- User service (auth, profiles)
- Appointment service (scheduling, availability)
- Consultation service (video sessions using Twilio)
- Payment service (Stripe integration)
- Notification service (Twilio SMS + SendGrid email)
Database: PostgreSQL with read replicas for scaling. We used pgBouncer for connection pooling and implemented database sharding for patient records.
Real-time: WebSocket connections via AWS API Gateway WebSocket API, with a Redis pub/sub layer for broadcasting appointment updates.
The Scaling Journey
Month 1 — Launch (0 to 2,000 users)
We launched with a single db.r6g.large RDS instance and two t3.medium application servers. The first month was about ironing out UX issues and onboarding early adopter clinics.
Key lesson: Video consultation quality depends heavily on client-side bandwidth detection. We implemented adaptive bitrate streaming in week two.
Month 2 — Growth (2,000 to 12,000 users)
Word-of-mouth drove rapid adoption. We hit our first scaling bottleneck: the appointment service could not handle peak-hour booking surges. We implemented:
- Horizontal scaling (4 → 12 ECS tasks)
- Redis caching for available time slots
- Read replicas for appointment queries
- Rate limiting on the booking endpoint
Month 3 — Acceleration (12,000 to 35,000 users)
A partnership with a regional hospital chain doubled our user base. The database became the bottleneck. We:
- Implemented read replicas across three availability zones
- Added Elasticache Redis for session caching
- Migrated patient documents to S3 with CloudFront CDN
- Introduced database connection pooling with RDS Proxy
Month 4 — Scaling to 50K
With 50K users and growing 15% week-over-week, we optimized for cost and reliability:
- Implemented auto-scaling policies based on CPU and memory
- Added circuit breakers for downstream service failures
- Built a monitoring dashboard with Datadog
- Set up automated load testing weekly
Key Takeaways
Start simple, but plan for scale: We started with a monolith and extracted services as bottlenecks emerged. Over-engineering at the start would have delayed our launch by weeks.
Database is usually the bottleneck: Most scaling issues trace back to the database. Plan for read replicas, caching, and connection pooling from day one.
Monitoring is non-negotiable: Without good observability, you are flying blind. Set up alerts for p99 latency, error rates, and database connection utilization before you need them.
Conclusion
Scaling from 0 to 50K users in four months required rapid iteration, careful architecture decisions, and constant monitoring. The key was building a modular system that could evolve without rewrites. At Rudra IT Solutions, we design systems that scale with your growth curve—whether you are starting at zero or already serving thousands.