Skip to main content
skill CX Codex

capacity-planning-helper — Claude Code skill: sizing and cost

capacity-planning-helper is a Claude Code skill that turns a traffic forecast into instance counts, database and cache sizing, and a monthly AWS cost estimate.

MIT 265 installs ★ 64 updated 2026-01-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add patricio0312rev/skills --skill capacity-planning-helper -a claude-code
Open on GitHub

What capacity-planning-helper does

The skill takes a forecast (daily users, average and peak RPS now and at 6, 12 or 24 months) and turns it into a resource list: how many instances, which type, how much memory, how many cache nodes and how much disk. Inside are TypeScript sketches of TrafficForecast and ResourceNeeds, an estimateResources function, and an hourly cost calculation.

The math is rough on purpose. One instance per 100 RPS of peak load, then 50% headroom stacked on top. Databases are sized from connection counts, the cache gets a primary and a replica. Prices are AWS constants baked into the code: t3.large at 0.0832 $/h, db.r6g.xlarge at 0.336, 730 hours to a month. Replace those constants before quoting numbers for any other provider, or the estimate is fiction.

Also inside: an autoscaling config with CPU triggers at 70% and 30%, a queue-depth trigger at 1000, min and max instance limits, and a pre-scale schedule for 08:00 and 22:00. Three infrastructure options run about $2,500, $5,000 and $10,000 a month, with a spreadsheet template for the growth table and a checklist of what the final plan should contain. The advice in the file is to start on the middle option and watch real metrics for a month.

What it helps with

  • size compute for a fivefold jump in daily users
  • estimate the monthly bill for compute, database, cache and bandwidth
  • set autoscaling thresholds on CPU and queue depth
  • compare a cost-optimized layout against a high-availability one
  • fill a capacity table for the next 6 and 12 months

Example prompts for the agent

  • Work out how many instances and cache nodes we need for 2500 peak RPS in 12 months.
  • Build the monthly AWS cost estimate from the skill's pricing and show where we can trim.
  • Set up autoscaling triggers at 70% and 30% CPU with a morning pre-scale schedule.

How to install capacity-planning-helper

1Skills CLI (Vercel)

npx skills add patricio0312rev/skills --skill capacity-planning-helper -a claude-code

2Manually: put the files in place

~/.claude/skills/capacity-planning-helper/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/capacity-planning-helper/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about capacity-planning-helper

How do I install capacity-planning-helper in Claude Code?

Run npx skills add patricio0312rev/skills --skill capacity-planning-helper -a claude-code; the skill lands at ~/.claude/skills/capacity-planning-helper/SKILL.md.

What does capacity-planning-helper do?

It converts a traffic forecast into resource counts for compute, database and cache, then prices them by the hour with AWS rates.

Does it work for clouds other than AWS?

The pricing in the examples uses AWS instance types (t3.large, db.r6g.xlarge, cache.r6g.large). Swap those numbers in estimateCost for another provider, otherwise the total is wrong.

Source text

SKILL.md · MIT
---
name: capacity-planning-helper
description: Estimates infrastructure needs based on traffic forecasts, workload analysis, and performance requirements with sizing recommendations and cost trade-offs. Use for "capacity planning", "infrastructure sizing", "resource estimation", or "scalability planning".
---

# Capacity Planning Helper

Right-size infrastructure for current and future needs.

## Traffic Forecasting

```typescript
interface TrafficForecast {
  current: {
    dailyUsers: number;
    peakRPS: number;
    avgRPS: number;
  };
  projected: {
    timeframe: "6m" | "12m" | "24m";
    dailyUsers: number;
    peakRPS: number;
    avgRPS: number;
    growthRate: number;
  };
}

const forecast: TrafficForecast = {
  current: {
    dailyUsers: 100000,
    peakRPS: 500,
    avgRPS: 200,
  },
  projected: {
    timeframe: "12m",
    dailyUsers: 500000, // 5x growth
    peakRPS: 2500,
    avgRPS: 1000,
    growthRate: 4.0, // 400% growth
  },
};
```

## Resource Estimation

```typescript
interface ResourceNeeds {
  compute: {
    instanceType: string;
    instanceCount: number;
    cpu: number;
    memory: number;
  };
  database: {
    instanceType: string;
    instanceCount: number;
    storage: number;
    iops: number;
  };
  cache: {
    instanceType: string;
    nodes: number;
    memory: number;
  };
}

function estimateResources(forecast: TrafficForecast): ResourceNeeds {
  const { peakRPS } = forecast.projected;

  // Rule of thumb: 100 RPS per instance (with headroom)
  const instanceCount = Math.ceil(peakRPS / 100);

  // Database: 1000 connections per 2vCPU
  const dbInstances = Math.ceil((peakRPS * 2) / 1000);

  return {
    compute: {
      instanceType: "t3.large",
      instanceCount: instanceCount * 1.5, // 50% headroom
      cpu: 2 * instanceCount,
      memory: 8 * instanceCount,
    },
    database: {
      instanceType: "db.r6g.xlarge",
      instanceCount: dbInstances,
      storage: 1000, // GB
      iops: 10000,
    },
    cache: {
      instanceType: "cache.r6g.large",
      nodes: 2, // Primary + replica
      memory: 12, // GB
    },
  };
}
```

## Cost Estimation

```typescript
interface CostEstimate {
  monthly: {
    compute: number;
    database: number;
    cache: number;
    storage: number;
    bandwidth: number;
    total: number;
  };
  annual: number;
}

const pricing = {
  "t3.large": 0.0832, // $/hour
  "db.r6g.xlarge": 0.336,
  "cache.r6g.large": 0.226,
  storage: 0.1, // $/GB/month
  bandwidth: 0.09, // $/GB
};

function estimateCost(
  resources: ResourceNeeds,
  trafficGB: number
): CostEstimate {
  const hoursPerMonth = 730;

  const monthly = {
    compute:
      resources.compute.instanceCount * pricing["t3.large"] * hoursPerMonth,
    database:
      resources.database.instanceCount *
      pricing["db.r6g.xlarge"] *
      hoursPerMonth,
    cache: resources.cache.nodes * pricing["cache.r6g.large"] * hoursPerMonth,
    storage: resources.database.storage * pricing.storage,
    bandwidth: trafficGB * pricing.bandwidth,
    total: 0,
  };

  monthly.total = Object.values(monthly).reduce((sum, cost) => sum + cost, 0);

  return {
    monthly,
    annual: monthly.total * 12,
  };
}
```

## Scale Triggers

```yaml
# auto-scaling-config.yml
scaling:
  triggers:
    - metric: cpu_utilization
      threshold: 70%
      action: scale_up
      cooldown: 5m

    - metric: cpu_utilization
      threshold: 30%
      action: scale_down
      cooldown: 15m

    - metric: request_queue_depth
      threshold: 1000
      action: scale_up
      cooldown: 1m

  limits:
    min_instances: 2
    max_instances: 20

  schedule:
    # Pre-scale for known traffic patterns
    - time: "08:00"
      target_instances: 10
    - time: "22:00"
      target_instances: 4
```

## Cost/Performance Tradeoffs

```markdown
# Infrastructure Options

## Option 1: Cost-Optimized ($2,500/mo)

- Compute: 4x t3.large
- Database: 1x db.r6g.large
- Cache: 1x cache.r6g.medium
- **Pros:** Lowest cost
- **Cons:** Limited headroom, potential latency issues

## Option 2: Balanced ($5,000/mo)

- Compute: 8x t3.large
- Database: 2x db.r6g.xlarge
- Cache: 2x cache.r6g.large
- **Pros:** Good headroom, redundancy
- **Cons:** Moderate cost

## Option 3: Performance-Optimized ($10,000/mo)

- Compute: 12x c6g.xlarge
- Database: 3x db.r6g.2xlarge
- Cache: 3x cache.r6g.xlarge
- **Pros:** Maximum performance, high availability
- **Cons:** Higher cost

## Recommendation

Start with Option 2, monitor for 1 month, adjust based on:

- Actual CPU/memory utilization
- Database query performance
- Cache hit rates
```

## Capacity Planning Spreadsheet

```
| Metric              | Current | 6mo Proj | 12mo Proj | Notes                    |
|---------------------|---------|----------|-----------|--------------------------|
| Daily Users         | 100k    | 250k     | 500k      | 5x growth expected       |
| Peak RPS            | 500     | 1250     | 2500      | Linear w/ users          |
| DB Connections      | 100     | 250      | 500       | 2 per instance           |
| Storage (GB)        | 100     | 300      | 1000      | User data + logs         |
| Bandwidth (TB)      | 1       | 3        | 10        | Images + video           |
| Instance Count      | 4       | 10       | 20        | Auto-scaling             |
| Monthly Cost        | $2k     | $5k      | $10k      | AWS estimate             |
```

## Output Checklist

- [ ] Traffic forecast
- [ ] Resource estimates
- [ ] Cost analysis
- [ ] Scale triggers
- [ ] Performance targets
- [ ] Growth plan
      ENDFILE

© patricio0312rev · MIT · patricio0312rev/skills

Similar skills

All skills for DevOps and infrastructure →

From the same set148

The whole set →
alerting-dashboard-builder alerting-dashboard-builder turns your service level objectives into Prometheus burn-rate alerts and a dashboard template, with runbook links and a first-response guide. CX Codex +1 266installs contract-testing-builder contract-testing-builder implements API contract testing with Pact, OpenAPI, and JSON Schema to catch breaking changes before deploying services. CX Codex +1 266installs rollback-workflow-builder rollback-workflow-builder builds deployment rollback workflows, runbooks, and recovery checks. Use it for production incidents or automatic recovery after a failed release. CX Codex +1 266installs vector-db-setup vector-db-setup sets up vector databases like Pinecone and Chroma with OpenAI embedding pipelines and similarity search queries for AI apps. CX Codex +1 266installs data-seeding-fixtures-builder data-seeding-fixtures-builder builds deterministic mock data, factory functions, realistic fixtures, and database reset scripts for testing environments. CX Codex +1 265installs docs-starter-kit docs-starter-kit generates documentation templates for open-source and internal codebases, including README, CONTRIBUTING, and security policies. CX Codex +1 265installs prompt-regression-tester prompt-regression-tester compares prompt revisions across structured test suites, detects regressions, and drafts targeted fixes. CX Codex +1 265installs release-automation-builder release-automation-builder is a Claude Code skill for automating releases and package publishing. It responds to requests about versioning, changelogs, or release workflows. CX Codex +1 265installs

Project sponsors

Companies that keep this analytics open