FinOps Maturity Model: From 'Who Left This Running?' to Cost-Optimized Culture

Assess and advance your organization's FinOps maturity across people, processes, and technology. Covers the crawl-walk-run framework, organizational readiness, metrics that matter at each stage, and the transformation roadmap that turns cloud cost management from reactive firefighting into proactive optimization.

FinOps Maturity Model: From 'Who Left This Running?' to Cost-Optimized Culture

Orientation: The FinOps Maturity Model maps the typical progression an organization undergoes as it moves from reactive cost awareness—answering "who left this running?" after a bill shock—to a proactive, organization-wide culture where cost considerations are embedded in everyday engineering work. It matters when a team has outgrown ad-hoc bill review and needs structured practices for ongoing cost governance, tag enforcement, budget enforcement, and automated right-sizing. This page is organized around what you are trying to accomplish, not around a taxonomy of tools or cloud providers.

Finding and Identifying Waste

What you're trying to do: Answer the immediate question of what's running and costing money without a clear owner. In the early maturity stage, this is typically an ad-hoc investigation triggered by a spike, a complaint from finance, or a mandate to reduce cloud spend.

Concrete approach: Export the cloud provider's billing data to a location you can query. Most providers offer an export mechanism—Cost and Usage Reports, billing exports, or consumption APIs—that delivers daily or hourly line items. Pull the data into a queryable store, then filter for resources with no cost-allocation tags or with owner tags set to generic values. Standard tools like curl to fetch the export, jq to process JSON, and psql to query a loaded database work across providers.


curl -s -H "Authorization: Bearer $TOKEN" "$BILLING_API/v1/exports/latest" | jq -r '.results[] | select(.serviceId == "compute") | select(.status == "active") | .resourceId + " " + .cost + " " + (.tags.Owner // "unknown")'

Sharp edges: Billing data is typically delayed by 24 hours or more, so a resource you just terminated may still appear in the export. Many exports omit zero-value line items, meaning a deleted instance with no data transfer or storage won't show up. Tag propagation across accounts or directories can be inconsistent—you might find a resource tagged in one directory but not another. Additionally, "untagged" does not always mean "unowned"; some services bill at the service level without per-resource tags, requiring you to correlate by resource ID, instance type, or account. Data model differences between providers—such as whether the cost field is priskCost, unblendedCost, or netAmortizedCost—mean your filtering logic must account for the specific export format you're working with, or you risk silently double-counting or missing line items.

Allocating Costs to Teams or Owners

What you're trying to do: Move from "what's running" to "who owns it." This is the foundational step for showback, chargeback, or simply knowing whom to ask when a cost looks wrong.

Concrete approach: Enforce a tagging policy at resource creation. Many teams use an admission controller or a pre-creation hook that rejects resources missing required tags. If you're working with Kubernetes, a ValidatingAdmissionPolicy can enforce owner, environment, and cost-center labels before a pod or service is created.

# Example: ValidatingAdmissionPolicy that requires three standard labels (Kubernetes 1.24+)
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicy
metadata:
  name: require-cost-labels
spec:
  validations:
  - expression: "has(object.request.object.metadata.labels['owner']) && has(object.request.object.metadata.labels['environment']) && has(object.request.object.metadata.labels['cost-center'])"
    message: "Resources must have owner, environment, and cost-center labels"

Sharp edges: Admission controllers only protect new resources; existing resources remain un-tagged until manually updated. Tag propagation latency can mean a resource appears costed in one system before the label propagates to the billing export. Some services—managed databases, serverless functions, or third-party integrations—do not support user-defined labels, requiring alternative allocation methods such as resource ID patterns, namespace segregation, or account-level separation. Enforcement that is too strict can slow down development teams, creating friction that leads to workarounds like label-less resource creation or the use of generic owner values that undermine the allocation model.

Setting Budgets and Alerts

What you're trying to do: Get notified before costs spiral past a tolerable threshold. This shifts the model from retrospective investigation to proactive warning.

Concrete approach: Most cloud providers offer a budget service that can trigger webhooks, email notifications, or SMS when spend crosses a configured percentage of the limit. The mechanism is generally the same regardless of provider: define a budget with a limit and one or more thresholds, attach an alert endpoint, and ensure the billing feed is current.

# Generic pattern: create a budget with an 80% forecasted threshold via API
curl -X PUT "$BILLING_API/accounts/$ACCOUNT_ID/budgets/$BUDGET_NAME" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
        "limitAmount": {"amount": "10000", "currency": "USD"},
        "thresholds": [{"percent": 80, "notificationType": "FORECASTED", "thresholdType": "PERCENTAGE_OF_LIMIT"}],
        "notificationChannels": [{"type": "EMAIL", "address": "finops@example.com"}]
      }'

Sharp edges: Budgets operate on forecasted spend, which means a threshold can fire before the actual cost is known—useful for prevention, but prone to false positives if usage is highly volatile. Notification channels that rely on email or webhook delivery can be silenced by infrastructure issues, and there is often a lag between a threshold crossing and the actual notification delivery. Forecast accuracy depends on the consistency of the daily billing export; if the export is incomplete or delayed, the forecast may diverge from reality, leading to either unnecessary alerts or missed ones. Additionally, threshold fatigue is real: if budgets fire too frequently, teams begin to ignore or mute them, defeating the proactive purpose.

Automating Optimization

What you're trying to do: Take action on wasteful resources without manual intervention. In the advanced maturity stage, the goal is to close the loop: detect → recommend → auto-remediate.

Concrete approach: Use a scheduler or an autoscaling mechanism to right-size or terminate resources that meet waste criteria. A common pattern is a nightly cron job that queries the cost allocation data, identifies resources idle for N days, and issues a stop or termination command. The key design choice is whether the script acts directly or generates a ticket/pull-request for human review.

# Example: identify compute resources idle for 14+ days and generate review tickets
curl -s "$BILLING_API/v1/resources?status=running" | jq -r '.[] | select(.lastSeen < now - 1209600) | .resourceId' | while read id; do
  gh issue create --title "Consider stopping idle resource $id" --body "Resource $id has been running without an owner tag for over 14 days. Verify before termination."
done

Sharp edges: Auto-termination is the sharpest edge in the entire maturity model. An instance that appears idle in metrics may be performing a batch job, a backup, or a cross-region replication that only runs periodically. Auto-stopping without a grace period can cause data corruption for stateful workloads. Rightsizing recommendations based on CPU/memory metrics can suggest instance types that are incompatible with your software stack—for example, a rightsizing suggestion that moves from a compute-optimized to a memory-optimized instance may fail deployment if the application assumes a specific vCPU-to-memory ratio. The safest approach is to auto-generate tickets or pull requests rather than acting directly, letting a human verify before the resource is changed. Even then, reviewers may lack the context to judge whether a resource is truly wasteful, leading to either overly conservative decisions (leaving waste in place) or risky approvals.

Embedding a Cost-Optimized Culture

What you're trying to do: Make cost awareness a routine part of how the organization builds, runs, and improves software. This is the distinguishing mark of the highest maturity stage: cost optimization is not a separate function but a default dimension of every engineering decision.

Concrete approach: Embed cost data into the tools engineers already use. Add a "monthly cost estimate" field to pull-request templates, so every change is accompanied by a rough cost impact. Integrate cost queries into CI pipelines so that a merge gate can reject changes that would increase the monthly run rate beyond a team-agreed cap. Make cost dashboards the default view on internal developer platforms, so a developer sees the cost implications before they see CPU or memory metrics.

# Example: pull-request template snippet with cost impact question

---
name: Cost Impact
description: "Estimate the monthly cost impact of this change"
questions:
  - "Which resources does this change add or modify?"
  - "What is the estimated monthly cost impact (USD)?"
  - "Has this been discussed with the team owner?"
---

Sharp edges: Cost estimates in early stages are just that—estimates. They can be wrong by an order of magnitude, especially for serverless workloads, data transfer-heavy applications, or workloads with spiky seasonal patterns. If the gate is too strict, engineers will learn to circumvent it (splitting changes, under-reporting impact), which defeats the purpose. Cost myopia is a real risk: teams may optimize for low cost at the expense of performance, reliability, or user experience. The cultural work of framing cost as one of many trade-offs, not the primary one, is ongoing and never fully resolved. Additionally, cost data that is too granular (per-resource, per-hour) can overwhelm developers; aggregating to the team or service level usually strikes a better balance between usefulness and noise.

This page was rewritten on 26 October 2026. It replaced a templated version that was not specific to its own title. How these pages are written and checked. If anything here is wrong, tell us at hello@thegarnetwiki.com and we will correct it.