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
npx skills add patricio0312rev/skills --skill capacity-planning-helper -a claude-codeWhat 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-code2Manually: put the files in place
~/.claude/skills/capacity-planning-helper/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/capacity-planning-helper/
1Skills CLI (Vercel)
npx skills add patricio0312rev/skills --skill capacity-planning-helper -a codex2Manually: put the files in place
.agents/skills/capacity-planning-helper/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add patricio0312rev/skills --skill capacity-planning-helper -a cursor2Manually: put the files in place
.cursor/skills/capacity-planning-helper/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install patricio0312rev/skills performance/capacity-planning-helper/SKILL.md2Manually: put the files in place
.github/skills/capacity-planning-helper/SKILL.md1Skills CLI (Vercel)
npx skills add patricio0312rev/skills --skill capacity-planning-helper -a gemini-cli2Platform CLI
gemini skills install https://github.com/patricio0312rev/skills --path performance/capacity-planning-helperManually: put the files in place
.devin/skills/capacity-planning-helper/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add patricio0312rev/skills --skill capacity-planning-helper -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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