# Budget And Cost Management

> Budget and Cost Management Skill

- Skill: `weirdgme/budget-and-cost-management` (Agent Skill)
- Install (CLI): `npx skillmds@latest add weirdgme/budget-and-cost-management`
- Raw SKILL.md: https://api.skillmd.com/api/skills/weirdgme/budget-and-cost-management/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Finance & Business
- Author: weirdgme (https://skillmd.com/u/weirdgme)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/weirdgme/budget-and-cost-management

---

# Budget and Cost Management Skill

**For engineering managers managing infrastructure budgets, cloud costs, and demonstrating ROI for platform investments.**

> This skill helps managers plan infrastructure budgets, implement cost governance, allocate costs across teams, and build business cases for platform investments. Focused on financial management, not technical cost optimization.

---
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🎯 SKILL ACTIVATED: budget-and-cost-management
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━


## When to Use This Skill

**You're a manager who needs help with:**
- Planning annual infrastructure budgets
- Understanding cloud bills and cost drivers
- Implementing cost allocation and chargebacks
- Building ROI cases for platform investments
- FinOps practices for engineering teams
- Negotiating budgets with finance/leadership
- Forecasting infrastructure costs as team scales
- Balancing cost vs performance trade-offs

**This skill does NOT cover:**
- Hands-on technical cost optimization (see **cloud-engineering** skill)
- Detailed cloud pricing models (see **cloud-engineering** skill)
- Infrastructure architecture decisions (see **infrastructure-strategy** skill)
- Team hiring costs (see **engineering-management** skill)

---

## Core Areas

### 1. Understanding Cloud Costs (Manager's Perspective)

**The challenge:** Cloud bills are complex. You need to understand enough to manage budgets without becoming a cloud pricing expert.

#### Cloud Cost Breakdown (Simplified)

**AWS Cost Structure:**
```
Typical AWS Bill Breakdown:

Compute (40-50%):
├── EC2 instances (VMs)
├── Lambda (serverless functions)
├── ECS/EKS (containers)
└── Spot instances (discounted)

Storage (20-30%):
├── S3 (object storage)
├── EBS (block storage for EC2)
├── Glacier (archival)
└── Data transfer OUT (expensive!)

Databases (15-25%):
├── RDS (managed databases)
├── DynamoDB
├── ElastiCache (Redis/Memcached)
└── Redshift (data warehouse)

Networking (5-10%):
├── Load balancers
├── NAT gateways
├── VPN connections
└── Data transfer

Other (5-10%):
├── CloudWatch (monitoring)
├── Route53 (DNS)
├── Support plan (3-10% of total bill)
└── Misc services
```

**Azure and GCP:** Similar breakdowns, different service names.

#### Common Cost Surprises for Managers

```
🚨 Data Transfer Costs:
- $0.09/GB to transfer data OUT of cloud
- Can be 10-20% of total bill
- Example: 10TB/month = $900/month

🚨 NAT Gateway Costs:
- $0.045/hour + $0.045/GB processed
- Often hidden, can be $500+/month per gateway

🚨 Load Balancer Costs:
- Application Load Balancer: $20/month + usage
- 10 ALBs = $2,400/year just for availability

🚨 "Idle" Resources:
- Dev/test environments running 24/7
- Non-production databases at production size
- Can be 30-40% of total spend
```

**Key insight for managers:** Most cloud costs come from a few sources. Focus your cost governance there.

---

### 2. Infrastructure Budget Planning

**Goal:** Create realistic annual infrastructure budget that accounts for growth and innovation.

#### Annual Budget Planning Process

**Step 1: Baseline Current Spend**
```
Current Monthly Spend Breakdown:

Production Infrastructure: $50,000/month
├── Compute: $20,000
├── Storage: $10,000
├── Databases: $15,000
└── Networking: $5,000

Non-Production: $15,000/month
├── Staging: $8,000
├── Dev: $5,000
└── Test: $2,000

Tools & Services: $10,000/month
├── Observability: $4,000 (Datadog)
├── Security: $3,000 (SCA tools, SIEM)
├── CI/CD: $2,000 (GitHub, CircleCI)
└── Other: $1,000

Total: $75,000/month = $900K/year
```

**Step 2: Project Growth**
```
Growth Drivers:

User Growth:
├── Current: 100K users
├── Projected: 150K users (+50%)
├── Infrastructure impact: +30% (due to economies of scale)
└── Cost impact: +$270K/year

Team Growth:
├── Current: 30 engineers
├── Projected: 45 engineers (+50%)
├── Dev environment impact: +50%
└── Cost impact: +$90K/year (dev/staging environments)

New Initiatives:
├── Machine learning platform: +$100K/year
├── Multi-region expansion: +$200K/year
└── Data lake project: +$80K/year

Total Growth: +$740K/year
```

**Step 3: Efficiency Initiatives**
```
Cost Savings Opportunities:

Reserved Instances / Savings Plans:
├── Current: 20% coverage
├── Target: 60% coverage
├── Discount: 30-40% on committed compute
└── Savings: -$150K/year

Right-Sizing:
├── Over-provisioned resources identified
└── Savings: -$80K/year

Shutdown Automation:
├── Auto-stop non-prod environments after hours
└── Savings: -$70K/year

Total Savings: -$300K/year
```

**Step 4: Calculate Budget Request**

```
Annual Infrastructure Budget:

Baseline:               $900K
+ Growth:               $740K
- Efficiency Savings:   -$300K
+ Contingency (10%):    +$134K
─────────────────────────────
Total Budget Request:   $1,474K (~$1.5M)

Quarterly Breakdown:
├── Q1: $350K (baseline + reserved instance purchases)
├── Q2: $360K
├── Q3: $380K (new initiatives launch)
└── Q4: $384K (continued growth)
```

#### Budget Presentation to Leadership

```
Slide 1: Executive Summary
├── Request: $1.5M infrastructure budget for FY2025
├── Current: $900K (FY2024)
├── Growth: +67% budget, supporting +50% user growth
└── Key investments: Multi-region, ML platform, efficiency

Slide 2: Cost Drivers
├── User growth: +50% → +$270K
├── Team growth: +50% → +$90K
├── Strategic initiatives: +$380K
└── Net increase: +$440K (after savings)

Slide 3: Efficiency Initiatives
├── Reserved instance optimization: -$150K
├── Right-sizing: -$80K
├── Automation: -$70K
└── Total savings: -$300K

Slide 4: Risk Mitigation
├── Contingency: 10% ($134K)
├── Monitoring: Monthly cost reviews
└── Governance: Cost allocation by team

Slide 5: Comparison & Benchmarks
├── Industry: $20-30 per user/month (we're at $25)
├── Trend: Infrastructure cost per user decreasing
└── Competitive: Within range for our stage
```

**Pro tip:** Frame infrastructure cost as **cost per user** or **% of revenue** to show efficiency, not just absolute dollars.

#### Budget Planning Scenarios

**Scenario: "How much contingency buffer should we include?"**
- **Standard:** 10-15% contingency for infrastructure budgets
- **Calculation:** If base budget is $1.34M, add $134-200K contingency
- **Use for:**
  - Unexpected user growth spurts
  - Security incidents requiring rapid scaling
  - Failed efficiency initiatives (savings don't materialize)
  - New compliance requirements
- **Don't use for:** Planned initiatives (those should be in base budget)

**Scenario: "What if we're spending X% of revenue on infrastructure?"**
- **Benchmarks by stage:**
  - Early stage (pre-PMF): 20-40% of revenue (acceptable, focus on growth)
  - Growth stage: 15-25% of revenue (optimize as you scale)
  - Scale stage: 10-15% of revenue (mature, efficient)
- **If too high (>30%):** Focus on efficiency initiatives
- **If too low (<10%):** May be underinvesting in infrastructure/reliability

**Scenario: "How do we handle untagged costs?"**
- **Problem:** $50K/month in untagged AWS resources
- **Solution:**
  1. Run quarterly tagging audits - find untagged resources
  2. Email resource owners: "Tag or terminate in 30 days"
  3. Auto-shutdown untagged non-production resources after 60 days
  4. Track tagging compliance: Target 95%+
- **Allocate untagged:** Split proportionally across teams until resolved

**Scenario: "Should we cross-charge teams for their infrastructure?"**
- **Showback (Recommended):**
  - Show teams their costs, don't charge them
  - Pros: Awareness without friction, teams optimize voluntarily
  - Cons: No hard enforcement
- **Chargeback:**
  - Actually charge teams' budgets for infrastructure
  - Pros: Strong incentive to optimize
  - Cons: Bureaucracy, cross-team friction, accounting complexity
- **Decision:** Start with showback. Only move to chargeback if waste is significant (>20%)

**Scenario: "How can we optimize storage costs with lifecycle policies?"**
- **S3 Lifecycle Rules:**
  - Day 0-30: Standard S3 ($0.023/GB)
  - Day 30-90: Infrequent Access ($0.0125/GB) - 46% savings
  - Day 90+: Glacier ($0.004/GB) - 83% savings
- **Example savings:**
  - 100TB data, 50% older than 30 days
  - Without lifecycle: $2,300/month
  - With lifecycle: $1,150 + $250 = $1,400/month
  - **Savings:** $900/month = $10.8K/year
- **Action:** Implement lifecycle policies for logs, backups, archives

**Scenario: "How do we benchmark our costs against industry?"**
- **Metrics to compare:**
  - Infrastructure cost per engineer: $5-15K/month
  - Infrastructure cost per user: $0.50-5/month (varies by product)
  - Infrastructure as % of revenue: 10-25%
- **Where to get benchmarks:**
  - FinOps Foundation reports
  - Industry surveys (Gartner, Forrester)
  - Peer companies (if you have relationships)
- **Use benchmarks to:** Justify current spend or identify optimization opportunities

**Scenario: "How do we explain cloud value to the board?"**
- **Frame as business enablement:**
  - "Cloud enables us to scale 10x without hiring 10x engineers"
  - "Deployed 50 new features this year vs 12 last year (on-prem)"
  - "Cloud costs $1.5M but saved $800K in datacenter costs + $500K in ops labor"
- **Show ROI:**
  - Time to market: Weeks → Days
  - Reliability: 99.9% → 99.99% uptime
  - Security: Automated compliance vs manual
- **Avoid:** Technical jargon, focus on business outcomes

**Scenario: "What should we present in quarterly business reviews (QBR)?"**
- **Slide 1: Cost Summary**
  - Total spend: $450K (vs $425K budget, +6%)
  - Trend: Up 8% QoQ (expected due to growth)
  - Cost per user: $2.50 (down from $2.75, improving efficiency)
- **Slide 2: Drivers of Change**
  - User growth: +15% → +$40K
  - New ML feature: +$30K
  - Reserved instance savings: -$15K
- **Slide 3: Efficiency Initiatives**
  - Right-sizing: Saved $25K this quarter
  - Storage lifecycle: Saved $10K/quarter ongoing
  - Next: Spot instances pilot (+$15K savings potential)
- **Slide 4: Forecast**
  - Q4 projection: $460K (on track for annual budget)
  - Risk: Potential user surge during holiday season

---

### 3. Cost Allocation and Chargebacks

**Why cost allocation matters:**
- Teams understand their impact on infrastructure costs
- Product decisions factor in infrastructure costs
- Accountability for resource usage

#### Cost Allocation Models

**Model 1: Simple Allocation by Team (Easiest)**
```
Tagging Strategy:
├── Tag: "Team" (e.g., "payments", "growth", "platform")
├── Tag: "Environment" (e.g., "prod", "staging", "dev")
└── Tag: "Cost-Center" (e.g., "engineering", "product")

Monthly Cost Report:
├── Payments Team: $15,000
│   ├── Production: $12,000
│   └── Non-production: $3,000
├── Growth Team: $10,000
├── Platform Team: $8,000 (shared infrastructure)
└── Unallocated: $2,000 (fix tagging)

Total: $35,000
```

**Model 2: Showback (Informational, Recommended)**
```
Show teams their costs, but don't charge them.

Benefits:
✅ Raises cost awareness
✅ No budget battles between teams
✅ Platform team keeps central budget

Monthly Report to Teams:
"Growth Team: You used $10K in infrastructure this month
 Top cost driver: Your new ML model ($4K)
 Opportunity: Shut down old staging environments ($1K/month savings)"
```

**Model 3: Chargeback (Transactional, Complex)**
```
Actually charge teams for their infrastructure usage.

Benefits:
✅ True accountability
✅ Teams optimize their own costs

Drawbacks:
❌ Bureaucratic overhead
❌ Teams may optimize for cost over performance
❌ Discourages experimentation

Implementation:
1. Each team gets infrastructure budget allocation
2. Monthly "bill" for actual usage
3. Overage requires approval

Example:
├── Payments Team Budget: $20K/month
├── Actual Usage: $22K/month
├── Overage: $2K (requires VP approval)
└── Finance transfers budget between cost centers
```

**Recommendation for most orgs:** Start with **showback**, move to chargeback only if needed.

#### Allocating Shared Costs

**Problem:** Platform team costs benefit everyone. How to allocate?

```
Platform Team Infrastructure: $50K/month
├── Kubernetes clusters (shared)
├── CI/CD infrastructure
├── Observability stack
├── Shared databases/caches
└── Networking

Allocation Options:

Option A: Split Equally
├── 5 product teams
├── $10K/month per team
└── Simple, but unfair if usage varies

Option B: Split by Usage (Compute Hours)
├── Payments: 40% usage → $20K
├── Growth: 30% usage → $15K
├── Other teams: 30% → $15K
└── Fair, but complex to measure

Option C: Don't Allocate (Recommended)
├── Platform costs stay centralized
├── Product teams only see their direct costs
├── Simpler, encourages platform adoption
└── "Infrastructure as a free internal service"
```

**Pro tip:** If you charge for shared platform, teams will build their own infrastructure to avoid costs (not what you want).

---

### 4. FinOps for Engineering Managers

**FinOps:** Financial Operations - collaboration between engineering, finance, and business on cloud costs.

#### FinOps Maturity Model

```
Level 1: Reactive (Most orgs start here)
├── Cloud bill arrives, surprise at cost
├── No visibility into cost drivers
├── No ownership of costs
└── Action: Set up basic cost tracking

Level 2: Monitoring (6-12 months)
├── Monthly cost reviews
├── Tagging and allocation in place
├── Some cost awareness
└── Action: Implement showback

Level 3: Optimizing (12-24 months)
├── Proactive cost optimization
├── Reserved instance strategy
├── Cost targets for teams
└── Action: Build cost culture

Level 4: Advanced (24+ months)
├── Real-time cost optimization
├── Automated policies
├── Cost per product metric
└── Action: Continuous improvement
```

#### FinOps Practices for Managers

**1. Monthly Cost Review Meeting (30-60 min)**
```
Attendees: Engineering managers, finance, platform lead

Agenda:
1. Review total spend vs budget (5 min)
   ├── $85K actual vs $80K budget
   └── $5K overage (6% over)

2. Top cost increases (15 min)
   ├── Payments team: +$10K (new ML model launched)
   ├── Growth team: +$5K (A/B testing infrastructure)
   └── Platform: +$3K (added Kubernetes nodes)

3. Cost optimization wins (10 min)
   ├── Shutdown automation saved $4K
   ├── Right-sized databases saved $2K
   └── Total savings: $6K

4. Action items (10 min)
   ├── Investigate payments ML model cost (can we optimize?)
   ├── Review reserved instance coverage (currently 30%, target 50%)
   └── Tag unallocated $2K in costs

5. Forecast next month (5 min)
   └── Expected: $90K (new feature launch)
```

**2. Cost Anomaly Alerts**
```
Set up alerts for unexpected cost spikes:

Alert Rules:
├── Daily spend > $5K (normal: $2.5K)
├── Weekly spend > 20% above baseline
├── Specific service > $1K/day (e.g., Lambda)
└── Untagged resources > $500

Response:
├── Alert goes to platform team + manager
├── Investigate within 24 hours
├── Report findings in Slack
└── Fix or accept (with explanation)
```

**3. Cost Ownership Culture**
```
Make engineers cost-aware:

✅ DO:
- Share monthly cost reports with all engineers
- Celebrate cost optimization wins
- Include cost in architecture review
- Provide cost dashboards (self-service visibility)

❌ DON'T:
- Blame engineers for high costs
- Penalize experimentation
- Make cost the only metric
- Hide cost information
```

---

### 5. ROI Frameworks for Platform Investments

**The question:** "Should we invest $500K in building an internal developer platform?"

**Answer:** Build an ROI case.

#### Platform Investment ROI Template

**Investment: Internal Developer Platform**

**Costs (Year 1):**
```
Team:
├── 1 Staff Engineer: $220K
├── 2 Senior Engineers: $320K
├── 1 Product Manager: $180K
└── Total Headcount: $720K

Tools & Infrastructure:
├── Kubernetes clusters: $60K
├── CI/CD tooling: $40K
├── Observability: $30K
└── Total Tools: $130K

Total Year 1 Investment: $850K
```

**Benefits (Year 1):**
```
Developer Productivity:
├── 40 product engineers
├── Current: 2 hours/day on infrastructure toil
├── Target: 30 min/day (platform automates common tasks)
├── Time saved: 1.5 hours/day × 40 engineers = 60 hours/day
├── Annual value: 60 × 220 work days × $80/hour = $1,056,000

Faster Deployments:
├── Current: 2 hours to deploy (manual process)
├── Target: 10 minutes (automated CI/CD)
├── 5 deploys/week → 4 hours saved/week
├── Annual value: Hard to quantify, but reduces time-to-market

Reduced Incidents:
├── Current: 4 incidents/month from manual errors
├── Target: 1 incident/month (automation prevents errors)
├── Cost per incident: $10K (downtime + eng time)
├── Annual value: 3 incidents/month × 12 × $10K = $360K

Total Annual Benefits: ~$1.4M
```

**ROI Calculation:**
```
ROI = (Benefits - Costs) / Costs × 100%
ROI = ($1.4M - $850K) / $850K × 100%
ROI = 65% Year 1 ROI

Payback Period: 7-8 months

3-Year NPV:
├── Year 1: -$850K + $1.4M = +$550K
├── Year 2: -$750K (ongoing) + $1.6M = +$850K
├── Year 3: -$750K + $1.8M = +$1,050K
└── Total 3-Year Value: +$2.45M
```

**Presenting to Leadership:**

```
Slide 1: The Problem
├── 40 engineers spend 2 hours/day on infrastructure toil
├── Manual deployments take 2 hours, error-prone
├── 4 incidents/month from manual errors
└── This is costing us $1.4M/year in lost productivity

Slide 2: The Solution
├── Build internal developer platform
├── Self-service infrastructure provisioning
├── Automated CI/CD pipelines
└── Reduced toil, faster deployments, fewer incidents

Slide 3: The Investment
├── Team: 4 people ($720K)
├── Infrastructure: $130K
├── Total Year 1: $850K
└── Ongoing: $750K/year

Slide 4: The Return
├── Developer productivity: +$1M/year
├── Reduced incidents: +$360K/year
├── Faster time-to-market: Priceless
└── ROI: 65% in Year 1, 7-month payback

Slide 5: Risk Mitigation
├── Start with pilot (2-3 teams)
├── Iterate based on feedback
├── Measure adoption and satisfaction
└── Stop if ROI not realized after 6 months
```

#### Common Platform Investment ROI Calculations

**CI/CD Pipeline:**
```
Investment: $200K (2 engineers for 6 months)
Benefit: Reduce deployment time from 4 hours → 15 minutes
Value: 20 deploys/week × 3.75 hours saved × $80/hour × 50 weeks = $300K/year
ROI: 50% Year 1
```

**Observability Platform:**
```
Investment: $150K/year (tooling + 1 engineer)
Benefit: Reduce MTTR from 4 hours → 1 hour
Value: 10 incidents/month × 3 hours saved × 5 engineers × $80/hour × 12 = $144K/year
Soft benefit: Customer trust, fewer escalations
ROI: Break-even Year 1, positive Year 2+
```

**Infrastructure as Code:**
```
Investment: $100K (1 engineer for 6 months)
Benefit: Reduce provisioning time from 2 days → 1 hour
Value: 50 provisioning requests/year × 15 hours saved × $80/hour = $60K/year
ROI: Negative Year 1, but compounds (enables other automation)
```

**Key insight:** Some platform investments pay off immediately. Others are foundational (IaC, observability) and enable future ROI.

---

### 6. Negotiating Budgets with Finance/Leadership

**The challenge:** Finance wants to cut costs. You need to maintain quality.

#### Budget Negotiation Scenarios

**Scenario 1: "Cut your budget by 20%"**

```
DON'T:
❌ "We can't do that, infrastructure is critical!"
❌ Across-the-board 20% cut (quality suffers)
❌ Accept without analysis

DO:
✅ Provide options with trade-offs

Response:
"I can present three options for a 20% reduction ($300K):

Option A: Cut scope
├── Delay multi-region expansion (saves $200K)
├── Pause ML platform project (saves $100K)
└── Impact: Product roadmap slips by 2 quarters

Option B: Reduce quality
├── Cut non-production environments (saves $150K)
├── Reduce observability tooling (saves $80K)
├── Defer reserved instance purchases (saves $70K)
└── Impact: Slower development, more incidents, higher long-term costs

Option C: Optimize efficiency (Recommended)
├── Aggressive right-sizing (saves $120K)
├── Shutdown automation (saves $90K)
├── Renegotiate vendor contracts (saves $90K)
└── Impact: Minimal, achievable in 3 months

Which option aligns with business priorities?"
```

**Scenario 2: "Why is cloud so expensive?"**

```
DON'T:
❌ Get defensive: "That's just what it costs!"
❌ Technical jargon: "Well, our egress costs are..."

DO:
✅ Normalize costs with business metrics

Response:
"Let's look at infrastructure cost in context:

Cost per User:
├── Current: $25/user/month
├── Industry benchmark: $20-35/user/month
└── We're in healthy range

Cost as % of Revenue:
├── Current: 3.5% of revenue
├── Target for our stage: 3-5%
└── We're on target

Trend:
├── Q1: $30/user
├── Q2: $27/user
├── Q3: $25/user (current)
└── Decreasing cost per user as we scale (economies of scale)

We're efficiently managing costs while enabling growth."
```

**Scenario 3: "Can we move to a cheaper cloud?"**

```
DON'T:
❌ Dismiss immediately: "No, we're on AWS"
❌ Over-promise: "Yes, we'll save 50%!"

DO:
✅ Analyze total cost of switching

Response:
"Let's evaluate the full cost of a cloud migration:

Migration Costs:
├── 6-12 months engineer time: $600K-$1.2M
├── Downtime risk: Potential revenue loss
├── New tooling and training: $100K
├── Parallel running costs (6 months): $300K
└── Total: $1M-$1.6M

Ongoing Savings:
├── Compute costs: -10% ($60K/year)
├── But: New costs for migration complexity
└── Net savings: $40K-$60K/year

Payback Period: 17-25 years

Recommendation: Not worth it. Better ROI from optimization on current cloud."
```

#### Budget Defense Tactics

**Tactic 1: Show Value, Not Just Cost**
```
Instead of: "We spent $1.5M on infrastructure"
Say: "We supported 50% user growth for a 30% increase in infrastructure spend"
```

**Tactic 2: Benchmark Against Industry**
```
Use data from:
├── Andreessen Horowitz infra benchmarks
├── Industry reports (Flexera, CloudHealth)
├── Peer companies (if you have relationships)
└── "We're at 3.5% of revenue, industry average is 4-6%"
```

**Tactic 3: Show Continuous Improvement**
```
Quarter-over-quarter efficiency:
├── Q1: $35/user
├── Q2: $32/user (-9%)
├── Q3: $28/user (-12%)
└── "We're continuously optimizing while supporting growth"
```

**Tactic 4: Tie to Business Outcomes**
```
Instead of: "We need $2M for infrastructure"
Say: "This infrastructure investment enables:
     - 99.99% uptime (customer trust)
     - <100ms latency (conversion rate +5%)
     - Scale to 500K users (revenue opportunity: $10M)"
```

---

## Quick Reference for Managers

**Budget Planning:**
- Start with baseline, add growth, subtract efficiency
- Include 10% contingency
- Present cost per user or % of revenue

**Cost Allocation:**
- Start with showback (informational)
- Tag resources by team/environment
- Don't charge for shared platform (encourages usage)

**FinOps Practices:**
- Monthly cost review meeting
- Cost anomaly alerts (>20% spike)
- Share cost data transparently with teams

**Platform ROI:**
- Calculate productivity gains (time saved × hourly rate)
- Account for incident reduction
- Show payback period (target: <12 months)

**Budget Negotiation:**
- Provide options with trade-offs
- Normalize costs (per user, % revenue)
- Show continuous improvement trend
- Tie to business outcomes

**Key Metrics to Track:**
- Monthly infrastructure spend
- Cost per user
- Infrastructure cost as % of revenue
- Reserved instance coverage
- Cost allocation by team

---

## Integration with Other Skills

**This skill works with:**
- **engineering-management** - Headcount planning, team budgets
- **infrastructure-strategy** - Build vs buy decisions, long-term investment
- **engineering-operations-management** - On-call compensation, incident costs
- **technical-leadership** - Making investment decisions with data

**Technical skills for cost optimization:**
- **cloud-engineering** - Technical cost optimization, reserved instances
- **platform-engineering** - Building cost-efficient platforms
- **sre** - Efficiency through automation, reducing toil

---

**Remember:** Your job is to be a good steward of infrastructure budget while enabling the business to grow. Optimize for long-term value, not just short-term cost cuts. Transparency and data-driven decisions build trust with finance and leadership.