Complete AIOps Resume Project | Full Workflow + Guide

Hi Inner Circle,
This one's been a long time coming.

The AiOps Project is a complete, end-to-end DevOps + AIOps system built on real AWS infrastructure, and this newsletter breaks down exactly how it works, what it's made of, and the three biggest lessons you can take away from building it

The Core Idea

A developer writes code locally, and by the time that code reaches production, it has been built, containerized, deployed via GitOps, monitored across three observability layers, and is diagnosable by an AI agent named Kira, powered by AWS Bedrock.

The Full Pipeline, Stage by Stage

• Local Development — Docker Compose runs all 7 microservices locally: Frontend, Gateway, Auth, Product, Order, Orders, User, plus PostgreSQL, Prometheus, and Grafana

• Source Control — Git branching, PRs, and merges to main trigger everything downstream

• CI Pipeline — GitHub Actions builds all 7 Docker images in parallel, pushes to Amazon ECR, then commits updated image tags back to Git

• Infrastructure — Terraform provisions a VPC across 3 AZs, an EKS cluster, ECR repos, and installs ArgoCD plus kube-prometheus-stack via Helm

• GitOps Deployment — ArgoCD watches the main branch, detects new image tags, and rolls out updates to EKS automatically

• Observability — Prometheus scrapes /metrics from every service; Fluent Bit ships pod logs to CloudWatch; Grafana surfaces request rate, p95/p99 latency, error rates, and pod health.

• AIOps — Kira, a Bedrock Agent, investigates incidents by calling three Lambda tools: fetch_logs (CloudWatch), fetch_metrics (Prometheus API), and fetch_health (EKS). She returns a root cause, supporting evidence, a fix, and prevention steps.

Every Tool That Powered This Build

16 tools across local dev, CI/CD, cloud infra, observability, and AI, working as one cohesive system.

The Complete System Design, in One Flow

Here's the full picture, from first keystroke to AI-powered diagnosis:

Workflow 1 – Local Development

• Developer writes code.

• Docker Compose runs it locally.

Workflow 2 – Cloud Infrastructure (Terraform)

(Infrastructure is already provisioned through Terraform and used by the pipeline)

Workflow 3 – CI/CD (GitHub Actions)

• git push triggers GitHub Actions.

• Actions builds and pushes all 7 images to ECR.

• commits the new image tags back to Git.

Workflow 5 – GitOps (ArgoCD)

• ArgoCD detects the change and performs a rolling deploy to EKS.

Workflow 4 – Observability (Prometheus + Grafana)

• Prometheus scrapes metrics and Fluent Bit ships logs to CloudWatch.

• Grafana dashboards light up.

Workflow 6 – AIOps (Kira)

• When something goes wrong, Kira correlates logs, metrics, and pod health to hand the engineer a root cause plus a fix.

Every step is automated. Every layer is observable. And every incident has an AI co-pilot ready to investigate.

Tools in the Stack

• Docker Compose, GitHub Actions, Amazon ECR

• Terraform, AWS EKS, ArgoCD

• Prometheus, Grafana, Fluent Bit, CloudWatch

• AWS Bedrock, AWS Lambda, Streamlit

• Kubernetes, PostgreSQL, prom-client

3 Critical Takeaways for Interview

If you're building something similar, or just want to level up your DevOps thinking, here's what I'd want you to walk away with:

GitOps is the glue

When CI commits image tags back to Git, ArgoCD closes the loop automatically. Git becomes the single source of truth for every deployment. No manual kubectl apply. No drift. The cluster always reflects what's in the repo.

Observability needs all three layers

Metrics (Prometheus), logs (CloudWatch), and health checks (EKS) each catch different failure modes. A spike in p99 latency tells you something is slow. Logs tell you why. Pod health tells you if it's already dead. Kira's power comes from correlating all three at once, which no single tool does on its own.

AI agents work best with scoped tools

Kira never guesses. Each Lambda function does exactly one thing: fetch logs, fetch metrics, or fetch health. The Bedrock Agent reasons across those outputs. Narrow, focused tools produce trustworthy conclusions. The moment an agent has to do too much in one call, accuracy drops. Keep the tools tight.

That's the AIOps Project. Watch the full build on YouTube and dig through the code on GitHub, links are in the buttons above.

I'd love to hear what you're building.

Hit reply and let me know!