← All articles

Advanced Cloud Cost Optimization Strategy Teams Overlook

Why most cost‑optimization strategies fall short

Most teams focus on the obvious levers – rightsizing instances, buying Reserved Instances, or deleting unattached volumes. Those actions are valuable, but they treat waste as a one‑time problem. In reality, waste is a continuous process: resources spin up for a sprint, for a nightly batch, or for a temporary experiment and then sit idle for days or weeks. If you only look at static inventory, you miss the dynamic, time‑based cost that accrues during predictable low‑usage periods.

A mature cost‑optimization strategy must therefore address two questions:

1. When does a resource become idle?
2. What automated action should be taken to eliminate the waste without breaking the workflow?

Answering those questions with a repeatable, code‑driven pipeline turns cost control from a manual cleanup task into a self‑healing part of your infrastructure.

Building an automated idle‑resource reclamation pipeline

The core idea is simple: tag resources with an intent, monitor their utilization, and trigger a Lambda function that either stops, terminates, or downsizes the resource during a predefined idle window. The pipeline uses only AWS native services, so there is no extra licensing cost.

1. Tag resources for lifecycle intent

Start by establishing a tagging convention that signals whether a resource is eligible for automated reclamation. For example:

• Lifecycle=Ephemeral
• ReclaimAfter=7d (the maximum idle time before action)
• Owner=team‑infra

Apply the tags at creation time. For EC2 instances launched by CloudFormation, add the tags in the template:

Resources:
  MyInstance:
    Type: AWS::EC2::Instance
    Properties:
      Tags:
        - Key: Lifecycle
          Value: Ephemeral
        - Key: ReclaimAfter
          Value: 7d

For resources created manually, use the console or CLI:

aws ec2 create-tags --resources i-0123456789abcdef0 \
  --tags Key=Lifecycle,Value=Ephemeral Key=ReclaimAfter,Value=7d

Consistent tagging gives the pipeline a reliable source of truth.

2. Capture usage patterns with CloudWatch Metrics

AWS already publishes utilization metrics for most services. For EC2, the CPUUtilization metric is a good proxy for activity. For RDS, use DatabaseConnections. For Elastic Load Balancers, monitor RequestCount.

Create a CloudWatch metric alarm that fires when utilization stays below a threshold for a continuous period. Example for an EC2 instance:

aws cloudwatch put-metric-alarm \
  --alarm-name "LowCPU-i-0123456789abcdef0" \
  --metric-name CPUUtilization \
  --namespace AWS/EC2 \
  --statistic Average \
  --period 300 \
  --evaluation-periods 12 \
  --threshold 5 \
  --comparison-operator LessThanOrEqualToThreshold \
  --dimensions Name=InstanceId,Value=i-0123456789abcdef0 \
  --actions-enabled false

The alarm is disabled (--actions-enabled false) because we only need the metric data; the actual decision will be made by a Lambda function that reads the recent datapoints.

3. Create EventBridge rules for low‑usage windows

EventBridge (formerly CloudWatch Events) can invoke Lambda on a schedule or when a specific pattern occurs. We will use a scheduled rule that runs every day at 02:00 UTC – a time when most development activity has paused.

aws events put-rule \
  --name "DailyIdleReclaim" \
  --schedule-expression "cron(0 2 * * ? *)"

Attach the Lambda target:

aws events put-targets \
  --rule DailyIdleReclaim \
  --targets Id=1,Arn=arn:aws:lambda:us-east-1:123456789012:function:IdleReclaimer

The rule ensures the reclamation logic runs consistently, regardless of whether an alarm fires.

4. Deploy Lambda function to stop, terminate, or resize

The Lambda function is the decision engine. It performs the following steps:

1. Discover all resources with Lifecycle=Ephemeral using the Resource Groups Tagging API.
2. Fetch the last 24 hours of utilization metrics for each resource.
3. Determine if the average metric is below the defined threshold and the resource has been tagged with ReclaimAfter that has elapsed.
4. Execute the appropriate action: - For EC2: stop-instances or terminate-instances based on a secondary tag ReclaimAction. - For RDS: stop-db-instance (available for Aurora Serverless v2) or delete-db-instance with SkipFinalSnapshot=true. - For EBS volumes: delete-volume if State=available.

Below is a minimal Python 3.9 Lambda snippet that stops idle EC2 instances:

import boto3, datetime

ec2 = boto3.client('ec2')
cloudwatch = boto3.client('cloudwatch')

def lambda_handler(event, context):
    # 1. Find tagged instances
    paginator = ec2.get_paginator('describe_instances')
    filters = [{"Name": "tag:Lifecycle", "Values": ["Ephemeral"]}]
    for page in paginator.paginate(Filters=filters):
        for reservation in page['Reservations']:
            for instance in reservation['Instances']:
                instance_id = instance['InstanceId']
                # 2. Get CPU metric
                resp = cloudwatch.get_metric_statistics(
                    Namespace='AWS/EC2',
                    MetricName='CPUUtilization',
                    Dimensions=[{'Name':'InstanceId','Value':instance_id}],
                    StartTime=datetime.datetime.utcnow() - datetime.timedelta(hours=24),
                    EndTime=datetime.datetime.utcnow(),
                    Period=300,
                    Statistics=['Average']
                )
                datapoints = resp['Datapoints']
                if not datapoints:
                    continue
                avg_cpu = sum(p['Average'] for p in datapoints) / len(datapoints)
                # 3. Check threshold (5%)
                if avg_cpu <= 5:
                    # 4. Stop instance
                    ec2.stop_instances(InstanceIds=[instance_id])
                    print(f"Stopped idle instance {instance_id} (avg CPU {avg_cpu:.1f}%)")

Deploy the function with the required IAM policy (ec2:StopInstances, cloudwatch:GetMetricStatistics, resourcegroupstaggingapi:GetResources).

5. Verify and report with CloudBudgetMaster’s free AWS waste finder

After the pipeline runs for a week, use the free AWS waste finder to see the dollar impact of reclaimed resources. The tool reads your account’s cost and usage reports, matches them against the tags you defined, and surfaces a list of resources that were stopped or terminated, together with the estimated monthly savings.

Visit /tools/aws-waste-finder to generate the report, then create a free account at /register to store historical data and receive automated alerts when new idle resources appear.

Integrating Compute Optimizer for predictive rightsizing

AWS Compute Optimizer provides machine‑learning recommendations for EC2, Auto Scaling groups, EBS volumes, and Lambda functions. While the idle‑resource pipeline handles time‑based waste, Compute Optimizer tackles capacity‑based waste.

1. Enable Compute Optimizer in the console (Settings → Compute Optimizer → Enable). You can also enable via CLI:

aws compute-optimizer enable-recommendation-export --s3-bucket my‑optimizer‑exports

2. Export recommendations daily to an S3 bucket. The export includes a CSV with fields such as InstanceArn, CurrentInstanceType, RecommendedInstanceType, and EstimatedMonthlySavings.

3. Merge the export with the idle‑resource report. If a resource is both under‑utilized and flagged as Lifecycle=Ephemeral, you can safely downsize it instead of stopping it entirely.

4. Automate the merge using an AWS Glue job or a simple Lambda that reads the CSV, cross‑references the tag API, and calls modify-instance-attribute for the recommended type.

aws ec2 modify-instance-attribute --instance-id i-0123456789abcdef0 \
  --instance-type "{\"Value\": \"t3.micro\"}"

By coupling predictive rightsizing with the idle‑window pipeline, you capture both static over‑provisioning and dynamic idle periods.

Cost impact calculation and reporting

To turn reclaimed capacity into a business‑ready metric, follow these steps:

1. Enable Cost and Usage Reports (CUR) in the Billing console. Choose the Parquet format and deliver to an S3 bucket.
2. Create an Athena table that points to the CUR location:

CREATE EXTERNAL TABLE IF NOT EXISTS cur (
  identitylineitemid string,
  lineitemusagestartdate timestamp,
  lineitemusageenddate timestamp,
  lineitemresourceid string,
  lineitemusagetype string,
  lineitemunblendedcost double,
  lineitemoperation string,
  lineitemproductcode string,
  lineitemresourcegroup string
) ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe' 
STORED AS INPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat' 
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat' 
LOCATION 's3://my-cur-bucket/cur/';

3. Run a query that sums cost for resources that were stopped or terminated by the pipeline in the last month:

SELECT lineitemresourceid, SUM(lineitemunblendedcost) AS monthly_savings
FROM cur
WHERE lineitemoperation IN ('StopInstances', 'TerminateInstances')
  AND lineitemusagestartdate >= date_trunc('month', current_date - interval '1' month)
GROUP BY lineitemresourceid;

4. Export the result to CSV and attach it to your monthly FinOps review.

The combination of automated reclamation, Compute Optimizer rightsizing, and transparent reporting creates a repeatable strategy that continuously reduces waste without manual intervention.

Comparison of reclamation approaches

The table shows why an automated pipeline is the most efficient strategy for teams that already operate in AWS.

Frequently asked questions

How do I avoid accidentally stopping production workloads?

Add a second tag, such as Critical=true, and modify the Lambda filter to exclude any resource with that tag. You can also set the ReclaimAction tag to NotifyOnly so the function sends an SNS alert instead of taking action.

Can this pipeline work across multiple AWS accounts?

Yes. Use AWS Organizations and enable Resource Access Manager (RAM) to share the S3 bucket that stores CUR data. Deploy the same Lambda function in each member account, or run a central Lambda with cross‑account IAM roles that iterate over all accounts.

What is the cost of running the pipeline itself?

The Lambda execution time is typically under 1 second per resource, costing a few cents per month. EventBridge and CloudWatch have free tier limits that cover the daily schedule. Overall overhead is negligible compared to the savings.

Does the free AWS waste finder replace the need for a paid FinOps platform?

The waste finder gives you a snapshot of reclaimed resources and estimated savings. For continuous monitoring, alerting, and multi‑cloud visibility you would still benefit from a full‑featured platform, but the tool is sufficient for a proof‑of‑concept.

Key takeaways

• Tag resources with a clear lifecycle intent (Lifecycle=Ephemeral).
• Use CloudWatch metrics and EventBridge to detect prolonged low utilization.
• Deploy a Lambda function that automatically stops, terminates, or downsizes idle resources.
• Combine the pipeline with AWS Compute Optimizer for predictive rightsizing.
• Validate dollar impact with CloudBudgetMaster’s free AWS waste finder and store results in Cost and Usage Reports.
• The approach requires only native AWS services, keeping additional cost near zero.
• Automating reclamation turns cost optimization from a periodic task into a continuous strategy.

CloudBudgetMaster automates this workflow for AWS today. It scans your account with read‑only permissions, identifies idle and wasted resources, and reports the dollar impact. Support for GCP, Azure and Snowflake is coming soon.