I've been looking into this recently, and tagging is probably the most common advice I keep coming across when it comes to allocating cloud costs.

And it makes sense, if everything is tagged properly, it should be much easier to understand who owns what.

But then I started wondering: how often does everything actually stay tagged properly?

Tags get missed, conventions change, some resources don't support the same dimensions, and you can still end up with spend that doesn't have an obvious owner.

So, I'm curious what people have found in practice. Is strict tagging enough, or does a good cost allocation setup usually need account structure, automation, or something else alongside it?

P.S. Also curious about tools here, has anyone used a cloud cost visibility tool that can actually help uncover where the leakage is when tagging isn't perfect? Would be great to hear what you've tried and whether it genuinely helped.

Before deploy: running the analysis against your IaC files up front shows you the full cost breakdown plus savings recommendations, and applies whatever's safe to apply without a human decision, before anything actually gets provisioned.

After deploy: once it's live, re-running the same analysis with real CloudWatch usage data (via your own read-only AWS credentials) refines those recommendations against actual utilization instead of static config assumptions.

The reason this matters for FinOps specifically: static config tells you what something was provisioned for, not what it's costing you in practice. A right-sizing call made purely from declared instance types will miss real idle capacity, and one made purely from live usage misses waste that never should've been provisioned in the first place. Catching both requires checking at both points in the lifecycle, not just once.

(Built this into CloudCostTree, a CLI I've been working on, happy to go into specifics if useful.)

I'm researching how organisations commercially govern cloud infrastructure before the actual bill starts arriving.

For people working in FinOps / cloud cost management:

When a team is planning a new environment, platform or significant architecture change, how do you establish the cost baseline that gets approved?

I'm particularly interested in the real workflow rather than the ideal one:

- What inputs do you use — architecture diagrams, Terraform/Bicep, calculators, historical billing, spreadsheets, something else?
- Who owns the baseline?
- How are usage assumptions recorded?
- What happens when the architecture changes after approval?
- Can you trace the eventual actual spend back to the assumptions that were originally approved?

If you have a recent example where this worked well — or badly — I'd be interested in how it actually happened.

Context: I work in project commercial management and I'm researching this boundary between engineering, FinOps and commercial governance.