This monthly cloud cost optimization runbook gives DevOps, platform, and finance teams a repeatable way to review AWS, Azure, and GCP spending, estimate savings, and approve changes without putting production reliability at risk.
Overview
Cloud cost reviews work best as an operating process rather than a one-time cleanup exercise. A useful review connects spending to an owner, a workload, a business purpose, and a measurable performance requirement. The goal is not to reduce every bill as far as possible. It is to remove waste, match capacity to demand, and make trade-offs visible before they affect availability, delivery speed, or security.
Use this runbook once per month for normal operations and more frequently during rapid growth, major migrations, or unusual spend. Review the current period against the previous comparable period, then compare actual usage with the assumptions behind your architecture and capacity plans.
Keep a record of each recommendation in a shared worksheet with these columns:
- Cloud provider, account, subscription, project, or environment
- Service, resource, workload, and technical owner
- Current monthly cost and usage measure
- Proposed action and estimated monthly effect
- Reliability, security, performance, and operational risks
- Approval owner, due date, and implementation status
- Actual result after the change
That final field matters. A recommendation is only useful when the team verifies whether the expected saving occurred and whether service behavior remained within acceptable limits. Pair cost changes with existing operational controls, such as an SRE incident response runbook and defined service-level objectives.
How to estimate
Start with a simple baseline. For each account, subscription, or project, record the current period cost, the previous comparable period cost, and the main usage drivers. A basic variance calculation is:
Cost variance = current cost − previous cost
Percentage variance = (current cost − previous cost) ÷ previous cost × 100
Do not treat a higher bill as waste automatically. A growing workload may be producing more requests, storing more data, or running more build jobs. Add a unit-cost view where possible, such as cost per request, cost per active customer, cost per deployment, or cost per gigabyte processed:
Unit cost = total service cost ÷ relevant workload unit
Next, estimate the effect of a proposed action. For a resource that can be removed, the gross monthly saving is the avoidable monthly cost. For rightsizing, compare the current monthly cost with the estimated cost of the replacement configuration. For storage movement, include the expected storage charge, retrieval or access charges where applicable, and any migration cost.
Use this general estimate:
Estimated net saving = current monthly cost − replacement monthly cost − one-time change cost allocated to the review period
For commitments or discounts, avoid presenting the headline reduction as guaranteed savings. Calculate the break-even point instead:
Break-even period = commitment or migration cost ÷ expected monthly saving
Then test the assumption against future demand. A commitment that looks attractive at the current run rate may be unsuitable if the workload is being replaced, consolidated, or moved to another provider. Pricing calculators and billing exports can help with estimates, but the final review should use the organization’s actual usage and billing data.
Classify every recommendation as one of four actions:
- Remove: delete or decommission a resource that is no longer needed.
- Resize: change capacity to match observed demand and performance requirements.
- Schedule: stop nonproduction resources outside working or test hours.
- Optimize: change storage, architecture, data transfer, licensing, or purchasing behavior.
Inputs and assumptions
Ownership and allocation
Begin by checking whether every significant cost has an owner. Standardize tags, labels, or metadata for application, team, environment, service, cost center, and lifecycle. The exact mechanism differs between AWS, Azure, and GCP, but the review question is the same: can a person explain why the resource exists and what would happen if it changed?
Separate production, staging, development, shared platform, security, and data workloads. Shared services need an allocation rule, even if it is approximate. For example, a shared cluster might allocate cost by namespace, requested capacity, actual consumption, or an agreed percentage. Record the method so monthly comparisons remain consistent.
Usage and capacity
For compute, collect utilization over a representative period rather than relying on one quiet day. Review CPU, memory, storage, network, queue depth, request rate, and saturation indicators that are relevant to the workload. Low average utilization does not prove that a resource is oversized if it must handle short peaks or maintain redundancy.
For Kubernetes and other platforms, include worker capacity, persistent volumes, load balancers, idle namespaces, observability data, and resources reserved for autoscaling. A deployment change should be evaluated alongside reliability and rollback requirements; the Kubernetes deployment strategy guide can help frame those operational trade-offs.
Storage and data transfer
Review storage by age, access frequency, replication, backup retention, and recovery requirements. Identify unattached volumes, old snapshots, duplicate artifacts, abandoned test data, and logs with no documented retention need. Before deleting anything, confirm ownership and recovery obligations.
Data transfer deserves its own line in the worksheet. Look for traffic crossing regions, zones, providers, or managed services. A change that reduces compute cost can still increase total cost if it moves more data. Validate the proposed design with traffic patterns and failure scenarios rather than optimizing a single service line.
Commitments and automation
Review discounts, reservations, savings plans, licenses, and other commitments by actual utilization and remaining term. Treat a commitment as a capacity decision, not merely a discount. Document the covered workload, expected baseline, flexibility, and owner.
Automate low-risk controls where possible, such as notifications for missing ownership metadata, budgets, anomaly alerts, and scheduled shutdowns for approved nonproduction environments. Keep production changes behind an approval process. Infrastructure as code can make approved changes auditable; the Terraform and Kubernetes platform onboarding playbook provides a useful structure for that approach.
Worked examples
Example 1: removing idle nonproduction resources
Assume a team finds development resources with an illustrative monthly cost of $420. The owner confirms they are not required overnight and can be recreated from code. A scheduled shutdown is expected to reduce active hours by 40 percent, while the remaining hours preserve the normal testing workflow.
Estimated gross saving = $420 × 40% = $168 per month
Before approval, the team should verify that scheduled stopping does not interrupt integration tests, destroy local state, or delay deployments. Record the schedule, exception process, and rollback method. After implementation, compare the next complete billing period with the baseline and check build and test metrics.
Example 2: rightsizing a production workload
Suppose a production service currently costs an illustrative $900 per month for its compute layer. A capacity review shows that a smaller configuration is expected to cost $650 per month. Load testing indicates that the smaller option meets the normal target, but the team still needs to validate peak behavior and failover capacity.
Estimated monthly saving = $900 − $650 = $250
The approval should include the test evidence, autoscaling limits, alert thresholds, and rollback configuration. If the service has a strict availability target, evaluate whether reducing each instance independently or changing the fleet size is safer. Cost optimization should not remove the redundancy required by the service’s reliability objective. For a broader reliability context, see the guide to SRE error budgets and SLOs.
Example 3: storage lifecycle change
Imagine an archive contains 12 TB of data, with only a small portion accessed regularly. A lifecycle policy could move older objects to a lower-cost tier. The estimate must include the lower storage charge, expected retrieval activity, request charges, transition timing, retention requirements, and any effect on recovery procedures.
Do not calculate the saving from storage rates alone. Use a conservative access assumption, test retrieval with representative files, and confirm that the application can tolerate the resulting access behavior. The recommendation should show both the expected monthly reduction and the estimated cost of an unusual retrieval event.
When to recalculate
Run the complete review monthly, but recalculate specific recommendations whenever an input changes. Important triggers include a provider pricing or billing-model change, a new region or service, a workload migration, a major traffic increase, a new data-retention policy, a material architecture change, or the renewal of a commitment.
Revisit estimates after incidents and performance regressions as well. A cost action that contributed to saturation, slower deployments, or recovery difficulty should be paused, reversed, or redesigned. Link the cost worksheet to the incident review when appropriate; the objective is to learn which assumptions were incomplete, not to assign blame.
At the end of each monthly meeting, select a small set of approved actions and assign owners. For each action, define:
- The exact resource or billing category in scope
- The expected monthly and one-time financial effect
- The performance and reliability checks required before and after change
- The implementation date and rollback condition
- The date when actual savings will be verified
Refresh the worksheet when provider terminology, console locations, commitment options, or pricing inputs change. Keep the prior month’s assumptions instead of overwriting them, so the team can explain variance and improve its forecasts. Used this way, a cloud cost optimization checklist becomes part of platform engineering: a practical feedback loop between infrastructure decisions, workload behavior, and responsible spending.