16 articles on cost allocation — what drives the cost, how it is priced, and where the savings actually are.
Shared clusters are far cheaper than cluster-per-team, but only if one team cannot consume the capacity everyone else paid for. ResourceQuotas, LimitRanges, and priority classes are the controls that make shared infrastructure fair. Here is how to set them.
Shared services are the invisible half of a platform budget: ingress, service mesh, logging, secrets, registries, CI, and the clusters they run on. None of it belongs to a product team, so nobody questions it. Here is how to size, split, and justify that bill.
A tagging policy nobody enforces is a spreadsheet, not a control. Policy as code rejects untagged resources before they deploy, so allocation stays near 100 percent instead of drifting. Here is how to build it.
Untagged resources are the reason your cost allocation never reaches 100 percent. Finding them systematically, by account and service, turns an unattributable slice of the bill into owned, actionable spend. Here is the method.
Chargeback moves real cloud cost onto each team's budget, which changes behavior far more than a report ever will. But it only works if the data is trusted. Here is how to implement it without a revolt.
Networking, observability, support fees, and volume discounts belong to everyone and no one. How you split them decides whether showback is fair or a fight. Here are the common methods and when each fits.
How you structure AWS accounts and organizational units decides how clearly you can see and control cost. A good multi-account layout gives allocation for free; a flat single account fights you forever. Here is how to design it.
The AWS Cost and Usage Report is the most detailed billing data AWS produces, but it is raw and huge. Turning it into queryable, allocated cost data is a pipeline worth building. Here is the architecture.
GCP's billing export streams detailed cost data straight into BigQuery, making SQL your cost analysis tool. It is powerful and easy to start, but the queries themselves can get expensive. Here is how to use it well.
A shared Kubernetes cluster arrives as one bill for many teams, and the node cost hides who used what. Showback by team, driven by resource requests and namespaces, makes the shared cost fair and visible. Here is how.
Cost allocation depends on consistent tags, and the most reliable way to get them is to enforce tagging in Terraform itself. Here is how to apply, standardize, and validate cost-allocation tags through your IaC.
Giving each team a cost budget only works if the budget is enforced where infrastructure is defined. Here is how to attribute Terraform cost to teams and hold each to a budget through the pull request.
A shared cluster hides which team spends what. Splitting cost by namespace, using resource requests, actual usage, and node cost, turns one opaque bill into per-team accountability. Here is how namespace cost attribution works and where it gets tricky.
A pod has no price tag; it inherits a slice of its node's cost based on the CPU and memory it requests or uses. Understanding that translation reveals why over-requesting is expensive and where pod-level waste hides. Here is the model.
The cloud bills nodes; teams consume pods. Here's how to allocate cluster cost by requests or usage, handle shared and idle costs, and where OpenCost/Kubecost and pre-deploy estimation each fit.
The standard 5 tags every resource should have, the activation gotcha that hides historical data, enforcement via Terraform default_tags and Tag Policies, and the anti-patterns to avoid.