
Completing All 5 AWS DevOps Agent Challenges — Builders Skill Sprint May 2026
A hands-on walkthrough of completing all five AWS DevOps Agent challenges from the AWS User Group Madurai Builders Skill Sprint, covering Lambda debugging, EC2 CPU diagnosis, IAM permission issues, and building a custom RDS connectivity outage simulation.
Introduction
I recently completed all five challenges from the AWS User Group Madurai's Builders Skill Sprint — May 2026 DevOps Month. The sprint focused on using AWS DevOps Agent to investigate and resolve real-world operational issues using plain English — no coding required for most challenges.
Here's a summary of my experience, what I learned, and how the agent performed as an AI-powered SRE teammate.
What is AWS DevOps Agent?
AWS DevOps Agent is an AI service that monitors your AWS environment, investigates operational issues, identifies root causes, and recommends fixes — all through natural language conversation. You describe a problem, and it correlates metrics, logs, and resource configurations to pinpoint what went wrong.
The Challenges
Challenge 1: Meet Your Agent ⭐
Goal: Set up the agent and have a conversation about your AWS environment.
I asked the agent questions like "What resources do I have?" and "Is anything unhealthy?" — it responded with a clear, plain-English inventory of my account including the CloudFormation stacks, Lambda functions, and CloudWatch alarms it discovered. It even proactively flagged that a Lambda function was intentionally broken and would fail once invoked.
Key takeaway: The agent provides conversational context awareness — it doesn't just list resources, it interprets their state.

Challenge 2: First Investigation ⭐⭐
Scenario: A Lambda function (
challenge2-broken-fn ) fails on every invocation.Root cause: The handler referenced an undefined variable
config , causing a NameError on every run.Fix: Defined the config variable before the handler:
config = {"value": "hello"}def handler(event, context):return {"result": config["value"]}After deploying the change, the function succeeded and the
challenge2-broken-fn-errors alarm returned to OK.Key takeaway: The agent analyzed CloudWatch logs, identified the exact exception type, and pointed to the problematic line — faster than manually sifting through log groups.

Challenge 3: Stress & Diagnose ⭐⭐⭐
Scenario: An EC2 instance (
challenge3-stress ) had critically high CPU with the alarm challenge3-high-cpu firing.Root cause: The instance's user-data script launched infinite bash spin loops on both vCPUs of the t3.micro at boot time:
#!/bin/bashfor i in $(seq $(nproc)); dosetsid bash -c "while true; do :; done" >/dev/null 2>&1 < /dev/null &doneThis pegged CPU at 100% indefinitely.
Fix: Connected via SSM Session Manager and killed the runaway bash processes.
Key takeaway: The agent correlated the CloudWatch CPU alarm with the instance state and recommended connecting via Session Manager to investigate process-level activity — exactly the right workflow.

Challenge 4: Bad Deploy Detective ⭐⭐⭐⭐
Scenario: A Lambda function (
challenge4-app-fn ) with correct-looking code fails on every DynamoDB read after a deploy.Root cause: The IAM execution role was missing
dynamodb:GetItem permission — the CloudFormation template only attached AWSLambdaBasicExecutionRole . Every invocation threw AccessDeniedException .Fix: Attached the
AmazonDynamoDBReadOnlyAccess managed policy to the Lambda's execution role. The function immediately started returning the expected product data:{"statusCode": 200,"body": "{"item": {"id": {"S": "1"}, "product": {"S": "Builders Hoodie"}, "price": {"N": "49"}}}"}Key takeaway: The agent correctly identified that the issue was NOT in the code — it was a permissions/configuration problem. This is exactly the type of subtle post-deploy regression that causes real production incidents.

Challenge 5: Build Your Own 🚀
For the innovation challenge, I built a banking API and simulated a realistic production outage.
Architecture:
Client → API Gateway → Lambda (challenge5-bank-api) → Amazon RDS PostgreSQL (challenge5-postgres)

What I built: A health endpoint through API Gateway that verifies connectivity to the PostgreSQL database. The entire environment was provisioned using CloudFormation.
How I broke it: After verifying the application was healthy and returning HTTP 200 responses, I intentionally removed the inbound security group rule that allowed the Lambda security group to reach RDS on port 5432:
aws ec2 revoke-security-group-ingress \ --group-id sg-009d8ac4a3f087388 \ --protocol tcp --port 5432 \ --source-group sg-00e7c9eb09716132a \ --region ap-southeast-2This simulated a real-world scenario where a security hardening change accidentally removes database connectivity.
What the agent found: The AWS DevOps Agent investigated the CloudWatch alarm and identified that Lambda was timing out on database connections. The RDS instance itself was healthy, but the missing security group rule prevented network connectivity between Lambda and the database.
Fix: Restored the inbound security group rule:
aws ec2 authorize-security-group-ingress \ --group-id sg-009d8ac4a3f087388 \ --protocol tcp --port 5432 \ --source-group sg-00e7c9eb09716132a \ --region ap-southeast-2The API immediately recovered without any code changes. I also created an operational runbook documenting investigation and recovery steps for this class of failure.
Key takeaway: Security group misconfigurations are one of the most common causes of "it worked yesterday" outages. The agent's ability to correlate application-level timeouts with network-level configuration changes is powerful.

What I Learned
- The agent thinks like an SRE — it doesn't just read logs; it correlates signals across CloudWatch metrics, logs, IAM policies, and resource configurations.
- Plain English is enough — every investigation started with a simple description of the problem. No query languages, no dashboard hunting.
- It identifies the right layer — whether the issue was code (Challenge 2), compute (Challenge 3), permissions (Challenge 4), or network (Challenge 5), the agent correctly identified which layer was broken.
- Speed matters — problems that would take 15-30 minutes of manual investigation were diagnosed in under 2 minutes of conversation.
- It's a teaching tool — beyond fixing the immediate problem, the agent explains why something failed, which builds operational understanding over time.
Services Used
- AWS DevOps Agent
- AWS CloudFormation
- AWS Lambda
- Amazon EC2
- Amazon DynamoDB
- Amazon RDS (PostgreSQL)
- Amazon API Gateway
- Amazon CloudWatch
- AWS Systems Manager (Session Manager)
- AWS IAM
Resources
Conclusion
AWS DevOps Agent is a genuinely useful operational tool — not just a chatbot wrapper around CloudWatch. It understands service relationships, correlates failures across layers, and provides actionable recommendations. For teams running production workloads, this could significantly reduce mean time to resolution (MTTR).
If you're looking to try it out, the Builders Skill Sprint challenges are an excellent structured way to experience the agent's capabilities firsthand.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article