Loading case study...
Loading case study...
Full-stack social media platform for the disability community, from Bubble prototype to enterprise-scale mobile apps with microservices architecture.
Architected entire application from scratch
Successfully launched on iOS and Android app stores
Built core social features: posts, connections, messaging
Managed full product lifecycle from ideation to deployment
A comprehensive social media platform designed specifically for the disability community.
This project demonstrates the journey from rapid prototype to enterprise-scale application built as a modular monolith with plans for microservices migration.
This project showcased my evolution from JobTrax's lessons into a more sophisticated system design and project management approach.
TheTenPercent, a US-based non-profit organization representing the 10% of the population with disabilities, needed a safe and secure social platform.
They came to Zelio seeking cost-effective development compared to US rates, but with ambitious scalability requirements.
We implemented a two-phase approach: starting with a rapid Bubble.io prototype to secure funding, then building enterprise-scale native applications.
The backend was designed as a modular monolith with a clear path for future microservices migration.
Objective: Create a functional prototype for investor presentations and funding acquisition.
Objective: Build production-ready applications capable of scaling to 10,000+ users.
Account creation with 2FA
Used by: Users
Share content with community
Used by: Users
Find accessibility resources
Used by: Users
Real-time messaging
Used by: Users
Admin user management
Used by: Admins
Content moderation tools
Used by: Admins
Community members (via iOS & Android apps)
Uses: 4 use cases
Platform administrators (via web portal)
Uses: 2 use cases
Actors are associated with use cases they interact with (shown in use case descriptions)
Hybrid Architecture: Modular Monolith + Microservices
iOS (SwiftUI)
Android (Kotlin)
The project was structured around 4 major milestones with clear deliverables and deadlines:
Challenge: Designing a scalable backend architecture to handle 10,000+ concurrent users, with a path to microservices migration.
Current Architecture:
The application is built as a monolithic layered MVC architecture using Node.js/Express.js with TypeScript, organized into clear domain boundaries:
Solution:
I chose a modular monolith approach to balance development speed with future scalability. The architecture was organized into distinct modules (authentication, users, content, messaging, social graph, notifications) with clear boundaries, making it straightforward to extract services later when needed.
The key decision was starting with a single codebase rather than microservices from day one. This allowed us to:
However, I designed clear domain boundaries from the start, using dependency injection and repository patterns to make future extraction straightforward. When we needed independent scaling for Auth and Notifications services, the migration path was already clear.
Microservices Migration Implementation:
We successfully migrated two core services from the monolithic architecture to microservices using the Strangler Fig Pattern, leveraging AI-assisted development to accelerate the transition while maintaining production stability.
The remaining services (Content, Social Graph, Community, Events, Business Services) remain in the modular monolith, creating a hybrid architecture optimized for our current scale and future growth.
Additional Microservices Technical Considerations:
Reliability Patterns:
For critical operations like payments, I implemented idempotency keys stored in Redis. If a request was retried with the same idempotency key, the system would return the cached response rather than processing it again, preventing duplicate charges.
Each service had comprehensive health checks (/health, /ready, /live) that verified database connectivity, Redis availability, and external service status. ECS used these to determine if a service was healthy and ready to receive traffic.
I also implemented graceful shutdown handlers that would stop accepting new requests, wait for in-flight requests to complete (up to 30 seconds), then close database and Redis connections cleanly. This prevented data corruption and ensured users didn't experience errors during deployments.
Data Consistency Patterns:
Performance Optimization:
Disaster Recovery & Backup:
Challenge: Building native iOS and Android apps with feature parity and optimal performance.
Solution:
Challenge: Implementing reliable messaging for a social platform with potential for thousands of concurrent users.
Solution:
Challenge: Building a comprehensive admin portal as the sole developer while managing other project responsibilities.
Technical Implementation:
Key Features Delivered:
Development Approach:
As the sole developer on the admin portal, I built it using React 18 with TypeScript for complete type safety across frontend and backend. The architecture used dependency injection and repository patterns, making it easy to test and maintain. I implemented MongoDB transactions for user creation to ensure data consistency, and used event publishing to trigger notifications asynchronously.
Key features included comprehensive user search with geospatial queries (finding users within 50km of a location), disability filtering, and pagination. All sensitive data like password hashes was excluded from API responses, and I used MongoDB transactions to ensure atomic operations when creating users with multiple related records.
Technical Achievements:
Challenge: Create a professional marketing website for TheTenPercent to support app launch and user acquisition.
Solution: Rapid website development using Framer for modern, responsive design.
Technical Implementation:
Key Features Delivered:
Development Timeline:
Live Project Links:
Problem: After successfully completing Milestones 1 and 2, Milestone 3 faced two critical issues: our UI/UX designer went missing, and the client CEO failed to provide the promised resources and data needed for the resources section to reach its potential.
Impact:
Solution:
Problem: TheTenPercent organization experienced a CEO change during MVP completion, causing significant onboarding delays.
Impact:
Solution:
Situation: Client expected 10,000 users for the complete application (post-funding), but MVP was launched with 200 users due to organizational changes delaying additional funding.
Context:
Solution:
TheTenPercent represents a significant evolution from my JobTrax experience, demonstrating growth in system design, project management, and technical leadership. While the project faced unexpected challenges with design bottlenecks and client organizational changes, it successfully delivered a functional social platform that serves the disability community.
This project taught me invaluable lessons about:
The technical achievements—from modular monolith architecture designed for microservices migration to real-time messaging, native mobile apps, complete admin portal, and professional website—combined with the project management challenges, have prepared me for more complex technical leadership roles. The experience of building a complete platform ecosystem from prototype to App Store launch, including admin portal and marketing website as the sole developer, while managing international teams and client expectations, demonstrates the kind of comprehensive skill set needed for senior development positions.
The complete project delivery showcased my ability to work independently across multiple technology stacks—from complex full-stack TypeScript applications to rapid no-code website development. This experience proves my capability to take ownership of entire project lifecycles and deliver them to production standards across different technology domains.
This case study represents a real project where I served as System Designer and Technical Lead. The platform successfully launched on both iOS and Android app stores and continues to serve the disability community, with architecture ready to scale to thousands of users when the client is ready for expansion.