<div id="readability-page-1" class="page"><div><img src="https://devstarsj.github.io/assets/https://images.unsplash.com/photo-1579621970563-ebec7560ff3e?w=1200&amp;q=80"><h2 id="the-cloud-bill-problem-is-an-engineering-problem">The Cloud Bill Problem Is an Engineering Problem</h2>Your CFO is looking at the cloud bill. It went up 40% this year. You shipped maybe 15% more features. Something isn’t adding up.This is the most common conversation in engineering leadership right now. And it’s not a procurement problem or a vendor negotiation problem — it’s an engineering problem.Cloud costs are a function of architecture decisions, resource allocation, code efficiency, and operational discipline. The teams cutting their bills by 30-50% without slowing down aren’t doing it through better contract negotiations. They’re doing it through better engineering.Here’s the playbook.<img src="https://images.unsplash.com/photo-1611974789855-9c2a0a7236a3?w=800&amp;q=80" alt="Financial charts and graphs on a laptop"> Photo by Maxim Hopman on Unsplash<hr><h2 id="the-finops-framework-culture-first">The FinOps Framework: Culture First</h2>FinOps isn’t a tool. It’s a practice — the intersection of Finance, Technology, and Business.The FinOps Foundation’s maturity model:<table><thead><tr><th>Phase</th><th>Characteristics</th></tr></thead><tbody><tr><td>Crawl</td><td>Cost visibility exists. Teams know what they spend.</td></tr><tr><td>Walk</td><td>Teams are accountable for costs. Optimization is happening.</td></tr><tr><td>Run</td><td>Cost efficiency is automated. Real-time optimization. AI-driven.</td></tr></tbody></table>Most companies in 2026 are stuck at “Crawl” → “Walk”. The companies at “Run” have 40-60% lower unit economics than their peers.The critical cultural shift: engineers own cost as a first-class metric, alongside latency, reliability, and security.<hr><h2 id="the-biggest-cost-drains-and-their-fixes">The Biggest Cost Drains (And Their Fixes)</h2><h3 id="1-overprovisioned-compute-typically-35-50-of-waste">1. Overprovisioned Compute (Typically 35-50% of Waste)</h3>The pattern: dev environment specs copy-pasted to production. 4-core, 16GB instances running at 5% CPU utilization.Quick win: Right-sizing<div><pre><code># AWS Compute Optimizer recommendations
aws compute-optimizer get-ec2-instance-recommendations \
 --account-ids $ACCOUNT_ID \
 --filters name=Finding,values=Overprovisioned

# Output typically shows: "Reduce from m5.xlarge to m5.large = -50% cost"
</code></pre></div>AWS Compute Optimizer, GCP Recommender, and Azure Advisor all surface these automatically. The issue isn’t finding them — it’s acting on them. Assign ownership, create a monthly right-sizing review.Kubernetes right-sizing with VPA:<div><pre><code>apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
 name: payment-service-vpa
spec:
 targetRef:
 apiVersion: apps/v1
 kind: Deployment
 name: payment-service
 updatePolicy:
 updateMode: "Auto" # Or "Recommendation" to review first
 resourcePolicy:
 containerPolicies:
 - containerName: payment-service
 minAllowed:
 cpu: 50m
 memory: 128Mi
 maxAllowed:
 cpu: 2
 memory: 2Gi
</code></pre></div>VPA automatically adjusts CPU/memory requests based on actual usage. Teams using VPA typically see 25-40% cost reduction in Kubernetes workloads.<h3 id="2-idle-and-orphaned-resources-typically-15-25-of-waste">2. Idle and Orphaned Resources (Typically 15-25% of Waste)</h3>Snapshots from last year’s testing. Load balancers pointing at deleted services. NAT gateways with no traffic. These accumulate silently.Detection script:<div><pre><code>import boto3

def find_orphaned_resources():
 ec2 = boto3.client('ec2')
 
 # Unattached EBS volumes
 volumes = ec2.describe_volumes(
 Filters=[{'Name': 'status', 'Values': ['available']}]
 )['Volumes']
 
 for vol in volumes:
 monthly_cost = vol['Size'] * 0.10 # $0.10/GB/month for gp3
 print(f"Orphaned EBS: {vol['VolumeId']} - {vol['Size']}GB = ${monthly_cost:.2f}/mo")
 
 # Old snapshots (&gt; 90 days, no associated AMI)
 snapshots = ec2.describe_snapshots(OwnerIds=['self'])['Snapshots']
 for snap in snapshots:
 age_days = (datetime.now(timezone.utc) - snap['StartTime']).days
 if age_days &gt; 90:
 print(f"Old snapshot: {snap['SnapshotId']} - {age_days} days old")

find_orphaned_resources()
</code></pre></div>Tools like Cloud Custodian and Infracost automate this at scale.<h3 id="3-data-transfer-costs-hidden-but-massive">3. Data Transfer Costs (Hidden but Massive)</h3>Nobody budgets for data transfer. It’s usually 10-20% of total cloud bills and almost entirely invisible until month-end.Common culprits:<ul><li>Services in different regions talking to each other</li><li>NAT gateway traffic (AZ-crossing)</li><li>CloudFront origin pulls</li></ul>Quick audit:<div><pre><code># Find top talkers crossing AZ boundaries
aws cloudwatch get-metric-statistics \
 --namespace AWS/NATGateway \
 --metric-name BytesInFromSource \
 --period 86400 \
 --start-time 2026-04-01 \
 --end-time 2026-05-01 \
 --statistics Sum
</code></pre></div>Fix: Deploy services into the same AZ as their dependencies. Use VPC endpoints for S3/DynamoDB. Cache aggressively at the edge.<hr><h2 id="spotpreemptible-instances-the-best-roi-in-cloud-optimization">Spot/Preemptible Instances: The Best ROI in Cloud Optimization</h2>Spot instances (AWS) / Preemptible VMs (GCP) offer 60-90% discounts with one catch: they can be reclaimed with 2 minutes notice.For stateless workloads, this is free money.<h3 id="kubernetes-spot-strategy">Kubernetes Spot Strategy</h3><div><pre><code># Spot node pool for non-critical workloads
apiVersion: v1
kind: Node
metadata:
 labels:
 node.kubernetes.io/lifecycle: spot
 
---
# Pod affinity for batch/stateless workloads
spec:
 affinity:
 nodeAffinity:
 preferredDuringSchedulingIgnoredDuringExecution:
 - weight: 100
 preference:
 matchExpressions:
 - key: node.kubernetes.io/lifecycle
 operator: In
 values:
 - spot
 tolerations:
 - key: "spot"
 operator: "Equal"
 value: "true"
 effect: "NoSchedule"
</code></pre></div>What runs well on Spot:<ul><li>Batch processing jobs</li><li>CI/CD runners</li><li>ML training workloads</li><li>Auto-scaled stateless APIs (with proper disruption budgets)</li></ul>What shouldn’t run on Spot:<ul><li>Databases</li><li>Stateful services without proper checkpointing</li><li>Single-replica critical services</li></ul><hr><h2 id="tagging-the-foundation-of-cost-accountability">Tagging: The Foundation of Cost Accountability</h2>You can’t optimize what you can’t measure. Tagging is the prerequisite.Required tags (enforce via AWS Config / GCP Organization Policies):<div><pre><code># Terraform tagging example
locals {
 required_tags = {
 Team = var.team
 Environment = var.environment
 CostCenter = var.cost_center
 Service = var.service_name
 ManagedBy = "terraform"
 }
}

resource "aws_instance" "example" {
 # ... config ...
 tags = merge(local.required_tags, var.additional_tags)
}
</code></pre></div>AWS Config rule to enforce tagging:<div><pre><code>{
 "ConfigRuleName": "required-tags",
 "Source": {
 "Owner": "AWS",
 "SourceIdentifier": "REQUIRED_TAGS"
 },
 "InputParameters": {
 "tag1Key": "Team",
 "tag2Key": "Environment",
 "tag3Key": "CostCenter"
 }
}
</code></pre></div>Once tagged, surface costs per team in your FinOps dashboard. When teams see their costs, behavior changes.<hr><h2 id="ai-powered-cost-anomaly-detection">AI-Powered Cost Anomaly Detection</h2>Manual cost review doesn’t scale. In 2026, every major cloud provider offers ML-based anomaly detection:<div><pre><code># AWS Cost Anomaly Detection via API
import boto3

ce = boto3.client('ce')

# Create a monitor for a specific service
response = ce.create_anomaly_monitor(
 AnomalyMonitor={
 'MonitorName': 'service-cost-monitor',
 'MonitorType': 'DIMENSIONAL',
 'MonitorDimension': 'SERVICE'
 }
)

# Set alert threshold
ce.create_anomaly_subscription(
 AnomalySubscription={
 'MonitorArnList': [response['MonitorArn']],
 'Subscribers': [{
 'Address': 'engineering@company.com',
 'Type': 'EMAIL'
 }],
 'Threshold': 20.0, # Alert if cost anomaly &gt; $20
 'Frequency': 'DAILY',
 'SubscriptionName': 'daily-cost-alerts'
 }
)
</code></pre></div>Teams using automated anomaly detection catch cost spikes within hours instead of weeks.<hr><h2 id="the-finops-dashboard-you-actually-need">The FinOps Dashboard You Actually Need</h2>Stop looking at total monthly spend. Track unit economics:<table><thead><tr><th>Metric</th><th>Formula</th><th>Why It Matters</th></tr></thead><tbody><tr><td>Cost per Request</td><td>Total Spend / Total Requests</td><td>Measures efficiency over time</td></tr><tr><td>Cost per User</td><td>Total Spend / Active Users</td><td>Scales with your business</td></tr><tr><td>Cost per Feature</td><td>Service Spend / Feature Usage</td><td>Shows ROI of features</td></tr><tr><td>Waste %</td><td>Idle Spend / Total Spend</td><td>Directly actionable</td></tr></tbody></table>When costs grow proportionally with users/requests, that’s healthy scaling. When costs grow faster than value delivered, that’s waste.<hr><h2 id="30-day-quick-win-plan">30-Day Quick Win Plan</h2>Week 1: Enable Cost Explorer, tag all resources, identify top 10 cost drivers.Week 2: Right-size the top 3 overprovisioned services. Move dev/test to Spot/Preemptible.Week 3: Audit and delete orphaned resources. Review data transfer costs.Week 4: Set up anomaly detection. Create per-team cost dashboards. Run FinOps review.Most teams see 15-25% cost reduction in the first 30 days with this approach. The deeper wins (architecture changes, reserved instance strategy, spot adoption) come in months 2-6.<hr><h2 id="conclusion">Conclusion</h2>Cloud cost optimization isn’t about being cheap. It’s about being efficient — getting maximum value per dollar spent. The teams winning in 2026 treat cloud cost as an engineering discipline, not an afterthought.Instrument. Measure. Allocate. Optimize. Repeat.Your cloud bill is a measure of your engineering efficiency. Make it a metric you’re proud of. <div>이 글이 도움이 되셨다면 공감 및 광고 클릭을 부탁드립니다 :) </div></div></div>

Dev Note

The Cloud Bill Problem Is an Engineering Problem
Your CFO is looking at the cloud bill. It went up 40% this year. You shipped maybe 15% more features. Something isn’t adding up.
This is the most common conversation in engineering leadership right now. And it’s not a procurement problem or a vendor negotiation problem — it’s an engineering problem.
Cloud costs are a function of architecture decisions, resource allocation, code efficiency, and operational discipline. The teams cutting their bills by 30-50% without slowing down aren’t doing it through better contract negotiations. They’re doing it through better engineering.
Here’s the playbook.
Photo by Maxim Hopman on Unsplash
The FinOps Framework: Culture First
FinOps isn’t a tool. It’s a practice — the intersection of Finance, Technology, and Business.
The FinOps Foundation’s maturity model:
Phase
      Characteristics
    
Crawl
      Cost visibility exists. Teams know what they spend.
    
Walk
      Teams are accountable for costs. Optimization is happening.
    
Run
      Cost efficiency is automated. Real-time optimization. AI-driven.
    
Most companies in 2026 are stuck at “Crawl” → “Walk”. The companies at “Run” have 40-60% lower unit economics than their peers.
The critical cultural shift: engineers own cost as a first-class metric, alongside latency, reliability, and security.
The Biggest Cost Drains (And Their Fixes)
1. Overprovisioned Compute (Typically 35-50% of Waste)
The pattern: dev environment specs copy-pasted to production. 4-core, 16GB instances running at 5% CPU utilization.
Quick win: Right-sizing
# AWS Compute Optimizer recommendations
aws compute-optimizer get-ec2-instance-recommendations \
  --account-ids $ACCOUNT_ID \
  --filters name=Finding,values=Overprovisioned
# Output typically shows: "Reduce from m5.xlarge to m5.large = -50% cost"
AWS Compute Optimizer, GCP Recommender, and Azure Advisor all surface these automatically. The issue isn’t finding them — it’s acting on them. Assign ownership, create a monthly right-sizing review.
Kubernetes right-sizing with VPA:
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: payment-service-vpa
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: payment-service
  updatePolicy:
    updateMode: "Auto"  # Or "Recommendation" to review first
  resourcePolicy:
    containerPolicies:
    - containerName: payment-service
      minAllowed:
        cpu: 50m
        memory: 128Mi
      maxAllowed:
        cpu: 2
        memory: 2Gi
VPA automatically adjusts CPU/memory requests based on actual usage. Teams using VPA typically see 25-40% cost reduction in Kubernetes workloads.
2. Idle and Orphaned Resources (Typically 15-25% of Waste)
Snapshots from last year’s testing. Load balancers pointing at deleted services. NAT gateways with no traffic. These accumulate silently.
Detection script:
import boto3
def find_orphaned_resources():
    ec2 = boto3.client('ec2')
    
    # Unattached EBS volumes
    volumes = ec2.describe_volumes(
        Filters=[{'Name': 'status', 'Values': ['available']}]
    )['Volumes']
    
    for vol in volumes:
        monthly_cost = vol['Size'] * 0.10  # $0.10/GB/month for gp3
        print(f"Orphaned EBS: {vol['VolumeId']} - {vol['Size']}GB = ${monthly_cost:.2f}/mo")
    
    # Old snapshots (> 90 days, no associated AMI)
    snapshots = ec2.describe_snapshots(OwnerIds=['self'])['Snapshots']
    for snap in snapshots:
        age_days = (datetime.now(timezone.utc) - snap['StartTime']).days
        if age_days > 90:
            print(f"Old snapshot: {snap['SnapshotId']} - {age_days} days old")
find_orphaned_resources()
Tools like Cloud Custodian and Infracost automate this at scale.
3. Data Transfer Costs (Hidden but Massive)
Nobody budgets for data transfer. It’s usually 10-20% of total cloud bills and almost entirely invisible until month-end.
Common culprits:
Services in different regions talking to each other
NAT gateway traffic (AZ-crossing)
CloudFront origin pulls
Quick audit:
# Find top talkers crossing AZ boundaries
aws cloudwatch get-metric-statistics \
  --namespace AWS/NATGateway \
  --metric-name BytesInFromSource \
  --period 86400 \
  --start-time 2026-04-01 \
  --end-time 2026-05-01 \
  --statistics Sum
Fix: Deploy services into the same AZ as their dependencies. Use VPC endpoints for S3/DynamoDB. Cache aggressively at the edge.
Spot/Preemptible Instances: The Best ROI in Cloud Optimization
Spot instances (AWS) / Preemptible VMs (GCP) offer 60-90% discounts with one catch: they can be reclaimed with 2 minutes notice.
For stateless workloads, this is free money.
Kubernetes Spot Strategy
# Spot node pool for non-critical workloads
apiVersion: v1
kind: Node
metadata:
  labels:
    node.kubernetes.io/lifecycle: spot
    
---
# Pod affinity for batch/stateless workloads
spec:
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        preference:
          matchExpressions:
          - key: node.kubernetes.io/lifecycle
            operator: In
            values:
            - spot
  tolerations:
  - key: "spot"
    operator: "Equal"
    value: "true"
    effect: "NoSchedule"
What runs well on Spot:
Batch processing jobs
CI/CD runners
ML training workloads
Auto-scaled stateless APIs (with proper disruption budgets)
What shouldn’t run on Spot:
Databases
Stateful services without proper checkpointing
Single-replica critical services
Tagging: The Foundation of Cost Accountability
You can’t optimize what you can’t measure. Tagging is the prerequisite.
Required tags (enforce via AWS Config / GCP Organization Policies):
# Terraform tagging example
locals {
  required_tags = {
    Team        = var.team
    Environment = var.environment
    CostCenter  = var.cost_center
    Service     = var.service_name
    ManagedBy   = "terraform"
  }
}
resource "aws_instance" "example" {
  # ... config ...
  tags = merge(local.required_tags, var.additional_tags)
}
AWS Config rule to enforce tagging:
{
  "ConfigRuleName": "required-tags",
  "Source": {
    "Owner": "AWS",
    "SourceIdentifier": "REQUIRED_TAGS"
  },
  "InputParameters": {
    "tag1Key": "Team",
    "tag2Key": "Environment",
    "tag3Key": "CostCenter"
  }
}
Once tagged, surface costs per team in your FinOps dashboard. When teams see their costs, behavior changes.
AI-Powered Cost Anomaly Detection
Manual cost review doesn’t scale. In 2026, every major cloud provider offers ML-based anomaly detection:
# AWS Cost Anomaly Detection via API
import boto3
ce = boto3.client('ce')
# Create a monitor for a specific service
response = ce.create_anomaly_monitor(
    AnomalyMonitor={
        'MonitorName': 'service-cost-monitor',
        'MonitorType': 'DIMENSIONAL',
        'MonitorDimension': 'SERVICE'
    }
)
# Set alert threshold
ce.create_anomaly_subscription(
    AnomalySubscription={
        'MonitorArnList': [response['MonitorArn']],
        'Subscribers': [{
            'Address': 'engineering@company.com',
            'Type': 'EMAIL'
        }],
        'Threshold': 20.0,  # Alert if cost anomaly > $20
        'Frequency': 'DAILY',
        'SubscriptionName': 'daily-cost-alerts'
    }
)
Teams using automated anomaly detection catch cost spikes within hours instead of weeks.
The FinOps Dashboard You Actually Need
Stop looking at total monthly spend. Track unit economics:
Metric
      Formula
      Why It Matters
    
Cost per Request
      Total Spend / Total Requests
      Measures efficiency over time
    
Cost per User
      Total Spend / Active Users
      Scales with your business
    
Cost per Feature
      Service Spend / Feature Usage
      Shows ROI of features
    
Waste %
      Idle Spend / Total Spend
      Directly actionable
    
When costs grow proportionally with users/requests, that’s healthy scaling. When costs grow faster than value delivered, that’s waste.
30-Day Quick Win Plan
Week 1: Enable Cost Explorer, tag all resources, identify top 10 cost drivers.
Week 2: Right-size the top 3 overprovisioned services. Move dev/test to Spot/Preemptible.
Week 3: Audit and delete orphaned resources. Review data transfer costs.
Week 4: Set up anomaly detection. Create per-team cost dashboards. Run FinOps review.
Most teams see 15-25% cost reduction in the first 30 days with this approach. The deeper wins (architecture changes, reserved instance strategy, spot adoption) come in months 2-6.
Conclusion
Cloud cost optimization isn’t about being cheap. It’s about being efficient — getting maximum value per dollar spent. The teams winning in 2026 treat cloud cost as an engineering discipline, not an afterthought.
Instrument. Measure. Allocate. Optimize. Repeat.
Your cloud bill is a measure of your engineering efficiency. Make it a metric you’re proud of.

FinOps in 2026: How Engineering Teams Are Cutting Cloud Bills by 40% Without Cutting Features

댓글