The Floor
Your cloud bill keeps climbing even after you’ve done everything finance can do. Tagging, rightsizing, cleanup and commitments find the first 15 or 20 percent. After that, every technique stops at the same place.
This episode is the first argument in my course, Architecting for Cost: the floor. What’s left on the bill is there because of a design decision someone already made, and finance can’t see those decisions from a spreadsheet.
In this episode:
- Why the finance playbook is good, and where it stops
- Why rightsizing, tagging and commitments all hit the same floor
- Two decisions that set the floor: forty services, and a fifteen-minute recovery point
- Why the architect owns a number they don’t control
- Where you have leverage: the design review
- When the floor isn’t your problem yet
- This week: find the decision behind your three biggest non-compute lines
Links:
Show transcript
Hello and welcome to Software Architecture Insights, your go-to resource for empowering software architects and aspiring professionals with the knowledge and tools they require to navigate the complex landscape of modern software design. Your cloud spend is up again. Finance puts the chart on the screen and everyone in the room looks at engineering.
So you do what a responsible team does. You turn on tagging so every dollar traces back to a team. You right-size the instances that are bigger than they need to be. You switch off the things nobody uses. You buy reserved capacity for the workloads that you know will still be running next year. And it works. The first pass takes fifteen, maybe twenty percent off the bill.
Then the bill starts climbing again anyway. Here’s why, and it’s the first argument in my course, Architecting for Cost. I call it the floor.
Let me start by defending the playbook. Tagging, right sizing, cleanup, and commitment, all that is real work. They’re usually the fastest money in the building, and they need almost nothing from engineering except access. If your company hasn’t done those things yet to try and reduce your cloud bill, stop listening and go do them. And I mean that.
But watch what happens over the next year. The first pass of doing that process finds 15 or 20%, and your cloud bill does actively go down for a while. The second pass finds maybe 4%. The third pass takes engineering weeks, and you end up finding just a little rounding error.
Most teams read that as a discipline problem, so they add a monthly cost review. They put a dashboard up on the wall. They assign someone to chase the top 10 line items, but the growth curve just doesn’t change.
The reason is that every technique in the playbook stops at the exact same place. Right sizing makes a wasteful instance cheaper, but it can’t make the instance unnecessary. Tagging tells you what team owns a line item and never tells you why the line item exists in the first place. A reserved instance commitment buys the same capacity at a discount, but you still bought the capacity.
Finance can run all three perfectly well and still hit the same floor. Everything left on the bill is there because of a decision somebody already made, and you can’t see those decisions from a spreadsheet.
Let me show you one. A team breaks a monolith into 40 services. They do that for good reasons: independent deploys, clear ownership, teams that stop waiting on each other to ship. For a large organization, moving from a monolith to services can be real valuable work to be done. But here’s what comes along with it. 40 load balancers, at least 80 instances because each service needs at least two in order to stay highly available, 40 connection pools to your database, most of them idle, 40 log streams. And calls that used to be function calls now cross the network. Some of those cross a zone boundary and that traffic is metered and billed.
None of that was on the whiteboard during the design review where you decided to move to a service-based architecture in the first place. All of it has been on the bill every month since.
Here’s a second example. A team commits to a 15-minute recovery point for a database. That’s a reasonable target. Someone senior asked for it, and nobody wanted to be the person arguing for more data loss. But 15 minutes means continuous replication. That means a warm standby, maybe in a second region, with duplicate storage. And every single write crosses a region boundary and gets billed for the life of the system. An architect made that call in a meeting where nobody said a price out loud.
Now put an analyst in front of that bill. They can see the load balancer line and the data transfer line rising together quarter after quarter. They can chart it. They can allocate it to the right team. They can ask the platform group to even explain what it is.
What they can’t do is decide that two of those 40 services should be one, or that a four-hour recovery point would probably be good enough, or that a single region is good enough for this application. Those calls need someone who knows what the services do, who depends on them, and what breaks if they change. In most companies, that person is the software architect, probably you, and you almost certainly don’t own the cloud budget.
You’ll still be asked to explain it, to defend it, and to bring it down. You’re accountable for a number that you don’t control. So where do you have leverage?
Your leverage comes early in the process. By the time a line item shows up on an invoice, the decision behind it is months or years old. Undoing it costs a migration project and a spot on somebody’s roadmap for at least a quarter or two. Made in the design review, the same decision costs one more conversation. Cost work at the end of the quarter is expensive cleanup. Cost work done early on during the design review, that’s architecture.
Now, one caveat here. If you haven’t done the basics that we talked about early on, the floor isn’t your problem yet. Tagging and right-sizing, those things come first, and they’ll pay for themselves quickly. And if the system is small and the bill is small, a long design conversation costs more than it saves. Some savings really are just on the invoice, and finance can get those done fine. The floor matters once the easy money is gone and the bill is still growing.
So this week, open your bill and pick the three biggest lines that aren’t plain computing. Things like load balancers, data transfer, replication, storage tiers, whatever is the biggest. For each one, find the decision behind it. Who made the decision? When was the decision made? And whether anyone priced it at the time.
Then add one question to your next design review. What will this design cost every month? And which part of the design sets that number? If nobody can answer that question, you’ve found your floor.
This is the first lesson in my new course, Architecting for Cost, a course designed to help software architects get a handle on cloud computing costs. The launch price for this course is $495 instead of the normal $695, and that special runs through Tuesday, December 1st. I’m also walking through the same argument in a free webinar this Thursday, November 19th, at 10:00 AM Pacific Time. It’s called When the Cloud Savings Stop. The link to the webinar and to the course are both in the show notes.
Thank you for joining us on Software Architecture Insights. If you found this episode interesting, please tell your friends and colleagues. You can listen to Software Architecture Insights on all of the major podcast platforms.
And if you want more from me, take a look at some of my many articles at softwarearchitectureinsights.com. And while you’re there, join the 2000 people who have subscribed to my newsletter, so you always get my latest content as soon as it’s available. Thank you for listening to Software Architecture Insights.
Enjoyed this episode? Get the next one.
Practical architecture thinking, every Tuesday morning. From someone still doing the work.
Join 1,000+ architects & engineering leaders. Unsubscribe anytime.