Repo:
• Travel SRE AI Agent Platform

Shields:

Description:
A Kubernetes-native, production-style SRE platform built around a travel booking microservice ecosystem.
The platform includes an API gateway, booking service, inventory service, payment service, search service, UI portal, and an AI SRE Agent that analyzes incidents, receives Alertmanager webhooks and performs controlled remediation actions.

Key Capabilities:

• Multi-service Kubernetes architecture with TypeScript services
• GitOps-ready Kubernetes manifests
• Prometheus metrics and ServiceMonitor integration
• Grafana dashboards for platform and service visibility
• Loki + Promtail centralized logging
• SLOs, error budgets and burn-rate alerts
• Slack alerting through Alertmanager
• Auto-remediation workflows: restart, scale and escalate
• UI portal for service health, deployment version and incident visibility

Architecture Overview:
Client / UI Portal → API Gateway → Search / Booking / Inventory / Payment Services
Services → Prometheus + Loki → Alertmanager → Slack + AI SRE Agent → Kubernetes API

What This Demonstrates:

• Kubernetes platform engineering
• Modern SRE practices using SLOs and burn-rate alerts
• Production-style observability architecture
• Incident analysis and self-healing workflows
• GitOps-ready platform delivery
• Reliability engineering applied to a real microservice domain

Repo:
• Kubernetes Internal Developer Platform

Shields:

Description:
A Kubernetes-based Internal Developer Platform designed to standardize how application teams create, deploy and operate services.
The platform combines GitOps delivery, reusable infrastructure patterns, Helm-based deployment standards, observability foundations, and a self-service service generator for consistent application onboarding.

Key Capabilities:

• Standardized Kubernetes application deployment patterns
• GitOps-driven platform delivery
• Centralized observability foundation
• Self-service workflows for application teams
• Extensible service template generator
• Language variant support
• Optional component toggles
• Helm chart integration
• CI workflow scaffolding
• Environment overlays
• Metadata enrichment and analytics hooks
• Service creation telemetry scaffolding

Repository Structure:

• infra/ — Cluster, GitOps and base infrastructure definitions
• platform/ — Helm charts, shared platform components and deployment standards
• services/ — Example application services deployed onto the platform
• tools/service-template/ — Service generator engine
• docs/ — Architecture, runbooks and operational documentation

Project Status:

• April milestone issues reviewed and closed
• Stage 5 scaffolding completed
• Stage 6 functional implementation underway
• Current focus: real variable rendering in the service generator

What This Demonstrates:

• Platform engineering and internal developer platform design
• GitOps-first Kubernetes operations
• Service standardization at scale
• Helm and environment overlay patterns
• Developer self-service workflows
• Production-style platform architecture

Repo:
• DevOps Deployment Automation

Workflow Badges:

Tech Badges:

Description:
A fully automated, Slack-controlled CI/CD pipeline built with GitHub Actions, AWS Lambda, API Gateway and a complete stateless rollback system.
This project demonstrates real-world DevOps/SRE practices: multi-environment deployments, version tracking, health checks, promotion workflows, and automated rollback triggered from Slack.

• Slack-driven deployments (deploy, promote, rollback)
• Multi-environment CI/CD (staging + production)
• Stateless version tracking using version files
• Automated health checks before marking deploy successful
• Zero-downtime rollback to previous stable version
• Dockerized application for consistent builds
• AWS Lambda + API Gateway for Slack webhook handling

Located in scripts/:

• build.sh — Build Docker image
• push.sh / push_staging.sh — Push image to ECR
• deploy_staging.sh — Deploy to staging
• deploy_production.sh — Deploy to production
• promote.sh — Promote staging → production
• rollback_production.sh — Roll back to previous version
• healthcheck.sh — Validate service health
• logs.sh — Fetch logs for debugging

GitHub Actions → AWS Lambda → API Gateway → Deployment Scripts → Version Tracking → Slack Notifications

• Multi-stage CI/CD pipeline design
• Slack-driven operational workflows
• Stateless deployment + rollback strategy
• Automated health checks & promotion logic
• GitHub Actions + AWS Lambda integration
• Production-style deployment scripting
• Real SRE operational maturity

Repo:
• Prometheus + Grafana SRE Platform

Shields:

Description:
A full production-grade observability and alerting platform built around a FastAPI application instrumented with Prometheus metrics, visualized through Grafana dashboards, monitored externally via Blackbox Exporter, and equipped with a complete alerting pipeline using Prometheus alert rules + Alertmanager + Grafana-managed alerts.

Key Capabilities:

• Custom FastAPI metrics (request count, latency histograms, Python internals)
• Blackbox Exporter for external uptime monitoring
• Auto-provisioned Grafana dashboards (FastAPI, Blackbox, Prometheus internals)
• Full alerting pipeline (Prometheus → Alertmanager → Slack)
• Grafana-managed alert rules for external probe failures
• Environment-aware configuration (macOS vs Linux exporters)
• Secure secret management using .env + Alertmanager variable injection
• Modular, production-ready Docker Compose architecture

Alerting Features:

• Critical & warning alerts (latency, traffic spikes, target down, app down)
• Blackbox probe alerts for external endpoint failures
• Slack notifications with runbook links, severity labels & metadata
• Automatic alert resolution when services recover

Architecture Overview:
FastAPI → Prometheus → Grafana → Alertmanager → Slack
Blackbox Exporter → Prometheus → Grafana → Alerts

What This Demonstrates:
Real SRE practices: instrumentation, exporters, alerting, dashboards, runbooks, secret management and operational readiness.

Repo:
• Ecommerce Microservice API

Shields:

Description:
A learning-oriented ecommerce microservice built with FastAPI, SQLite, SQLAlchemy, Alembic, Redis, and Docker.
The project was developed incrementally through milestone-based stages, evolving from a simple MVP into a more realistic ecommerce backend focused on clean architecture, testing, portability, and production-style backend patterns.

Key Capabilities:

• Products API with seeded inventory and Redis-backed caching
• Shopping cart API with stock validation and duplicate item merging
• Orders API with checkout workflow, order history, and inventory updates
• Order lifecycle management with validated status transitions and cancellation rules
• Mock payments workflow with order and user associations
• JWT authentication with bcrypt password hashing
• Redis-backed login rate limiting
• Multi-user ownership isolation for cart, orders, and payments
• Background tasks for invoices and order notifications
• Standardized configuration using pydantic-settings
• Dockerized local runtime with Redis healthcheck gating
• Pytest coverage for auth, products, cart, orders, payments, and background task side effects

Architecture:
FastAPI API → Redis cache / rate limiter → SQLAlchemy ORM → SQLite
Background tasks → invoice + notification file generation
Docker Compose → API + Redis services

What This Demonstrates:

• Incremental backend system design through milestone-based delivery
• Clean FastAPI architecture with routers, services, and dependency injection
• Redis integration for caching and rate limiting
• Alembic-based schema evolution
• Testable API design using dependency overrides and FakeRedis isolation
• Production-readiness improvements in configuration, startup behavior, and container health

Repo:
• Ansible Work 1

Shields:

Description:
A comprehensive collection of 15+ Ansible playbooks designed to automate real-world Linux server operations, application deployments, configuration management and environment provisioning.
This suite demonstrates production-style automation patterns including multi-play orchestration, templating, handlers, dynamic variables, and reusable role-based structures.

Key Capabilities:

• Server provisioning & configuration (users, packages, services)
• Web application deployments (HTML, PHP, Angular)
• Apache/HTTPD setup & environment configuration
• Maintenance mode workflows (blue/green-style switch)
• Dynamic Jinja2 templating & variable injection
• Logical conditions, handlers & multi-play orchestration
• Role-ready structure for scalable automation

Included Playbooks:

• Server setup & package installation
• Apache/HTTPD provisioning
• E-commerce & food-delivery sample deployments
• HTML, PHP & Angular app deployments
• Maintenance mode automation
• Static & dynamic variable examples
• Ubuntu server configuration
• Multi-package & logical condition automation

What This Demonstrates:

• Infrastructure automation fundamentals
• Idempotent configuration management
• Reusable automation patterns
• Real DevOps workflows using Ansible at scale

Description:
InsightFace + FastAPI + Docker + AWS.
Embedding generation, vector search, user enrollment, secure APIs.

Repo:
• Python Background Job Microservice

Shields:

Description:
A production-style microservice architecture built with FastAPI, Redis and RQ for asynchronous background job processing.
The system exposes an HTTP API for submitting jobs, checking job status and retrieving results, while a dedicated worker processes tasks asynchronously.
All components run in isolated containers using Docker Compose.

Key Capabilities:

• FastAPI HTTP API for job submission & status tracking
• Redis as a message broker / job queue
• RQ worker for asynchronous background processing
• Fully containerized with Docker & Docker Compose
• Logs, troubleshooting, and multi-service orchestration
• Deployable on AWS EC2 or any Linux host

Architecture:
API → Redis → Worker
Jobs are queued by the API, processed by the worker and results retrieved via HTTP.

Why This Matters:
Demonstrates real DevOps microservice patterns:

• Service separation
• Asynchronous processing
• Container orchestration
• Logging & troubleshooting
• Environment-ready structure

Tech Stack:
FastAPI • Redis • RQ • Docker • Docker Compose • Linux

Repo:
• Finance Tracker API

Shields:

Description:
A production-ready FastAPI backend for tracking personal expenses — fully containerized with Docker and deployed to AWS ECS Fargate using Terraform.
This project demonstrates real-world DevOps engineering: Infrastructure as Code, secure VPC networking, load-balanced container workloads, RDS PostgreSQL, and cloud-native observability.

Key Capabilities:

• JWT-based authentication (register/login)
• CRUD operations for expenses
• SQLite locally, PostgreSQL (RDS) in production
• Modular FastAPI architecture (routers, models, schemas, core)
• Dockerfile + docker-compose for local development
• Swagger UI at /docs
• CI/CD-ready structure for GitHub Actions → ECS

Cloud Infrastructure (Terraform):

• VPC with public + private subnets
• Application Load Balancer (public)
• ECS Fargate service (private subnets)
• RDS PostgreSQL (private subnets)
• Security groups with least-privilege access
• IAM roles for ECS task execution & logging
• CloudWatch log groups for observability
• ECR repository for container images

High-Level Architecture:
ALB → ECS Fargate Task → RDS PostgreSQL
VPC with NAT Gateway, route tables and VPC endpoints for ECR/S3.

Authentication Flow:

• Register → Login → Receive JWT → Use token in Authorization header
• Fully stateless, token-based authentication

What This Demonstrates:

• Cloud-native application deployment
• Infrastructure as Code with Terraform
• Secure networking and IAM design
• Container orchestration with ECS Fargate
• Production-grade backend engineering

Repo:
• Number Guess Game

Shields:

Description:
A fully automated CI/CD pipeline for a Java Servlet web application deployed on AWS EC2.
This project demonstrates a complete DevOps workflow: build, test, quality gate checks, artifact versioning, and automated deployment to Tomcat, all orchestrated through Jenkins Pipeline-as-Code.

Key Capabilities:

• Maven build + unit tests on every commit
• SonarQube Quality Gates for static analysis
• Versioned .war artifacts stored in Nexus
• Automated deployment to Apache Tomcat
• Zero manual steps — fully automated CI/CD
• Clean, production-style multi-server architecture on AWS

Infrastructure:

• Jenkins (CI engine)
• SonarQube (code quality)
• Nexus Repository Manager (artifact storage)
• Apache Tomcat (deployment target)
• AWS EC2 instances (isolated services, no config drift)

Versioning & Rollback:

• Every build stored in Nexus with unique version
• Any version can be redeployed via Jenkins
• Safe, controlled rollback workflow

UI Enhancements:

• Centered layout
• Modern block-style container
• Mossy-hollow color theme
• Improved user feedback

Tech Stack:
Java Servlets + JSP • Maven • Jenkins Pipeline • SonarQube • Nexus • Tomcat • AWS EC2