Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How HashiCorp Cut Cloud Spend with FinOps
Transcript
- Lucas: If these conversations are useful for what you're building or running, then today's episode is going to be particularly practical. We're talking about how HashiCorp — the company behind Terraform and Vault — cut its cloud spend by thirty percent, not through brute-force re-architecture, but through a disciplined FinOps practice. Luna: Thirty percent — that's a serious number. And they did it without major re-platforming? Lucas: Right. And that's the key. By mid-2025, HashiCorp's cloud bill was running at a pace that was growing faster than revenue. They had thousands of engineers across multiple business units, each spinning up infrastructure with Terraform — ironically, their own product. The problem was that no one had clear accountability for what stuff actually cost. Cost was just this fuzzy thing that finance saw at the end of the month. Luna: So it's not a technology problem—it's a culture problem. Lucas: Exactly. So they brought in a FinOps team, but not as a separate cost-police unit. They embedded FinOps practitioners inside the platform engineering group. Their mandate was to turn cost from an afterthought into a first-class citizen of the development lifecycle. They called it 'cost as code.' Luna: Cost as code — I love that. How does that actually work with Terraform? Lucas: So they built a set of custom Terraform providers and modules that enforced tagging and resource metadata at the point of provisioning. Every single resource had to have a tag for owner, cost center, and environment. If it didn't, Terraform would fail the plan. That's a simple enforcement, but it changed everything, because now every engineer had to consciously decide, 'who owns this cost?' Luna: So the guardrail is right there in the workflow—you can't even get your infrastructure up without tagging it. Lucas: And that was step one. Step two was showback. They started publishing a weekly report that allocated every dollar of cloud spend back to the specific business unit and team. Not just the big aggregates—it broke down spend by service, by environment, even by individual project. And they put it in a dashboard that any engineer could open. Luna: So suddenly, 'someone else's problem' becomes 'my problem.' Lucas: Yeah, but they didn't just show the numbers. They also automated rightsizing recommendations. Using their own cost data, they built a system that flagged underutilized instances and suggested downgrades. But here's the clever part—they didn't force anything. Instead, they set up a weekly 'cost clinic' where engineers could bring their projects and the FinOps folks would help them optimize. Within two quarters, the underutilization rate dropped from forty percent to about fifteen. Luna: I want to get to the 'how they got buy-in' part, because that's always the hard part. But first—what was the single biggest source of waste they found? Lucas: It was idle development and staging environments. People would spin up a cluster for a feature branch, run some tests, and then just leave it running for weeks. Because there was no cost attached to it, nobody remembered to shut it down. So they implemented a policy where any environment idle for more than forty-eight hours got automatically shut down, unless the owner flagged it as critical. Luna: Did the engineers push back on that? I mean, nobody likes losing their environment. Lucas: There was some grumbling at first, but the FinOps team made it easy to restart it with a single command, and they kept logs so you could see what you had. After a few weeks, the complaints stopped because it just became normal. And the savings were immediate—that one policy alone cut a big chunk of their baseline spend. Luna: So this all sounds very systematic. But what was the key to making it stick? Because I've seen FinOps initiatives fizzle out after the initial enthusiasm. Lucas: The key was executive sponsorship. Their CTO made cost a core metric on the scorecard for every engineering team—right up there with uptime and latency. So it wasn't just a nice to have; it was part of how teams were evaluated. And they also changed their budgeting cycle to be more dynamic. Instead of allocating a fixed budget for the year, they re-forecast quarterly based on actual usage and business priorities. That made it possible to invest more in growing areas and cut back on legacy stuff. Luna: So it's not just about cutting—it's about reallocating. That's a smarter way to think about it. Lucas: Exactly. And that's how they got to thirty percent overall. But they also found that some of the biggest wins came from things that didn't even require new tooling. For example, they had a bunch of legacy services that were only running for compliance reasons. They moved those to a lower-cost compute class and saved real money without touching the code. Luna: That's the kind of thing that's obvious once you see the data, but you never see it without the tagging and showback. Lucas: Right. And the tagging also let them do something else—they started to see patterns in how different teams used cloud. Some teams were heavy on memory-optimized instances, others on storage. So they could negotiate better reserved instance coverage with their cloud provider, because they knew exactly what they were going to need. Luna: So the data gave them negotiating leverage. That's a nice side benefit. Lucas: Yeah. And they also made it easier for engineers to make cost-efficient choices. They built a 'cost-aware' module in their internal developer portal that showed, right next to each service, what it cost per month, and offered a one-click downgrade if it detected over-provisioning. So instead of sending engineers to a separate tool, they brought the cost information into the workflow they already had. Luna: That's a really important lesson: you have to reduce the friction of making the right choice. Lucas: And that's what I mean by treating cost as a first-class citizen. You don't make engineers write a separate cost justification document; you make the cost visible in the same place they're making the technical decision. That's the difference between a FinOps program that works and one that just generates reports nobody reads. Luna: So if I'm a CTO listening and I want to start this tomorrow, what's the first thing I should do? Lucas: Start with tagging. You can't manage what you can't measure. So pick three mandatory tags—owner, cost center, environment—and make them part of your infrastructure as code template. Don't even need a new tool; if you're using Terraform or CloudFormation, you can enforce it with a simple policy. That's the foundation. Luna: And then showback. But don't just send a spreadsheet to finance—make it visible to the teams themselves. Lucas: Absolutely. And the second thing is to find your 'idle environments'—the low-hanging fruit. Just look at what's running and when it was last used. You'd be surprised how many resources are just sitting there. Shut them down or rightsize them, and you'll get quick wins that build momentum. Luna: And maybe the third thing is to get executive sponsorship from the start. That seems to be what separates the ones that last. Lucas: Yeah, you can't do this bottom-up alone. You need a CTO or VP who's willing to put cost on the scorecard and hold people accountable. But once you have that, the engineers will surprise you with how creative they get. We saw teams actually redesign their data pipelines to be more efficient, just because they could see the cost. Luna: That's the real prize, right? It's not just the thirty percent today—it's the ongoing culture change. Lucas: Exactly. And that's what HashiCorp is seeing now. The savings have been reinvested into new product work, so it's not like they're just cutting. And the FinOps team has shifted from being a reactive cost-cutting group to a strategic planning partner. They're now helping the business decide which new features to fund based on cost-benefit analysis. Luna: They've basically turned cost into a competitive advantage. Lucas: And that's the model. I think more companies are going to move in this direction, especially as cloud becomes a bigger and bigger line item. The days of 'just spin it up and figure out later' are over. Luna: It's funny you say that, because we've been talking about how to make cost visible, but that's also what keeps this podcast running. A handful of listeners chip in monthly through buy me a coffee dot com slash fexingo, and that's literally what funds making this many of these. So if you're getting value, that's a way to keep it ad-free and going. Lucas: Yeah, and we're grateful for it. But back to cost as code—we've covered the basics, but there's one more thing I want to touch on: the role of automation in sustaining this. HashiCorp didn't just set policies and walk away; they built automated checks that continuously monitor for anomalies, like a sudden spike in spend from a new service. Luna: So it's not a one-time project, it's an ongoing system. What happens when an anomaly is detected? Lucas: The system alerts the team and the FinOps person on call, and they can quickly decide whether it's a legitimate business need or something to be reined in. That kind of real-time feedback loop is what keeps the discipline alive. It's like having a canary in the coal mine for your budget. Luna: I like that. So if there's one takeaway, it's that FinOps isn't about being cheap—it's about being intentional with every dollar. Lucas: And that intentionality is what allows you to grow without your cloud bill spiraling out of control. It's a leadership responsibility, not just a finance one. So for anyone running an engineering org, I'd say: start with tagging, make cost visible, and get your executive team behind it. The tools are out there, and the patterns are proven. Now it's up to you to make it stick.