Ramu Chelloju

Senior DevOps Engineer · Cloud Infrastructure Architect · Platform Engineering

Designing, building, and operating production-grade cloud infrastructure at scale Specialized in multi-cloud automation, microservices orchestration, and zero-downtime delivery systems

Production-focused DevOps Engineer with 5 years of hands-on experience architecting and operating cloud infrastructure for healthcare platforms and enterprise-grade microservices. Currently serving as the primary DevOps engineer for a telehealth platform on Azure, managing multi-tenant white-label infrastructure serving healthcare clients at scale.

Engineering Philosophy: Every manual process is technical debt. Infrastructure must be reproducible, version-controlled, observable, and self-healing. I build systems that operators trust and developers love.

What I bring to the table:

• End-to-end ownership of cloud infrastructure — from architecture design to production operations
• Deep expertise in both AWS and Azure ecosystems with production workloads
• Battle-tested CI/CD pipeline architecture reducing deployment cycles by 60%
• Monitoring-first mindset — if you can't observe it, you can't operate it

Primary DevOps Engineer — White-Label Healthcare SaaS Platform

Sole DevOps engineer responsible for designing, deploying, and operating the complete cloud infrastructure for a telehealth platform focused on weight-loss management and remote healthcare services. Built and maintained a multi-tenant white-label architecture supporting multiple healthcare clients with isolated infrastructure and shared deployment patterns.

Impact: Platform enables patients to access healthcare providers instantly through telehealth consultations — supporting weight-loss management, medication programs, and online patient engagement across multiple healthcare organizations.

Full Microservices Deployment on Amazon EKS — Production-Grade Kubernetes

End-to-end Kubernetes deployment of a 10-service e-commerce platform on Amazon EKS. Every manifest written, debugged, and verified working end to end.

Architecture:
Browser → AWS ELB → frontend (nginx) :80
                         ├── /api/catalogue/ → catalogue:8080 → mongodb:27017
                         ├── /api/cart/      → cart:8080      → redis:6379
                         ├── /api/user/      → user:8080      → mongodb:27017
                         ├── /api/shipping/  → shipping:8080  → mysql:3306
                         └── /api/payment/   → payment:8080   → rabbitmq:5672

What makes this production-grade:

• ✅ Liveness, Readiness, and Startup probes on all services
• ✅ Resource requests and limits — Guaranteed QoS class
• ✅ ConfigMaps for all environment configuration — no hardcoded values
• ✅ nginx.conf stored in ConfigMap — mounted as volume, no image rebuilds
• ✅ ClusterIP for all internal services, LoadBalancer only for frontend
• ✅ RabbitMQ for async order processing — decoupled payment flow
• ✅ Namespace isolation with proper labels and selectors
• ✅ Distroless runtime images for Node.js, Java, and Python services

Tech: Kubernetes Amazon EKS eksctl ConfigMap Volumes Probes LoadBalancer ClusterIP k9s kubectl

Optimised Docker Images — Multi-Stage Builds for 8 Microservices

Production-optimised Dockerfiles for all Roboshop microservices using multi-stage builds, distroless runtime images, and security best practices.

Services:
├── catalogue/   → Node.js  → distroless/nodejs20
├── cart/        → Node.js  → distroless/nodejs20
├── user/        → Node.js  → distroless/nodejs20
├── shipping/    → Java     → distroless/java17 (maven builder)
├── payment/     → Python   → alpine (pip --prefix pattern)
├── frontend/    → nginx    → alpine (non-root nginx user)
├── mongodb/     → custom   → pre-loaded schema
└── debug/       → AlmaLinux → full toolset for cluster debugging

What makes this production-grade:

• ✅ Multi-stage builds — build tools never in final image
• ✅ Distroless runtime images — no shell, minimal attack surface
• ✅ Non-root users across all services
• ✅ Exact image version pinning — reproducible builds
• ✅ ENV removed — all config handled by Kubernetes ConfigMap
• ✅ Python --prefix=/install pattern — solves platform dependency problem
• ✅ Dependency layer caching — faster rebuilds

Tech: Docker Multi-stage builds Distroless Node.js Java Python Maven nginx uwsgi Alpine

Production-Grade AWS Infrastructure with Terraform — Modular Multi-Tier Architecture

End-to-end infrastructure provisioning for a microservices e-commerce platform using Terraform with custom reusable modules.

Architecture:
├── infra/              → Environment-specific infrastructure definitions
├── modules/
│   ├── terraform-aws-vpc/   → Custom VPC module (multi-AZ, public/private subnets)
│   └── terraform-aws-sg/    → Security group module (least-privilege network policies)
└── roboshop-infra.drawio    → Architecture diagram

What makes this production-grade:

• ✅ Custom Terraform modules for VPC and Security Groups — not off-the-shelf, purpose-built
• ✅ Multi-AZ deployment with proper subnet segmentation (public, private, database tiers)
• ✅ Remote state management with state locking for team collaboration
• ✅ Environment separation through Terraform workspaces
• ✅ Architecture documented with draw.io diagrams

Tech: Terraform AWS VPC EC2 Security Groups S3 Backend DynamoDB State Lock Multi-AZ

Enterprise Ansible Role Architecture — 11-Service Microservices Deployment

Production-ready Ansible automation with proper role-based architecture for deploying a complete microservices application stack.

Architecture:
├── roles/
│   ├── frontend/      → Nginx reverse proxy + static assets
│   ├── cart/          → Cart microservice (Node.js)
│   ├── catalogue/     → Product catalog service (Node.js)
│   ├── user/          → User authentication service (Node.js)
│   ├── shipping/      → Shipping calculation service (Java)
│   ├── payment/       → Payment processing service (Python)
│   ├── mongodb/       → Document store for catalog/user data
│   ├── mysql/         → Relational DB for shipping/orders
│   ├── redis/         → Session cache + cart storage
│   ├── rabbitmq/      → Async message queue for order processing
│   └── common/        → Shared tasks and handlers
├── group_vars/        → Environment-specific variables
├── inventory.ini      → Host inventory
└── roboshop.yaml      → Master orchestration playbook

What makes this production-grade:

• ✅ Role-based structure with clear separation of concerns across 11 services
• ✅ Jinja2 templating for environment-specific configurations
• ✅ Idempotent playbooks — safe to run repeatedly
• ✅ Handler-based service management for optimized restarts
• ✅ Group variables for multi-environment deployment support

Tech: Ansible YAML Jinja2 Roles Handlers Node.js Java Python MongoDB MySQL Redis RabbitMQ

Terraform Deep-Dive — State Management, Modules, Workspaces & Advanced Patterns

Comprehensive Terraform implementation covering enterprise infrastructure patterns from fundamentals to advanced state architecture.

What's covered:

• ✅ Remote state with S3 + DynamoDB locking — team-safe infrastructure management
• ✅ Layered state architecture separating network, compute, and application layers
• ✅ Production VPC design with multi-AZ, public/private subnet architecture
• ✅ Modular, reusable components following DRY principles
• ✅ Workspace-based environment separation (dev → staging → prod)
• ✅ Data sources for cross-stack references and output-driven integration

Tech: Terraform AWS VPC S3 DynamoDB IAM Workspaces Modules

	Certification	Issuer	Issued	Verify
	Microsoft Certified: Azure Fundamentals (AZ-900)	Microsoft	Apr 2022	🔗 Verify
	Foundation of Ethical Hacking	Udacity	Jan 2025	🔗 Verify
	Foundations of Cybersecurity	Google	Mar 2026	🔗 Verify

┌─────────────────────────────────────────────────────────────────┐
│                                                                 │
│   AUTOMATION FIRST     → If you do it twice, automate it        │
│   IMMUTABLE INFRA      → Servers are cattle, not pets            │
│   OBSERVABILITY        → Can't improve what you can't measure    │
│   SECURITY BY DESIGN   → Least privilege. Secrets never in code  │
│   DISASTER RECOVERY    → Backup everything. Test restores often  │
│   INFRASTRUCTURE = CODE → Version-controlled, tested, reviewed   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

• Infrastructure as Code — All infrastructure changes through version-controlled, peer-reviewed code
• GitOps Workflows — Git as the single source of truth for infrastructure state
• CI/CD Pipeline Design — Automated build, test, and deployment to production
• Monitoring-First Operations — Proactive alerting with actionable runbooks
• Incident Management — Defined response procedures, blameless post-mortems, continuous improvement
• Cost Optimization — Resource right-sizing, tagging strategies, and waste elimination

I'm always open to discussing cloud architecture challenges, infrastructure automation strategies, and DevOps best practices. Whether you're scaling infrastructure, building CI/CD pipelines, or optimizing cloud costs — let's talk.

📊 GitHub Activity