AWS DevOps Certification vs the Agent That Cut Our Bill
AWS DevOps certification covers cleanup nobody does. We let an agent handle it instead—here's what actually worked and where it failed.
Every AWS account collects clutter. A sandbox spun up for a demo, a CloudFormation stack from a project that shipped a year ago, a storage volume that outlived the server it was attached to. None of it breaks anything today, so the cleanup slides to next quarter, then the quarter after that. Much of what an AWS DevOps certification drills into you — CloudFormation lifecycle management, cost optimization, resource governance — is exactly this unglamorous housekeeping. So we tried something different: instead of blocking out an afternoon nobody wanted, we let an agent do the housekeeping under supervision. What follows is what actually happened, where it got stuck, and what it means for how a studio runs its cloud bill.
The chore nobody schedules
Cloud clutter behaves like a gym membership you forgot to cancel. Nothing dramatic happens the month you stop going. The charge is small, it's automatic, and it hides inside a bigger number you glance at once a month. Multiply that across a few dozen resources and a couple of years, and the "small" charges become a line item worth a conversation.
The industry data backs up the instinct. In Flexera's annual State of the Cloud Report, organizations consistently self-report that roughly 30% of their cloud spend is wasted. That figure has barely moved for years — not because nobody knows how to fix it, but because cleanup is boring, slightly risky, and never urgent. It's the definition of a task that gets postponed.
Here is why it matters for a business, not just for a bill: waste is quiet. It doesn't page anyone at 3 a.m. It doesn't show up in a sprint retro. It just sits there, and the longer it sits, the more nervous everyone gets about touching it — what if that stack is still load-bearing? That fear is the real cost. It turns a €40/month leak into a permanent one.
Real numbers: what forgotten resources actually cost
Abstract percentages don't motivate anyone. Specific AWS line items do. These are published, real prices for common leftovers:
- A NAT Gateway you forgot to tear down runs about $0.045 per hour in most regions — roughly $33 per month before you add data processing charges. Leave two behind from old VPCs and that's ~$800 a year for nothing.
- Unattached Elastic IPs. Since February 2024, AWS charges $0.005 per hour for every public IPv4 address, attached or not — about $3.60 per month each. Trivial alone; a fleet of orphans adds up.
- Old EBS volumes and snapshots. A forgotten 100 GB gp3 volume costs about $8 per month at $0.08/GB. Snapshots pile up at roughly $0.05/GB-month and rarely get pruned because deleting a backup feels dangerous.
- Idle RDS instances left running after a migration can quietly bill more than everything above combined.
None of these are exotic. They are the leftover boxes in a warehouse where you still pay rent on the floor space. Honest take: individually they're not worth an engineer's afternoon, which is precisely why they never get cleaned. The economics of attention are upside down — the fix costs more focus than any single item saves, so nobody does it.
Clearing old CloudFormation stacks by chatting with an agent
CloudFormation is the right place to start, because a stack is a manifest. Think of it as the packing list for a shipment: define it once, and AWS creates and later removes every resource on the list as a unit. Delete the stack, and in theory the NAT Gateway, the volumes, the security groups, and the IAM roles all go with it. That's the clean version of cleanup — no orphans, because the manifest tracks every box.
The agent's job was straightforward to describe and tedious to do by hand: list the stacks, tell us which were last updated over a year ago, summarize what each one contained, and flag anything that looked production-adjacent. Instead of clicking through the console stack by stack, the work became a conversation — "show me stacks untouched since last year, grouped by what they cost to keep." The agent pulled the inventory, cross-referenced rough cost, and proposed a delete order starting with the obviously dead ones.
Two things made this safe rather than reckless. First, nothing was deleted without an explicit confirmation per stack — the agent proposed, a human approved. Second, every action was logged in a form we could read back afterward. That second point is not a detail. An agent that deletes infrastructure is only trustworthy if you can reconstruct exactly what it touched and why, which is the whole argument in why your AWS DevOps agent is only as good as its log. A delete you can't audit is a delete you'll second-guess forever.
The stack that refused to delete
Then one stack got stuck in DELETE_FAILED. This is common enough that AWS documents it thoroughly in its CloudFormation troubleshooting guide. A stack lands in this state when CloudFormation can't remove one of its resources — usually because something outside the manifest depends on it, an S3 bucket still has objects in it, or a resource carries a DeletionPolicy: Retain that tells AWS to leave it alone.
The manual fix is fiddly and easy to get wrong at 5 p.m.: identify the specific resource blocking the delete, retain that one resource while deleting the rest of the stack, then deal with the holdout separately. Get the order wrong and you either abandon the delete or accidentally remove something the blocking resource still needed.
This is where the agent earned its keep. It read the failure event, named the exact resource that failed to delete, and explained why — a dependency the original template never accounted for. It then proposed the standard workaround: delete the stack while retaining the problem resource, confirm the rest was gone, and handle the holdout as a deliberate, separate decision rather than a blind retry. The stack cleared. Put simply: the annoying part of the chore — diagnosing a failure state and knowing the right escape hatch — is exactly the part an agent handles well, because it's pattern-matching against documented behavior, not guessing.
Then we pointed it at the whole account
Deleting old stacks only covers resources that were created by CloudFormation. The more expensive problem is usually the stuff created by hand, in a hurry, outside any template — an instance launched for a one-off test, a volume detached and never deleted, a load balancer left up after a service was retired. These have no manifest tracking them, so they never get cleaned as a group.
So the last step was to have the agent scan the whole account for leftovers actually running up the bill: idle resources, unattached storage, gateways with no traffic, IP addresses pointing at nothing. It correlated what was running against what was actually being used, then ranked findings by monthly cost so the review started with the items that mattered.
Your cloud bill is, in a real sense, feedback nobody ever types out. No one files a ticket saying "this volume is wasting €8 a month" — the signal is buried in a usage graph that stays flat because the resource does nothing. Surfacing that kind of unstated signal is the same discipline we wrote about in reading the feedback users never type: the important information is rarely the information someone hands you directly.
Alternatives and trade-offs (an honest comparison)
An agent is not the only way to do this, and it's fair to weigh it against the tools a certified engineer would normally reach for.
- AWS Trusted Advisor and Cost Explorer. AWS's own Cost Explorer and Trusted Advisor already flag idle load balancers, underused instances, and unattached volumes. They're excellent at finding waste. The gap is that they hand you a list and stop — you still have to go verify each item, understand the dependencies, and click delete. The finding is cheap; the acting is where the afternoon goes.
- Doing it manually in the console. Maximum control, maximum tedium. This is the "correct" approach that never happens, because it competes with shipping features and always loses. Reliability that depends on a human remembering to do a boring task is not reliability.
- Custom scripts and Infrastructure-as-Code hygiene. Writing a script to sweep orphaned resources is the professional answer, and for a large account it's the right long-term investment. The trade-off is upfront cost: you have to build, test, and maintain the sweeper, and a script only catches the cases you anticipated. It won't reason about a novel
DELETE_FAILEDcause it's never seen. - Third-party FinOps platforms. Powerful for large organizations, overkill for a studio with one or two accounts, and they add a vendor and a monthly fee to a problem you're trying to reduce spend on.
Here is what we recommend: use Trusted Advisor and Cost Explorer as the source of truth for what is wasteful — they're free and authoritative — and use an agent for the acting part: triaging the list, explaining dependencies, handling stuck states, and executing deletes one confirmation at a time. For anything you'll repeat on a schedule, graduate the pattern into a real script. The agent is the fast path to a clean account today; the script is how you keep it clean without thinking about it.
What this means for the skills behind an AWS DevOps certification
There's a natural worry lurking here: if an agent can reason about CloudFormation lifecycles and cost optimization, does the human expertise behind an AWS DevOps certification still matter? It matters more, not less — but the leverage shifts. The certification's value was never in remembering that DELETE_FAILED can be caused by a retain policy. It's in the judgment to know which stack is safe to touch, when a "waste" resource is actually a warm standby, and where automated cleanup could take down something quietly load-bearing.
The agent handled the mechanical layer — inventory, correlation, the documented workaround. The human held the judgment layer — approval, context, and the call on the ambiguous cases. That division of labor is the same one that makes automation work anywhere in a team, and it's the point we make in how DevOps actually works in real teams: tools don't replace ownership, they move the human's attention to the decisions that actually need a human.
Key takeaway for business
Cleanup is a solved problem that stays unsolved for organizational reasons, not technical ones. The tooling to find waste has existed for years; what's been missing is a cheap way to act on the findings without burning an engineer's focus on it.
Three conclusions worth keeping:
- The barrier was never knowledge — it was attention. Roughly 30% of cloud spend is wasted industry-wide, and the fix has always been available. An agent lowers the cost of doing the boring, risky part enough that it finally gets done.
- Keep the human on approval and the log. The delete authority stayed with a person, and every action was auditable. Automation you can't reconstruct after the fact is a liability, not a convenience.
- Turn the one-off into a habit. The first pass clears the backlog. The real win is scheduling a recurring account scan so waste never compounds into that same paralyzing "what if it's load-bearing?" fear again.
Honest take: an agent didn't make anyone's AWS expertise obsolete. It just removed the excuse for leaving the account messy — and that's worth more than the bill it cut.
This article is based on publicly available sources and may contain inaccuracies.


