FinOps for Developers: How to Cut Cloud Costs Without Slowing Down

Inform → Optimize → Operate

  Inform:    Make costs visible to the people who generate them
  Optimize:  Identify and implement savings opportunities
  Operate:   Continuously track, govern, and improve

1 x m5.xlarge (on-demand) = $0.192/hour
Running 24/7 = $140/month
Used 10 hours/day, 5 days/week = ~$42/month of actual usage
Waste: $98/month per instance

# Auto-shutdown dev environments on a schedule
resource "aws_autoscaling_schedule" "scale_down_evening" {
  scheduled_action_name  = "scale-down-evening"
  min_size               = 0
  max_size               = 0
  desired_capacity       = 0
  recurrence             = "0 19 * * MON-FRI"  # 7 PM weekdays
  autoscaling_group_name = aws_autoscaling_group.dev.name
}

resource "aws_autoscaling_schedule" "scale_up_morning" {
  scheduled_action_name  = "scale-up-morning"
  min_size               = 1
  max_size               = 3
  desired_capacity       = 1
  recurrence             = "0 7 * * MON-FRI"   # 7 AM weekdays
  autoscaling_group_name = aws_autoscaling_group.dev.name
}

-- Check average CPU over the last 7 days (PostgreSQL)
SELECT
  avg(cpu_percent) as avg_cpu,
  max(cpu_percent) as peak_cpu,
  avg(connections) as avg_connections
FROM pg_stat_activity_history
WHERE timestamp > now() - interval '7 days';

# Find unattached EBS volumes
aws ec2 describe-volumes \
  --filters "Name=status,Values=available" \
  --query "Volumes[*].{ID:VolumeId,Size:Size,Created:CreateTime}" \
  --output table

# Find snapshots older than 90 days
aws ec2 describe-snapshots \
  --owner-ids self \
  --query "Snapshots[?StartTime<='$(date -d '-90 days' -u +%Y-%m-%dT%H:%M:%S)'].{ID:SnapshotId,Size:VolumeSize,Date:StartTime}" \
  --output table

# Over-provisioned (common default)
resources:
  requests:
    cpu: "2"
    memory: "4Gi"
  limits:
    cpu: "4"
    memory: "8Gi"

# Right-sized (based on actual P95 usage)
resources:
  requests:
    cpu: "250m"
    memory: "512Mi"
  limits:
    cpu: "1"
    memory: "1Gi"

# Install VPA
kubectl apply -f https://github.com/kubernetes/autoscaler/releases/download/vpa-1.2.0/vpa-v1.2.0.yaml

# Check recommendations
kubectl get vpa -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.recommendation.containerRecommendations[*].target}{"\n"}{end}'

// Bad: Logging full request/response bodies
app.use((req, res, next) => {
  logger.info('Request received', {
    body: req.body,           // Could be megabytes
    headers: req.headers,     // Includes auth tokens
    query: req.query,
  })
  next()
})

// Good: Log what matters, sample the rest
app.use((req, res, next) => {
  logger.info('Request received', {
    method: req.method,
    path: req.path,
    contentLength: req.headers['content-length'],
    requestId: req.headers['x-request-id'],
  })

  // Sample detailed logging at 1%
  if (Math.random() < 0.01) {
    logger.debug('Request detail (sampled)', {
      body: truncate(JSON.stringify(req.body), 1000),
      query: req.query,
    })
  }
  next()
})

# Install
brew install infracost

# Authenticate
infracost auth login

# Generate a cost breakdown
infracost breakdown --path .

# Compare against the current state
infracost diff --path .

Project: my-terraform-project

+ aws_instance.api
  +$140/month

  + Instance usage (Linux/UNIX, on-demand, m5.xlarge)
    +$140/month

+ aws_rds_instance.main
  +$380/month

  + Database instance (db.r6g.xlarge, Multi-AZ)
    +$380/month

+ aws_s3_bucket.assets
  ~$0.023/GB/month (usage-based)

Monthly cost will increase by $520 (+23%)

# .github/workflows/infracost.yml
name: Infracost
on:
  pull_request:
    paths:
      - 'terraform/**'

jobs:
  infracost:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v4

      - name: Setup Infracost
        uses: infracost/actions/setup@v3
        with:
          api-key: ${{ secrets.INFRACOST_API_KEY }}

      - name: Generate cost diff
        run: |
          infracost diff \
            --path=terraform/ \
            --format=json \
            --out-file=/tmp/infracost.json

      - name: Post PR comment
        uses: infracost/actions/comment@v3
        with:
          path: /tmp/infracost.json
          behavior: update

# Install via Helm
helm repo add kubecost https://kubecost.github.io/cost-analyzer/
helm install kubecost kubecost/cost-analyzer \
  --namespace kubecost \
  --create-namespace \
  --set kubecostToken="your-token"

# Get cost by namespace for the last 7 days
curl -s "http://kubecost.internal/model/allocation?window=7d&aggregate=namespace" | \
  jq '.data[0] | to_entries[] | {namespace: .key, cost: .value.totalCost}'

{"namespace": "production", "cost": 1247.83}
{"namespace": "staging", "cost": 892.14}
{"namespace": "dev-team-alpha", "cost": 456.21}
{"namespace": "monitoring", "cost": 234.67}

type TaskComplexity = 'simple' | 'moderate' | 'complex'

interface CostAwareRouter {
  selectModel(task: {
    complexity: TaskComplexity
    inputTokens: number
    requiresAccuracy: boolean
  }): string
}

const router: CostAwareRouter = {
  selectModel(task) {
    // Simple tasks: classification, extraction, formatting
    // Use the cheapest model that meets quality requirements
    if (task.complexity === 'simple') {
      return task.inputTokens > 10000
        ? 'gemini-2.0-flash'     // Cheapest for high volume
        : 'gpt-4o-mini'
    }

    // Moderate tasks: summarization, code review, Q&A
    if (task.complexity === 'moderate') {
      return task.requiresAccuracy
        ? 'claude-sonnet-4'      // Best accuracy/cost ratio
        : 'gpt-4o-mini'
    }

    // Complex tasks: multi-step reasoning, creative writing, analysis
    return 'claude-sonnet-4'
  }
}

import { createHash } from 'crypto'

class LLMCache {
  private cache: Map<string, { response: string; timestamp: number }>

  constructor(private ttlMs: number = 3600000) { // 1 hour default
    this.cache = new Map()
  }

  private getKey(model: string, messages: Message[]): string {
    const content = JSON.stringify({ model, messages })
    return createHash('sha256').update(content).digest('hex')
  }

  async query(
    model: string,
    messages: Message[],
    callApi: () => Promise<string>
  ): Promise<{ response: string; cached: boolean }> {
    const key = this.getKey(model, messages)
    const cached = this.cache.get(key)

    if (cached && Date.now() - cached.timestamp < this.ttlMs) {
      return { response: cached.response, cached: true }
    }

    const response= await callApi()
    this.cache.set(key, { response, timestamp: Date.now() })
    return { response, cached: false }
  }
}

// Usage
const cache= new LLMCache()
const { response, cached }= await cache.query(
  'gpt-4o-mini',
  messages,
  ()=> openai.chat.completions.create({ model: 'gpt-4o-mini', messages })
    .then(r=> r.choices[0].message.content!)
)

console.log(`Response ${cached ? '(cached)' : '(live)'}: ${response}`)

class TokenBudget {
  private usage: Map<string, number> = new Map()

  constructor(
    private dailyLimit: number,
    private alertThreshold: number = 0.8
  ) {}

  async checkBudget(team: string, estimatedTokens: number): Promise<boolean> {
    const today = new Date().toISOString().split('T')[0]
    const key = `${team}:${today}`
    const currentUsage = this.usage.get(key) || 0

    if (currentUsage + estimatedTokens > this.dailyLimit) {
      await this.notifyOverBudget(team, currentUsage)
      return false
    }

    if (currentUsage + estimatedTokens > this.dailyLimit * this.alertThreshold) {
      await this.notifyApproachingLimit(team, currentUsage)
    }

    this.usage.set(key, currentUsage + estimatedTokens)
    return true
  }

  private async notifyOverBudget(team: string, usage: number) {
    // Send Slack alert, log to monitoring, etc.
    console.warn(`Team ${team} exceeded daily token budget: ${usage}/${this.dailyLimit}`)
  }

  private async notifyApproachingLimit(team: string, usage: number) {
    console.warn(`Team ${team} at ${Math.round(usage/this.dailyLimit*100)}% of daily budget`)
  }
}

// 1M tokens/day budget per team
const budget = new TokenBudget(1_000_000)

Current monthly spend:                        $50,000
                                               ───────
Tier 1: Orphaned resources + scheduling         -$4,000
Tier 2: Right-sizing + reservations             -$6,000
Tier 3: Spot instances + Kubecost optimization  -$4,000
                                               ───────
Optimized monthly spend:                       $36,000
                                               ───────
Annual savings:                               $168,000

# Simple weekly cost report script
#!/bin/bash
COST=$(aws ce get-cost-and-usage \
  --time-period Start=$(date -d '7 days ago' +%Y-%m-%d),End=$(date +%Y-%m-%d) \
  --granularity DAILY \
  --metrics BlendedCost \
  --query "ResultsByTime[*].Total.BlendedCost.Amount" \
  --output text | awk '{sum+=$1} END {printf "%.2f", sum}')

curl -X POST "$SLACK_WEBHOOK" \
  -H 'Content-type: application/json' \
  -d "{\"text\":\"Cloud spend this week: \$${COST}\"}"

# Require cost tags on all resources
variable "required_tags" {
  type = map(string)
  default = {
    team        = ""
    project     = ""
    environment = ""
    cost-center = ""
  }
}

resource "aws_instance" "example" {
  # ... instance config ...

  tags = merge(var.required_tags, {
    team        = "platform"
    project     = "api-gateway"
    environment = "production"
    cost-center = "engineering"
    Name        = "api-gateway-prod"
  })
}