# Cost Optimization

> Strategies and practices for optimizing cloud spending while maintaining performance and reliability

- Skill: `ffsshhttiikk/cost-optimization` (Agent Skill)
- Install (CLI): `npx skillmds@latest add ffsshhttiikk/cost-optimization`
- Raw SKILL.md: https://api.skillmd.com/api/skills/ffsshhttiikk/cost-optimization/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: DevOps & Infra
- Author: ffsshhttiikk (https://skillmd.com/u/ffsshhttiikk)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/ffsshhttiikk/cost-optimization

---


# Cloud Cost Optimization

## What I Do

I help organizations maximize the value from their cloud investments by eliminating waste, optimizing resource utilization, leveraging pricing models, and implementing financial governance. I enable cost-effective cloud operations without sacrificing performance.

## When to Use Me

- Reducing monthly cloud spend
- Planning cloud budget and forecasting
- Identifying unused or underutilized resources
- Implementing FinOps practices
- Optimizing enterprise-scale cloud costs
- Managing multi-cloud spending
- Setting up cost allocation and chargebacks

## Core Concepts

- **Right-sizing**: Matching resources to actual workload needs
- **Reserved Instances/Savings Plans**: Committed discounts (30-70% off)
- **Spot Instances**: Excess capacity at up to 90% discount
- **Cost Allocation Tags**: Tracking spending by team/project
- **Budgets and Alerts**: Proactive monitoring of spending
- **Cost Explorer/Analysis**: Understanding spending patterns
- **疏云: Eliminating idle resources**
- **Lifecycle Policies**: Automatic transition to cheaper storage tiers
- **Resource Scheduling**: Turning off non-production resources
- **FinOps Culture**: Cross-team accountability for cloud costs

## Code Examples

**AWS Cost Explorer Analysis (Python/Boto3):**
```python
import boto3
from datetime import datetime, timedelta

ce = boto3.client('ce')

# Get cost and usage by service
response = ce.get_cost_and_usage(
    TimePeriod={
        'Start': '2024-01-01',
        'End': '2024-02-01'
    },
    Granularity='MONTHLY',
    Metrics=['UnblendedCost', 'UsageQuantity'],
    GroupBy=[
        {'Type': 'DIMENSION', 'Key': 'SERVICE'},
        {'Type': 'DIMENSION', 'Key': 'USAGE_TYPE'}
    ]
)

# Identify underutilized instances
def find_underutilized_instances():
    ce = boto3.client('ce')
    rightsizing = ce.get_right_sizing(
        TimePeriod={
            'Start': '2024-01-01',
            'End': '2024-02-01'
        },
        Filter={
            'Dimensions': {
                'Key': 'RECORD_TYPE',
                'Values': ['EC2', 'RDS']
            }
        }
    )
    
    for item in rightsizing['RightSizeingResults']:
        if item['TotalActualHours'] > item['TotalRecommendedHours'] * 1.5:
            print(f"Instance: {item['ResourceId']}")
            print(f"Savings: ${item['EstimatedMonthlySavings']}")
```

**Terraform Cost Estimator:**
```hcl
# terraform/modules/cost-estimator/main.tf
variable "instances" {
  type = list(object({
    name          = string
    instance_type = string
    count         = number
    hours_per_day = number
  }))
}

locals {
  # AWS pricing (example rates)
  on_demand_rates = {
    "t3.micro"    = 0.0104
    "t3.small"    = 0.0208
    "t3.medium"   = 0.0416
    "t3.large"    = 0.0832
    "m5.large"    = 0.0960
    "m5.xlarge"   = 0.1920
  }
  
  reserved_rates = {
    "t3.micro"    = 0.0058
    "t3.small"    = 0.0117
    "t3.medium"   = 0.0233
  }
  
  monthly_cost_on_demand = sum([
    for inst in var.instances :
    inst.count * inst.hours_per_day * 30 *
    local.on_demand_rates[inst.instance_type]
  ])
  
  monthly_cost_reserved = sum([
    for inst in var.instances :
    inst.count * 720 *
    local.reserved_rates[inst.instance_type]
  ])
}

output "monthly_cost_on_demand" {
  value = local.monthly_cost_on_demand
}

output "monthly_cost_reserved" {
  value = local.monthly_cost_reserved
}

output "potential_savings" {
  value = local.monthly_cost_on_demand - local.monthly_cost_reserved
}
```

**Kubernetes Resource Optimization (YAML):**
```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: cost-optimization-config
  namespace: kube-system
data:
  config.yaml: |
    # Resource requests/limits recommendations
    recommendations:
      frontend:
        current:
          requests:
            cpu: "500m"
            memory: "512Mi"
          limits:
            cpu: "1000m"
            memory: "1Gi"
        recommended:
          requests:
            cpu: "250m"
            memory: "256Mi"
          limits:
            cpu: "500m"
            memory: "512Mi"
        estimated_savings: 40
    
    # Auto-scaling configuration
    autoscaling:
      min_replicas: 2
      max_replicas: 10
      target_cpu_utilization: 70
      target_memory_utilization: 80
    
    # Pod disruption budget
    pdb:
      min_available: 1
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: frontend-hpa
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: frontend
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
      - type: Percent
        value: 10
        periodSeconds: 60
    scaleUp:
      stabilizationWindowSeconds: 0
      policies:
      - type: Percent
        value: 100
        periodSeconds: 15
```

## Best Practices

1. **Implement FinOps framework** - Cross-team ownership and accountability
2. **Tag all resources properly** - Enable accurate cost attribution
3. **Use reserved instances for steady state** - Commit to predictable usage
4. **Right-size continuously** - Monitor and adjust regularly
5. **Schedule non-production resources** - Auto-stop dev/test environments
6. **Use spot for fault-tolerant workloads** - Batch jobs, stateless services
7. **Implement budgets and alerts** - Proactive monitoring
8. **Review unused resources weekly** - Orphaned volumes, snapshots, IPs
9. **Use lifecycle policies** - S3 Intelligent-Tiering, Glacier for cold data
10. **Conduct regular cost reviews** - Monthly optimization meetings