Originally published on Medium.
Most advice about cutting cloud costs starts with pricing: reserved instances, savings plans, the right instance family, a better region. All of that matters. But when I helped build CloudOps AI at Builder.ai, the biggest savings didn’t come from cleverer math. They came from finding the servers nobody remembered starting.
What we were building
CloudOps AI helped companies run AWS at the lowest possible cost. It offered prepaid options for AWS and used reserved-instance algorithms to work out where a customer could commit capacity and pay less. I was on the founding team and built the backend from scratch, working with sales, finance, product and customers to turn their requirements into the system.
On paper, it was an optimization product: look at what a company runs, recommend the cheapest way to run it.
In practice, the hardest assumption to get right wasn’t in the algorithm at all.
The real source of waste
In smaller companies, cloud access is often handed out freely. Developers get it. Juniors get it. Freshers get it. Most of them have never seen a cloud bill and don’t think about what a running server costs per hour.
So this happens all the time. Someone spins up a server in one region to test something. The test ends. The server doesn’t. Nobody checks that region again, because nobody checks every region. And it bills, quietly, every single day.
That changed how we designed the product. We couldn’t only assume waste came from paying the wrong price. We had to assume it came from people. So beyond recommending reserved instances, the system kept scanning every service in every region for running resources, and flagged anything that looked out of place.
The case that proved it
One customer had run up a bill of around ₹10 lakh (roughly $12,000) from servers left running that nobody was watching. No pricing optimization would have caught it. Only looking everywhere did.
That was the moment the product proved its value. Recommendations about reserved instances save money slowly. Catching a leak like that stops the bleeding the same day.
Flag, don’t kill
Finding a forgotten server is easy. Deciding what to do with it is not, because “forgotten” sometimes isn’t. A server that looks idle might be a job that runs once a month, or something a client depends on that nobody documented.
So we built a process, not a kill switch:
- Scan every service across every region for running resources.
- Compare usage against its own history. If it looks anomalous, flag it by service or by region.
- Send the flag into an approval cycle.
- If the first person ignores it and the cost keeps climbing day by day, escalate it until someone confirms: shut it down, or keep it.
The one rule we never broke: we never shut down a server without consent. The system could be persistent, and it got more urgent as the cost grew, but it never made an irreversible decision on the customer’s behalf. Savings matter, but taking down something that’s genuinely in use costs far more than any bill.
How we measured it
The impact showed up in the bill itself. Without intervention, a leak like that grows with every passing day. Once the flagged resources were confirmed and shut down, that daily growth simply stopped.
What a tool can’t fix
Here’s the uncomfortable truth: we couldn’t stop the leak from coming back.
If a company keeps giving cloud access to every developer and fresher, an external tool can’t change that. It’s the company’s own access decision. What a tool can do is catch the leak early, every time. That means alerts, notifications, approval cycles and clear SOPs, set up in the most cost-effective way, with the monitoring giving people enough information to make the call quickly.
The tool is the smoke detector. It isn’t the fire policy.
What I’d tell a founder looking at their cloud bill
Before you negotiate a discount or buy reserved instances, find out what’s actually running and who started it.
- Check every region, not just the one you use. Forgotten resources live where nobody looks.
- Decide who gets cloud access, and at what level. Not every developer needs the power to start a production-sized server.
- Make cost visible to the people creating it. Someone who sees what their test server costs per day behaves differently.
What I’d tell an engineering lead
- Alert on anomalies against history, not just on fixed budget thresholds. A small service quietly doubling is the early warning.
- Build an escalation path, not a kill switch. Flag, escalate, confirm, then act. Never let automation take down something on its own.
- Write the SOP. Who confirms, how fast, and what happens if nobody answers. A flag nobody owns is just noise.
The lesson
Cloud cost is a behaviour problem first and a pricing problem second. The math helps once you know what you’re running. But the money that hurts most is the money you didn’t know you were spending, on servers nobody remembers starting.
Fix visibility first. Then optimize.
Top comments (0)