Project Overview
| Client Industry | Education / EdTech |
| Business Type | Online course platform serving ~300,000 students across corporate and individual learners |
| Project Duration | 17 weeks |
| AI Service Provided | Container Orchestration (Docker & Kubernetes) |
| Technologies Used | Docker, Kubernetes (Amazon EKS), Helm, Terraform, GitHub Actions, Prometheus, Grafana, Redis |
The Client Challenge
The client’s course platform ran as a single monolithic application deployed on a fixed set of EC2 instances. This worked adequately for steady traffic but failed under the platform’s naturally spiky usage pattern.
The operational reality:
- Enrollment periods (start of academic terms, corporate training cycles) caused traffic to spike 8–10x normal levels within a matter of hours the fixed infrastructure couldn’t scale fast enough, resulting in slow page loads and failed enrollments.
- The monolithic architecture meant a bug or resource spike in one feature (e.g., video streaming) could degrade performance platform-wide, including unrelated features like login or course browsing.
- Deploying any change required redeploying the entire monolith, making releases slow and risky a small fix to one module carried the same deployment risk as a major feature launch.
- The infrastructure team manually pre-provisioned extra server capacity before known high-traffic periods, an imprecise process that either over-provisioned (wasting cost) or under-provisioned (causing outages).
- The client had lost enrollments during at least two major peak periods due to platform slowdowns, directly impacting revenue during their highest-value sales windows.
Our Solution
Air Brite Labs re-architected the platform from a single monolith into containerized services orchestrated on Kubernetes, enabling independent scaling of the components that actually needed it most critically, the enrollment and video-streaming services that bore the brunt of traffic spikes.
The migration was staged carefully: rather than a disruptive full rewrite, high-impact services were extracted from the monolith first and containerized, while lower-priority components remained temporarily in the existing structure until their turn came.
Key capabilities:
- Independent service scaling — the enrollment service and video-delivery service now scale independently and automatically based on real-time demand, rather than the whole platform scaling (or failing) together.
- Horizontal pod autoscaling — Kubernetes automatically adds and removes application instances based on CPU/memory load and custom metrics like queue depth, replacing manual pre-provisioning guesswork.
- Fault isolation — a spike or issue in one service (e.g., video transcoding load) no longer degrades unrelated services like course browsing or login.
- Rolling, zero-downtime deployments — individual services deploy independently through Kubernetes rolling updates, so a fix to one module no longer requires redeploying the entire platform.
- Real-time capacity visibility — Prometheus and Grafana dashboards give the infrastructure team live visibility into resource usage and scaling behavior during traffic events, replacing guesswork with data.
Technical Approach
Containerization: Core platform services (enrollment, course catalog, video delivery, user authentication) were extracted from the monolith and containerized with Docker, each with its own resource profile and scaling behavior defined independently.
Orchestration: Deployed on Amazon EKS (managed Kubernetes), chosen to reduce the operational overhead of managing Kubernetes control planes directly while still giving the team full orchestration control over workloads.
Deployment Management: Helm charts standardize deployment configuration across services and environments, ensuring consistent, repeatable deployments rather than one-off configurations per service.
Autoscaling Configuration: Horizontal Pod Autoscaler (HPA) configured per service based on relevant metrics CPU/memory for general services, and custom queue-depth metrics for the video transcoding service, which doesn’t scale well on CPU alone.
Caching: Redis introduced as a shared caching layer for session data and frequently accessed course metadata, reducing database load during traffic spikes and improving response times across services.
Infrastructure as Code: The underlying EKS cluster, networking, and supporting AWS infrastructure provisioned via Terraform, keeping the Kubernetes environment itself version-controlled and reproducible.
Observability: Prometheus scrapes metrics from all services and the Kubernetes cluster itself; Grafana dashboards give the team real-time and historical visibility into scaling events, resource utilization, and service health.
Implementation Process
- Discovery & Requirement Analysis (Weeks 1–3): Profiled the monolith’s traffic patterns and resource usage during a real enrollment spike to identify which components actually needed independent scaling, avoiding an unnecessary full rewrite.
- Prototype / PoC (Weeks 4–6): Extracted and containerized the video-delivery service first the highest-impact, most isolated component and validated Kubernetes autoscaling behavior against simulated load.
- Development (Weeks 7–12): Extracted and containerized the enrollment and authentication services, built out Helm charts, and configured autoscaling policies per service based on observed load characteristics.
- Integration (Weeks 13–14): Integrated Redis caching, connected Prometheus/Grafana monitoring, and wired the GitHub Actions pipeline to deploy to EKS.
- Testing (Weeks 15–16): Load-tested the new architecture against traffic volumes matching the client’s worst historical peak, validating autoscaling response time and fault isolation between services.
- Deployment (Week 17): Phased production cutover, migrating traffic service by service with the monolith remaining as a fallback until each migrated service was validated stable.
- Optimization (ongoing): Fine-tuned autoscaling thresholds and resource requests/limits based on real traffic data from the first post-migration enrollment period.
Key Features Delivered
- Containerized microservices architecture replacing a monolithic deployment
- Kubernetes-based orchestration on Amazon EKS with independent per-service scaling
- Horizontal Pod Autoscaling based on both standard and custom metrics
- Fault-isolated services preventing cross-feature performance degradation
- Rolling, zero-downtime deployments per service
- Redis-based shared caching layer reducing database load during peak traffic
- Real-time observability via Prometheus and Grafana dashboards
Business Results
- The platform handled the next major enrollment peak (9x normal traffic) with no degradation, compared to significant slowdowns and failed enrollments in prior peak periods
- Infrastructure costs during normal (non-peak) periods decreased, since autoscaling eliminated the need for manually pre-provisioned excess capacity
- Deployment frequency for individual services increased significantly, since teams could now deploy one service without redeploying the entire platform
- Mean time to recover from a service-specific issue dropped substantially, since fault isolation meant problems no longer cascaded platform-wide
- Estimated enrollment revenue previously lost to peak-period slowdowns was fully recovered in the following enrollment cycle
- Infrastructure team shifted from manual capacity planning to monitoring and optimization, freeing time for platform improvements
Technology Stack
| Layer | Technology |
|---|---|
| Containerization | Docker |
| Orchestration | Kubernetes (Amazon EKS) |
| Deployment Management | Helm |
| Infrastructure as Code | Terraform |
| CI/CD | GitHub Actions |
| Caching | Redis |
| Monitoring | Prometheus, Grafana |
Why the Solution Worked
The migration succeeded because it prioritized extracting the specific services that actually caused traffic-related failures, rather than attempting a full platform rewrite on principle. Profiling real traffic data before deciding what to containerize meant engineering effort went toward the components with the highest business impact.
Configuring autoscaling around the right metrics for each service not just generic CPU thresholds was equally critical. The video transcoding service, in particular, needed queue-depth-based scaling rather than CPU-based scaling to respond correctly to real load patterns, and getting that specific to each service’s actual behavior is what made the autoscaling reliable under real peak conditions.
Future Scalability
The Kubernetes foundation is designed to support continued platform evolution, including:
- Migrating remaining monolith components to containerized services as their traffic patterns justify independent scaling
- Adding multi-region deployment on EKS to serve international student growth with lower latency
- Implementing service mesh (e.g., Istio) for more granular traffic management as the number of services grows
- Extending the observability stack with distributed tracing as service-to-service calls become more complex
Because each service is independently containerized and deployed, new services can be added to the cluster without disrupting existing ones, and the autoscaling and monitoring patterns established here extend naturally to whatever comes next.
Final Outcome
The platform moved from a fragile, single-scaling-unit monolith that failed under its own predictable peak traffic to a resilient, independently scaling architecture that handles enrollment spikes as a matter of course. The business no longer loses enrollment revenue to infrastructure limitations during its most critical sales periods.


