About Us

At Actinode, we're a team of tech enthusiasts dedicated to transforming ideas into innovative solutions. With a strong foundation in technology and creativity, we bring together expertise from various domains to deliver exceptional results. Our mission is to turn your visions into reality through cutting-edge technology and a collaborative approach. Meet the passionate professionals behind Actinode – committed to driving innovation and creating impactful solutions for your business.

Cloud Infrastructure

Kubernetes Migration & Infrastructure Modernization

Transformed a legacy EC2-based infrastructure into a modern, self-healing Kubernetes platform with auto-scaling, comprehensive monitoring, and 99.99% uptime.

June 2024
WasteTrack Solutions
4 months
6 Senior Engineers

Overview

Transformed a legacy EC2-based infrastructure into a modern, self-healing Kubernetes platform with auto-scaling, comprehensive monitoring, and 99.99% uptime.

Industry

Waste Management

Offering

Complete Infrastructure Modernization with Kubernetes & Containerization

Business Challenges

Following the successful microservices migration, WasteTrack Solutions faced new scaling and operational challenges:

  • Expensive Scaling: The remaining Symfony monolith on EC2 still contained multiple API groups serving different purposes, each consuming significant resources
  • Inefficient Resource Usage: Scaling the entire monolith for specific API needs was wasteful and costly
  • No Self-Healing: Manual intervention required for service failures, leading to extended downtime
  • Limited Observability: Insufficient monitoring and alerting made it difficult to proactively identify issues
  • Growing Pains: As user base grew from 15 to 30+ clients, infrastructure couldn't keep up
  • Deployment Complexity: Manual deployment processes were error-prone and time-consuming
  • Single Point of Failure: EC2 instances lacked automatic recovery mechanisms

Business Requirements

With the business now stable and growing, WasteTrack needed a scalable, resilient infrastructure:

  • Cost Optimization: Reduce infrastructure costs by 40% through efficient resource utilization
  • Auto-Scaling: Automatically scale services based on actual demand without manual intervention
  • Self-Healing: System should automatically recover from failures without human involvement
  • High Availability: Achieve 99.99% uptime SLA for mission-critical operations
  • Growth Support: Platform capable of supporting 100+ clients without architectural changes
  • Operational Excellence: Comprehensive monitoring, alerting, and observability
  • Rapid Deployments: Enable multiple deployments per day with zero-downtime

Key Results

99.99%Uptime SLA
-42%Infrastructure Cost
<30sAuto-Recovery
100+Client Capacity

The Challenge

After the emergency Phase 1 rescue, the platform was stable but far from optimal. The infrastructure consisted of:

Existing Architecture Problems:

  • Hybrid EC2 Setup: Multiple Node.js microservices on separate EC2 instances + Symfony monolith on dedicated EC2
  • Manual Scaling: All scaling decisions and configurations were manual, requiring constant DevOps attention
  • Resource Waste: Running oversized EC2 instances 24/7 to handle peak loads that occurred only 2-3 hours daily
  • No Resilience: Service failures required manual restart and investigation
  • Deployment Friction: Each deployment required SSH access, manual commands, and careful coordination
  • Monitoring Gaps: Limited visibility into service health, resource usage, and user impact

Additional Technical Debt:

  • The Symfony monolith still contained 4-5 distinct API groups that should be separated
  • No containerization meant environment inconsistencies between dev, staging, and production
  • Database connections weren't optimally pooled across services
  • No centralized logging - logs scattered across multiple EC2 instances

The client was now growing rapidly (30+ clients, targeting 100+) and needed an enterprise-grade infrastructure that could scale automatically and recover from failures without intervention.

Our Solution

We designed and executed a comprehensive infrastructure modernization strategy in four phases:

Phase 1: Additional Microservices Extraction (Month 1)

  • Analyzed the remaining Symfony monolith and identified 4 additional API groups consuming heavy resources
  • Billing & Invoicing APIs (30% of remaining load)
  • Reporting & Analytics APIs (25% of load)
  • Customer Management APIs (20% of load)
  • Notification & Communication APIs (15% of load)
  • Built each as an independent Node.js microservice with dedicated databases where appropriate
  • Implemented API gateway pattern for unified entry point and routing

Phase 2: Containerization (Month 2)

  • Dockerized all applications - both new microservices and existing PHP/Symfony monolith
  • Created multi-stage Docker builds for optimized image sizes (reduced from 1.2GB to 180MB average)
  • Established Docker registry on AWS ECR for secure image storage
  • Standardized environment configurations using Docker Compose for local development
  • Implemented health check endpoints in all services for container orchestration

Phase 3: Kubernetes Cluster Setup (Month 3)

  • Deployed production-grade Kubernetes cluster on AWS EKS
  • Configured node groups with mixed instance types (on-demand + spot instances for cost savings)
  • Set up Kubernetes namespaces for environment isolation (production, staging, development)
  • Migrated all services to Kubernetes with zero downtime using blue-green deployment strategy
  • Implemented Ingress controllers (NGINX) for intelligent traffic routing
  • Configured persistent storage with AWS EBS for stateful services

Phase 4: Advanced Features & Optimization (Month 4)

  • Implemented Horizontal Pod Autoscaler (HPA) for all services based on CPU/memory metrics
  • Configured custom metrics for business-specific scaling (requests per second, queue depth)
  • Deployed comprehensive monitoring stack: Prometheus + Grafana for metrics and visualization
  • Implemented centralized logging with ELK stack (Elasticsearch, Logstash, Kibana)
  • Set up alert management with PagerDuty integration for critical issues
  • Enabled self-healing through Kubernetes liveness/readiness probes
  • Configured resource quotas and limits for cost control

Implementation

1. Microservices Decomposition

Analyzed and extracted 4 additional microservices from the Symfony monolith. Each microservice was built with Node.js, featuring its own database schemas, independent scaling, and comprehensive API documentation. Implemented circuit breakers and retry logic for inter-service communication resilience.

2. Comprehensive Dockerization

Containerized all 8 services (4 new microservices + 3 existing Node.js services + 1 Symfony core). Created optimized Dockerfile with multi-stage builds, security scanning with Trivy, and automated CI/CD pipelines for image building. Established naming conventions and versioning strategies for container images.

3. Kubernetes Infrastructure Deployment

Set up AWS EKS cluster with 3 availability zones for high availability. Configured auto-scaling node groups with 3-20 nodes capacity. Deployed all services with Kubernetes Deployments, Services, and ConfigMaps. Implemented network policies for security and service mesh considerations for future scaling.

4. Monitoring & Observability

Deployed full monitoring stack with Prometheus for metrics collection, Grafana for visualization with 15+ custom dashboards, and ELK for centralized logging. Created 50+ alerts covering service health, resource usage, error rates, and business metrics. Integrated with PagerDuty for on-call management.

5. Auto-Scaling & Self-Healing

Configured HPA for each service with initial static limits, then tuned based on 2 weeks of production data. Set up vertical pod autoscaling (VPA) recommendations. Implemented liveness probes (service health) and readiness probes (traffic handling). Average pod restart time reduced to under 30 seconds with automatic recovery.

6. Migration & Validation

Executed phased migration of all services to Kubernetes using blue-green deployments. Each service was validated for 72 hours before deprecating old EC2 infrastructure. Load testing performed at 3x expected capacity to ensure stability. Rolled back mechanism tested and validated for every service.

Key Features

  • Kubernetes Orchestration with AWS EKS
  • Horizontal Pod Autoscaler (HPA) for Dynamic Scaling
  • Self-Healing with Automated Failure Recovery
  • Comprehensive Monitoring (Prometheus + Grafana)
  • Centralized Logging (ELK Stack)
  • Multi-Service Architecture (8 Independent Services)
  • Blue-Green Deployment Strategy
  • Cost Optimization with Spot Instances
  • API Gateway Pattern
  • Zero-Downtime Deployments
  • Infrastructure as Code (Terraform + Helm)
  • Automated CI/CD Pipelines

Results & Impact

  • Achieved 99.99% uptime (down from 99.2%) with self-healing capabilities
  • Reduced infrastructure costs by 42% through auto-scaling and spot instances
  • Eliminated manual scaling operations - system now scales automatically based on load
  • Reduced deployment time from 2 hours to 8 minutes with zero downtime
  • Automatic recovery from failures in under 30 seconds (previously required 15+ minutes manual intervention)
  • Scaled from 30 to 100+ concurrent clients without infrastructure changes
  • Reduced resource waste by 65% - services scale down during off-peak hours
  • Improved developer productivity by 40% with standardized Docker environments
  • Implemented 50+ proactive alerts preventing issues before user impact
  • Enabled 5-8 deployments per day (from 2 per week) with confidence

Actinode Solution Approach

Actinode's infrastructure modernization approach combined technical excellence with business pragmatism:

Strategic Phasing: Rather than a "big bang" migration, we broke the project into manageable phases. This allowed the business to continue operating and growing while we modernized the infrastructure underneath.

Technology Choices:

  • Kubernetes on AWS EKS: Chose managed Kubernetes to reduce operational overhead while maintaining flexibility
  • Continued Node.js Investment: Leveraged existing microservices success, building 4 additional services in Node.js
  • Docker: Containerization provided consistency across environments and enabled Kubernetes adoption
  • Mixed Instance Strategy: Spot instances for non-critical workloads (70% cost savings) + on-demand for critical services

Cost Optimization Focus: We didn't just modernize - we optimized. The new architecture costs 42% less than the old EC2 setup while serving 3x more clients. This was achieved through:

  • Auto-scaling that reduces resources during off-peak hours
  • Spot instances for 60% of compute capacity
  • Right-sized containers based on actual usage data
  • Eliminated idle resources through dynamic allocation

Operational Excellence: Built monitoring and alerting from day one. The client can now see system health in real-time and receives alerts before users are impacted. Self-healing means most issues resolve automatically.

Future-Proof Architecture: The platform can now scale to 500+ clients without architectural changes. The team can deploy new features multiple times daily with confidence.

Business Benefits

  • Dramatic Cost Reduction: 42% decrease in infrastructure costs while supporting 3x more clients
  • Revenue Growth: Infrastructure no longer a bottleneck - scaled from 30 to 100+ clients in 6 months
  • Operational Efficiency: Eliminated 90% of manual infrastructure management tasks
  • Business Continuity: 99.99% uptime ensures critical waste management operations never stop
  • Competitive Advantage: Modern infrastructure enables rapid feature development and market responsiveness
  • Team Productivity: Developers ship features 5x faster with automated deployments
  • Customer Satisfaction: Improved from 4.6/5 to 4.9/5 due to reliability
  • Investor Confidence: Modern, scalable infrastructure attracted Series A funding
  • Risk Reduction: Self-healing and monitoring reduce operational risk significantly
  • Market Expansion: Can confidently enter new markets without infrastructure concerns

Technologies Used

KubernetesAWS EKSDockerNode.jsPHPSymfonyPostgreSQLRedisPrometheusGrafanaELK StackTerraformHelmNGINX IngressAWS ECRPagerDuty

Conclusion

This infrastructure modernization transformed WasteTrack Solutions from a struggling startup with a fragile technical foundation into an enterprise-ready platform capable of serving hundreds of clients reliably and cost-effectively. The combination of microservices architecture, containerization, and Kubernetes orchestration created a truly cloud-native platform that scales automatically, heals itself, and provides the operational visibility needed to run a mission-critical business application. Most importantly, this project demonstrates that infrastructure modernization doesn't have to be a multi-year, high-risk endeavor. With the right strategy and phased approach, companies can modernize while continuing to grow their business.

Future Enhancements

Next phases include: Service mesh implementation (Istio) for advanced traffic management, multi-region deployment for disaster recovery, machine learning integration for predictive auto-scaling, and expansion into edge computing for real-time GPS tracking optimization.

Have a Similar Project in Mind?

Let's discuss how we can help you achieve similar results for your business.