AWS Cloud Cost Optimization 2026 — Cut Your Bill by 60% Without Killing Performance

# Enable Cost Explorer (free)
# AWS Console > Billing > Cost Explorer > Enable
 
# Get monthly costs by service via CLI
aws ce get-cost-and-usage \
  --time-period Start=2026-03-01,End=2026-03-31 \
  --granularity MONTHLY \
  --metrics "UnblendedCost" \
  --group-by Type=DIMENSION,Key=SERVICE \
  --query 'ResultsByTime[0].Groups[*].{Service:Keys[0],Cost:Metrics.UnblendedCost.Amount}' \
  --output table
 
# Get costs by environment tag
aws ce get-cost-and-usage \
  --time-period Start=2026-03-01,End=2026-03-31 \
  --granularity MONTHLY \
  --metrics "UnblendedCost" \
  --group-by Type=TAG,Key=Environment

// cost-reporter.ts
import { CostExplorerClient, GetCostAndUsageCommand } from '@aws-sdk/client-cost-explorer'
 
const client = new CostExplorerClient({ region: 'us-east-1' })
 
async function getWeeklyCosts(): Promise<Record<string, number>> {
  const end   = new Date()
  const start = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
 
  const { ResultsByTime } = await client.send(new GetCostAndUsageCommand({
    TimePeriod: {
      Start: start.toISOString().split('T')[0],
      End:   end.toISOString().split('T')[0],
    },
    Granularity: 'DAILY',
    Metrics: ['UnblendedCost'],
    GroupBy: [{ Type: 'DIMENSION', Key: 'SERVICE' }],
  }))
 
  const totals: Record<string, number> = {}
  ResultsByTime?.forEach(day => {
    day.Groups?.forEach(group => {
      const service = group.Keys?.[0] ?? 'Unknown'
      const cost = parseFloat(group.Metrics?.UnblendedCost?.Amount ?? '0')
      totals[service] = (totals[service] ?? 0) + cost
    })
  })
 
  return totals
}

# Get Savings Plans recommendations
aws ce get-savings-plans-purchase-recommendation \
  --savings-plans-type COMPUTE_SP \
  --term-in-years ONE_YEAR \
  --payment-option NO_UPFRONT \
  --lookback-period-in-days THIRTY_DAYS
 
# Check current Savings Plans utilization
aws ce get-savings-plans-utilization \
  --time-period Start=2026-03-01,End=2026-03-31

// spot-handler.ts — Handle 2-minute Spot interruption notice
import http from 'http'
 
async function checkSpotInterruption(): Promise<boolean> {
  return new Promise((resolve) => {
    const req = http.get(
      'http://169.254.169.254/latest/meta-data/spot/termination-time',
      (res) => resolve(res.statusCode === 200)
    )
    req.on('error', () => resolve(false))
    req.setTimeout(1000, () => { req.destroy(); resolve(false) })
  })
}
 
async function gracefulShutdown() {
  console.log('Spot interruption — draining queue and shutting down')
  isShuttingDown = true
 
  await drainCurrentWork()
  await deregisterFromLoadBalancer()
  await db.end()
 
  process.exit(0)
}
 
setInterval(async () => {
  if (await checkSpotInterruption()) {
    await gracefulShutdown()
  }
}, 5000)

# CloudFormation ASG with Spot + On-Demand mix
MixedInstancesPolicy:
  InstancesDistribution:
    OnDemandBaseCapacity: 1
    OnDemandPercentageAboveBaseCapacity: 20
    SpotAllocationStrategy: capacity-optimized
  LaunchTemplate:
    Overrides:
      - InstanceType: t3.large
      - InstanceType: t3a.large
      - InstanceType: m5.large

# Enable Compute Optimizer (free)
aws compute-optimizer update-enrollment-status --status Active
 
# Get right-sizing recommendations
aws compute-optimizer get-ec2-instance-recommendations \
  --query 'instanceRecommendations[*].{
    Instance:instanceArn,
    CurrentType:currentInstanceType,
    Recommended:recommendationOptions[0].instanceType,
    MonthlySavings:recommendationOptions[0].estimatedMonthlySavings.value
  }' \
  --output table
 
# Find instances with less than 5% average CPU over 14 days
aws cloudwatch get-metric-statistics \
  --namespace AWS/EC2 \
  --metric-name CPUUtilization \
  --dimensions Name=InstanceId,Value=i-xxx \
  --start-time 2026-03-01T00:00:00Z \
  --end-time 2026-03-26T00:00:00Z \
  --period 86400 \
  --statistics Average

# Enable S3 Intelligent-Tiering for unpredictable access patterns
aws s3api put-bucket-intelligent-tiering-configuration \
  --bucket my-bucket \
  --id EntireBucket \
  --intelligent-tiering-configuration '{
    "Id": "EntireBucket",
    "Status": "Enabled",
    "Tierings": [
      {"Days": 90, "AccessTier": "ARCHIVE_ACCESS"},
      {"Days": 180, "AccessTier": "DEEP_ARCHIVE_ACCESS"}
    ]
  }'

{
  "Rules": [{
    "Status": "Enabled",
    "Transitions": [
      { "Days": 30,  "StorageClass": "STANDARD_IA" },
      { "Days": 90,  "StorageClass": "GLACIER_IR" },
      { "Days": 365, "StorageClass": "DEEP_ARCHIVE" }
    ],
    "NoncurrentVersionExpiration": { "NoncurrentDays": 90 },
    "Expiration": { "Days": 2555 }
  }]
}

# Find and list unattached EBS volumes
aws ec2 describe-volumes \
  --filters Name=status,Values=available \
  --query 'Volumes[*].{ID:VolumeId,Size:Size,Type:VolumeType}' \
  --output table
 
# Find unused Elastic IPs
aws ec2 describe-addresses \
  --query 'Addresses[?AssociationId==`null`].{IP:PublicIp,ID:AllocationId}' \
  --output table
 
# Stop dev RDS instances (saves 100% while stopped — max 7 days)
aws rds stop-db-instance --db-instance-identifier dev-db

# Create a budget alert at 80% of monthly target
aws budgets create-budget \
  --account-id 123456789012 \
  --budget '{
    "BudgetName": "MonthlyBudget",
    "BudgetLimit": {"Amount": "500", "Unit": "USD"},
    "TimeUnit": "MONTHLY",
    "BudgetType": "COST"
  }' \
  --notifications-with-subscribers '[{
    "Notification": {
      "NotificationType": "ACTUAL",
      "ComparisonOperator": "GREATER_THAN",
      "Threshold": 80
    },
    "Subscribers": [
      {"SubscriptionType": "EMAIL", "Address": "devops@company.com"}
    ]
  }]'