What is a monthly cloud cost review, and who should run it?
A monthly cloud cost review is a short, time-boxed engineering routine, typically an hour or two, in which the teams that own services look at what those services cost and decide what to change. It is not a finance report. The output is a small list of tickets with owners, not a slide deck.
The routine exists for three reasons:
- Attribution. Every line of spend should map to a service and a team. Spend that maps to no one tends to grow, because no one is responsible for questioning it.
- Catching waste while it is cheap to fix. Idle resources, unused volumes left behind after instance termination, and misconfigured defaults such as unlimited log retention or oversized default instance types are easiest to clean up shortly after they appear. At that point someone still remembers why they exist.
- Feedback on design decisions. Engineers see the cost consequences of architecture choices while the context is fresh.
Backend and platform engineers should run it, because they are the people who can safely change the resources. Assign a named owner who rotates each month. Rotation spreads system knowledge across the team and stops the review from becoming one person's chore that quietly lapses.
Hold it in a fixed monthly slot so it survives busy periods. Also run an extra review after major launches, migrations or traffic changes, which are the moments when duplicate environments and forgotten resources usually accumulate.
A finance-driven finops audit usually reports spend by account or billing category. Engineers rarely act on it, because it says what was spent but not which resource to change or who owns it.
How does the monthly audit work from start to finish?
Pick one owner per month, usually rotating among backend and platform engineers, and give them a fixed time box such as half a day. The rotation spreads knowledge of the bill across the team. The time box keeps the review from turning into an open-ended cleanup project.
The routine runs as one loop:
billing export -> group by tag / service / account -> rank deltas vs. last month -> checklist passes -> findings log -> tickets + automation -> (next month's export)
Start with deltas, not totals
Pull the billing export for the closed month and the one before it. Group spend three ways: by service, by account or project, and by owner tag. Then rank each group by absolute change. A service that has cost the same for a year is rarely the best use of a limited review window. A line that grew noticeably in one month usually points to a specific deploy, migration or forgotten experiment that someone still remembers.
Look at untagged spend early. If it is large or growing, every other number is less reliable, because you cannot tell which team caused the change.
Work the checklist, then record
After the big deltas are explained, work through the checklist categories below in a fixed order. A fixed order lets you compare one month's review with the next. Log each finding with the resource, owner, estimated saving and a proposed action. Open a ticket in the owning team's queue rather than fixing it yourself. If the same finding appears for a second month, automate it with a policy, a scheduled cleanup or an alert, so the next review starts from a cleaner baseline.
Owner: one rotating engineer per month Time box: fixed, e.g. half a day
+------------------------+ +--------------------------------+
| Billing export | | Group spend |
| closed month + prior |----->| by service |
+------------------------+ | by account / project |
^ | by owner tag (incl. untagged) |
| next month +--------------------------------+
| v
| +--------------------------------+
| | Rank by absolute delta vs. |
| | last month; start with top |
| | deltas and untagged spend |
| +--------------------------------+
| v
| +--------------------------------+
| | Checklist passes (fixed order) |
| +--------------------------------+
| v
| +--------------------------------+
| | Findings log: resource, owner, |
| | est. saving, proposed action |
| +--------------------------------+
| v
+------------------------+ +--------------------------------+
| Automation (policy, |<-----| Tickets in owning team's queue |
| cleanup, alert) when a | +--------------------------------+
| finding repeats |
+------------------------+
The monthly audit loop: each review moves from the billing export through grouping, delta ranking, checklist passes and a findings log to tickets, and automation for repeated findings sets up a cleaner baseline for the next month.
How do you enforce ownership tags so cost can be attributed?
Attribution depends on every resource carrying three keys: owner (a team, not a person, so it survives reorgs), service, and environment. Without them, the cost report lists line items that nobody claims, and those items are rarely acted on.
Set defaults in infrastructure-as-code
Put the tags where engineers don't have to remember them. Most IaC tools let you declare tags once at the provider or module level so every resource inherits them. A shared base module can set owner and service from module inputs and environment from the workspace or stack name. Individual resources can then add keys but never omit the required ones. Defaults matter more than documentation because people copy existing code.
Validate in the pipeline
Add a policy check to the plan stage. The rule is simple: for every resource that supports tags, fail or warn if any required key is missing or empty, or if environment is not one of an allowed set such as dev, staging and prod. In the monthly review, treat anything created outside the pipeline, such as console clicks or scripts, as an untagged finding that goes to whoever owns the account.
Roll out in audit mode first
Hard enforcement on day one blocks deploys, often during an incident, for resources that predate the policy. Run the check in warn-only mode for one or two review cycles, report the untagged count per team, and let teams backfill. Switch to blocking only once that count is near zero. Keep a documented, time-limited exception path so an urgent fix can still ship.
# Plan-stage tag check. Assumes the pipeline exports planned resources as JSON:
# [{"address": "db.orders", "tags": {...}}, ...]
import json, os, sys
REQUIRED = ("owner", "service", "environment")
ALLOWED_ENVS = {"dev", "staging", "prod"}
# Defaults a shared base module would merge into every resource.
# Resources may add keys but cannot drop these.
DEFAULT_TAGS = {"owner": "team-payments", "service": "orders-api",
"environment": os.environ.get("STACK_ENV", "")}
# Start in audit mode. Set ENFORCE_TAGS=1 once untagged counts are near zero.
ENFORCE = os.environ.get("ENFORCE_TAGS") == "1"
def problems(tags):
merged = {**DEFAULT_TAGS, **(tags or {})}
issues = [f"missing {k}" for k in REQUIRED if not merged.get(k, "").strip()]
env = merged.get("environment")
if env and env not in ALLOWED_ENVS:
issues.append(f"environment '{env}' not in {sorted(ALLOWED_ENVS)}")
return issues
def main(path):
with open(path) as f:
resources = json.load(f)
findings = [(r["address"], p) for r in resources if (p := problems(r.get("tags")))]
for address, issues in findings:
print(f"{'ERROR' if ENFORCE else 'WARN'} {address}: {'; '.join(issues)}")
print(f"{len(findings)} of {len(resources)} resources fail the tag policy")
# In audit mode, report without blocking the deploy.
return 1 if ENFORCE and findings else 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1]))
A provider-neutral plan-stage check that merges default tags, flags missing or invalid owner, service and environment keys, and only blocks deploys once enforcement is switched on.
Cloud cost review checklist: idle resources, unused volumes, networking and logs
Work through the checklist one category at a time. Treat every finding as a question for the owning team rather than a deletion order.
| Category | What to look for | Signal / metric | Safe first action |
|---|---|---|---|
| Idle compute | Instances, node pools, managed databases | Low CPU, memory and network sustained across the review window | Confirm with the owner, then downsize one step |
| Off-hours environments | Dev/test and load-test stacks | Running nights and weekends with no traffic | Add a schedule that stops them |
| Storage | Unattached volumes, orphaned or expired snapshots, unused images, buckets without lifecycle rules | Status "available", snapshot age past retention, no instance references | Snapshot, tag for deletion, remove after a grace period |
| Networking | Unattached static IPs, load balancers with no healthy targets, NAT data processing, cross-zone/region traffic | Zero healthy targets, high NAT bytes processed, inter-zone transfer line items | Release or delete; trace the top NAT and transfer sources |
| Observability | Log ingestion, retention, high-cardinality metrics, debug logs in production | Ingested volume per service, unique series count, log level | Lower the log level, shorten retention, drop unused labels |
Check idle compute against all three signals together. A box with low CPU can still be memory-bound or serving latency-sensitive traffic.
Unattached volumes keep billing for provisioned capacity after their instance is gone. On AWS, aws ec2 describe-volumes --filters Name=status,Values=available lists them.
NAT and cross-zone charges usually come from architecture choices rather than waste. Common causes are services that call object storage through NAT instead of a private endpoint, or chatty services spread across zones. Fixing these takes a design change, not a cleanup.
Observability costs scale with volume and cardinality. A single debug flag left on in production can outspend the service it monitors.
#!/usr/bin/env bash
# List unattached EBS volumes and unassociated Elastic IPs for review.
# Read-only: nothing here deletes or modifies resources.
set -euo pipefail
REGION="${AWS_REGION:-us-east-1}"
echo "== Unattached volumes in ${REGION} (status=available) =="
# Volumes in 'available' state are not attached to any instance
# but still bill for provisioned capacity.
aws ec2 describe-volumes \
--region "$REGION" \
--filters Name=status,Values=available \
--query 'Volumes[].[VolumeId,Size,VolumeType,CreateTime,Tags[?Key==`owner`]|[0].Value]' \
--output table
echo "== Elastic IPs with no association in ${REGION} =="
# An Elastic IP without an AssociationId is allocated but not in use.
aws ec2 describe-addresses \
--region "$REGION" \
--query 'Addresses[?AssociationId==null].[PublicIp,AllocationId]' \
--output table
# Safe first action for a volume, once the owner confirms:
# take a snapshot, then tag it so deletion happens after a grace period.
# aws ec2 create-snapshot --region "$REGION" --volume-id vol-0123456789abcdef0 \
# --description "pre-deletion backup"
# aws ec2 create-tags --region "$REGION" --resources vol-0123456789abcdef0 \
# --tags Key=cost-review,Value=delete-after-2026-12-01
A read-only AWS CLI script that lists unattached EBS volumes and unassociated Elastic IPs in one region, with the snapshot-and-tag step left commented out so it runs only after the owner confirms.
How do you estimate the saving of a finding?
Every finding needs a number before it gets a ticket. Without one, the team tends to fix whatever is easiest to explain rather than what is worth the most. The basic formula for storage is:
Monthly saving = number of resources × average size (GB) × price per GB-month
Illustrative estimate (assumed numbers, not a benchmark): assume 40 unattached volumes averaging 200 GB at an assumed $0.08 per GB-month. That gives 40 × 200 × 0.08 = $640 per month. Now assume the cleanup takes 6 engineer hours, covering owner confirmation, snapshots and deletion, at an assumed loaded cost of $100 per hour. That is $600 of one-off effort, so the work pays for itself in about one month.
Every input above is an assumption. Replace each one with your provider's actual pricing, your inventory counts and your team's real hourly cost.
Apply the same method to each finding, then rank by payback period:
| Finding (assumed) | Monthly saving | Engineer hours | Payback (at $100/h) |
|---|---|---|---|
| Shorter log retention | $300 | 2 | < 1 month |
| Unattached volumes | $640 | 6 | ~1 month |
| Orphaned snapshots | $40 | 4 | 10 months |
| Cross-zone traffic redesign | $400 | 80 | 20 months |
Stop working down the list once payback stretches past what you would accept for any other engineering investment. Engineer time is a development cost. Hours spent recovering $40 a month are hours not spent on the product. The redesign may still be worth doing, but it belongs on the roadmap, not in the monthly cleanup.
When should you avoid deleting or right-sizing a resource?
Some findings look like waste but are actually insurance. Check these cases before you act.
- Volumes and snapshots kept for recovery, compliance or forensics. An unattached volume may be the only copy of a decommissioned database, or evidence under a legal hold. Tag it with an owner and a planned deletion date. Confirm that a verified backup exists, meaning one you have actually restored. Delete only after the grace period passes with no objection.
- Short observation windows. A week of low CPU can hide month-end batch jobs, quarterly reports, standby replicas that sit idle until a failover, and seasonal peaks. Review at least a full month of data, and include the last known peak.
- Deliberate headroom. Capacity sized for bursts or failover exists to absorb load. If you remove it, the cost shows up as latency, CPU throttling or out-of-memory kills.
- Logs and metrics. Shorter retention or dropped metric labels remove the data on-call needs for the next incident. Agree these changes with the on-call rotation first.
Right-sizing in steps
Compare requested resources with actual usage at a high percentile. Change one workload at a time, and decide how you will roll back before you deploy.
Illustrative estimate for container requests: a service requests 2 CPU and 4 GiB, but its 30-day p95 usage is 0.4 CPU and 1.5 GiB.
- Lower the requests to 0.75 CPU and 2 GiB. This keeps headroom above the observed peak.
- Keep the memory limit above the highest usage you have seen.
- Roll the change out to a canary first.
- Watch throttling, OOM kills and latency for a week.
- If any of them regress, revert the manifest.
# Canary Deployment for the right-sizing change. The stable Deployment keeps
# its old requests (2 CPU / 4Gi) until this canary has run cleanly for a week.
# Rollback: delete this canary, or restore the previous values from version control.
apiVersion: apps/v1
kind: Deployment
metadata:
name: orders-api-canary
labels:
app: orders-api
track: canary
annotations:
# Record why the values changed so reviewers can audit the decision.
cost-review/previous-requests: "cpu=2,memory=4Gi"
cost-review/basis: "30-day p95: cpu=0.4, memory=1.5Gi"
spec:
replicas: 1
selector:
matchLabels:
app: orders-api
track: canary
template:
metadata:
labels:
app: orders-api # shares the Service selector, so it receives a slice of traffic
track: canary
spec:
containers:
- name: orders-api
image: registry.example.com/orders-api:1.8.2
resources:
requests:
cpu: 750m # above p95 (0.4) to keep headroom for bursts
memory: 2Gi # above p95 (1.5Gi)
limits:
# Stays above the highest usage seen (assumed 2.6Gi), so peaks
# do not end in an OOM kill. No CPU limit is set here to avoid
# adding throttling while the new requests are being validated.
memory: 3Gi
A Kubernetes canary Deployment that lowers CPU and memory requests from the illustrative estimate, keeps the memory limit above the highest observed usage, and records the previous values in annotations so the change can be rolled back.
What are the alternatives to cutting usage: commitments, spot capacity and automation?
Cutting usage is not the only lever. Once the baseline is clean, three other approaches lower the price you pay or stop waste from coming back.
Commitment-based discounts trade flexibility for a lower rate on steady usage. Before buying more, check how much of your existing commitments you actually use. An unused commitment is waste you have already paid for. Commit only to the floor of usage that has held for months, not to the current peak, because a later migration or right-sizing can strand the commitment.
Spot or interruptible capacity is cheap because the provider can reclaim it at short notice. Use it only for stateless services behind a load balancer, or for batch jobs that checkpoint and retry. Never use it for databases or single-instance services.
Automation stops known waste from coming back:
- Scheduled scripts that stop non-production environments overnight.
- Policy-as-code that rejects untagged resources.
- Budget alerts that flag spikes between reviews.
| Approach | Savings mechanism | Risk | Effort | Best fit |
|---|---|---|---|---|
| Commitments | Lower unit rate | Stranded spend | Low once sized | Stable baseline load |
| Spot capacity | Deep discount, reclaimable | Interruptions | Medium (retry logic) | Stateless, batch |
| Automation | Prevents recurring waste | Overly broad policies | Upfront build | Repeatable patterns |
| Manual monthly review | Finds and removes waste | Missed items | High, recurring | New or unusual findings |
| Finance-only report | Visibility only | No action taken | Low | Budget tracking |
Record every finding with an owner, a labeled estimate and a ticket. Turn each repeat finding into an automated check. The next review then starts from exceptions rather than a full sweep.
How OneEnv can help
Disclosure: OneEnv is the product behind this blog.
OneEnv (oneenv.io) is a workspace-based governance platform for the things services share — environment variables, database structure, API routes and validation rules. A change to a shared value is staged on a branch, reviewed once, and then every affected service explicitly approves or rejects it before it goes live, so you can see who a change touches before it ships instead of finding out in production.
Applied to cloud cost review checklist, this is where it helps:
Saves time
- Every service that inherits a shared value is listed in one place, so nobody searches repos and chats to find out who is affected.
- One review per branch replaces coordinating each team separately; each service still keeps its own approve/reject.
- Changing a route's URL or method automatically notifies the services that consume it — no hunting through repos for callers.
Saves cost
- Fewer production incidents and rollbacks caused by a shared value, route or column changing under a consumer unannounced.
- Less duplicated configuration to maintain: one shared definition inherited by many services.
- Consumers learn about a breaking change at review time rather than from production errors.
- OneEnv has a free plan (1 workspace, unlimited services and members, full governance), so trying it costs nothing.
These are qualitative benefits, not measured results — how much you save depends on how many services share the value.
Want to try it? Start at oneenv.io.