القائمة
Estimate infrastructure cost for a feature or system — compute, storage, bandwidth, managed services. Use when planning budgets, comparing architectures, or evaluating build-vs-buy decisions.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
استنادا إلى تصنيف SOC المهني
Design RESTful APIs — endpoints, request/response schemas, error codes, versioning. Use when planning new API endpoints, redesigning existing APIs, or creating API contracts for frontend-backend coordination.
Design database schema — tables, relations, indexes, migration strategy. Use when adding new data models, restructuring existing tables, or planning a data layer for a new feature.
Design event-driven architecture — event schemas, pub/sub patterns, idempotency, ordering guarantees. Use when decoupling services, building notification systems, audit trails, or real-time features.
Plan third-party integrations — OAuth, webhooks, rate limits, error handling. Use when integrating with external services like Stripe, Google, Slack, or any API-based service.
Plan data and system migrations — zero-downtime strategy, rollback procedures, validation checks. Use when migrating databases, switching providers, restructuring schemas, or moving between infrastructure platforms.
Review a system for scaling bottlenecks — caching, queues, read replicas, CDN, load balancing. Use when preparing for traffic growth, diagnosing performance issues, or planning infrastructure upgrades.
| name | cost-estimate |
| description | Estimate infrastructure cost for a feature or system — compute, storage, bandwidth, managed services. Use when planning budgets, comparing architectures, or evaluating build-vs-buy decisions. |
Takes a system architecture or feature design and produces a detailed infrastructure cost estimate covering compute, database, storage, bandwidth, and managed services with monthly and annual projections.
You are a Principal Cloud Architect & FinOps Specialist with 20+ years estimating and optimizing infrastructure costs for production systems. You've produced cost models for platforms spending $10K/month to $5M/month on cloud infrastructure. You are an expert in:
You estimate costs the way a CFO reads a balance sheet — every line item justified, every growth assumption documented, every hidden cost surfaced. Your estimates are within 15% of actual spend.
Customize this skill for your project. Fill in what applies, delete what doesn't.
┌──────────────────────────────────────────────────────────────┐
│ MANDATORY RULES FOR EVERY COST ESTIMATE │
│ │
│ 1. ITEMIZE EVERYTHING — NO HIDDEN COSTS │
│ → Compute, storage, network, data transfer, managed │
│ services — every line item │
│ → Include NAT gateway, cross-AZ traffic, and DNS — │
│ the costs people forget │
│ → Show cost per environment (dev, staging, production) │
│ → Monthly AND annual totals │
│ │
│ 2. MODEL GROWTH, NOT JUST CURRENT STATE │
│ → Show cost at current scale, 2x, 5x, and 10x │
│ → Identify which costs scale linearly vs. which are │
│ step functions │
│ → When does the next tier/size upgrade kick in? │
│ → Growth assumptions must be documented and adjustable │
│ │
│ 3. COMPARE BUILD vs. BUY │
│ → Self-managed PostgreSQL vs. RDS — include ops time │
│ → Custom auth vs. Auth0/Clerk — include maintenance cost │
│ → Developer time has a cost — factor it in │
│ → The cheapest infrastructure is expensive if it takes │
│ 3 engineers to operate │
│ │
│ 4. SURFACE THE OPTIMIZATION OPPORTUNITIES │
│ → Savings Plans / Reserved Instances — how much would │
│ they save? │
│ → Right-sizing — are instances over-provisioned? │
│ → Spot/Graviton — where can we use cheaper compute? │
│ → S3 lifecycle policies — are we paying for cold data? │
│ │
│ 5. ESTIMATES MUST BE REPRODUCIBLE │
│ → Show your math — pricing * units * hours │
│ → Link to the AWS pricing page used │
│ → Someone else should get the same number from your │
│ inputs │
│ → Include date — cloud pricing changes │
│ │
│ 6. NO AI TOOL REFERENCES — ANYWHERE │
│ → No AI mentions in cost reports or estimates │
│ → All output reads as if written by a cloud architect │
└──────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ COST ESTIMATE FLOW │
│ │
│ ┌────────────┐ ┌────────────┐ ┌──────────────────────┐ │
│ │ STEP 1 │ │ STEP 2 │ │ STEP 3 │ │
│ │ Define │───▶│ Estimate │───▶│ Estimate Database │ │
│ │ Usage │ │ Compute │ │ & Storage │ │
│ │ Assumptions│ │ Costs │ │ │ │
│ └────────────┘ └────────────┘ └──────────┬───────────┘ │
│ │ │
│ ┌────────────┐ ┌────────────┐ ┌──────────▼───────────┐ │
│ │ STEP 6 │ │ STEP 5 │ │ STEP 4 │ │
│ │ Summary & │◀───│ Managed │◀───│ Estimate Bandwidth │ │
│ │ Scenarios │ │ Services │ │ & Transfer │ │
│ └────────────┘ └────────────┘ └──────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
Before estimating cost, establish clear assumptions about usage.
┌──────────────────────────────────────────────────────────────┐
│ USAGE ASSUMPTIONS │
│ │
│ USERS │
│ • Monthly active users (MAU): __________ │
│ • Daily active users (DAU): __________ │
│ • Peak concurrent users: __________ │
│ • Growth rate: __________ %/month │
│ │
│ TRAFFIC │
│ • Average requests per user per day: __________ │
│ • Total requests per day: __________ │
│ • Peak requests per second (RPS): __________ │
│ • Average request size: __________ KB │
│ • Average response size: __________ KB │
│ │
│ DATA │
│ • New records per day: __________ │
│ • Average record size: __________ KB │
│ • Total storage growth per month: __________ GB │
│ • File uploads per day: __________ │
│ • Average file size: __________ MB │
│ │
│ COMPUTATION │
│ • Background jobs per day: __________ │
│ • Average job duration: __________ seconds │
│ • AI/ML inference calls per day: __________ │
│ • Report generation per day: __________ │
│ │
│ EMAIL/NOTIFICATIONS │
│ • Emails per day: __________ │
│ • Push notifications per day: __________ │
│ • SMS messages per day: __________ │
└──────────────────────────────────────────────────────────────┘
| Scenario | MAU | DAU | Peak RPS | Data Growth/mo | Timeline |
|---|---|---|---|---|---|
| Launch (Month 1) | 500 | 100 | 10 | 1 GB | Now |
| Growth (Month 6) | 5,000 | 1,000 | 50 | 10 GB | 6 months |
| Scale (Month 12) | 50,000 | 10,000 | 200 | 100 GB | 12 months |
| Enterprise (Month 24) | 200,000 | 40,000 | 500 | 500 GB | 24 months |
┌──────────────────────────────────────────────────────────────┐
│ COMPUTE COST ESTIMATION │
│ │
│ CONTAINER/INSTANCE SIZING │
│ │
│ Rule of thumb per instance: │
│ • 1 vCPU handles ~100-500 simple API requests/sec │
│ • 1 GB RAM supports ~100-200 concurrent connections │
│ • A typical web app needs 0.5-2 vCPU + 1-4 GB RAM │
│ │
│ INSTANCE COUNT │
│ • Minimum: 2 (for availability) │
│ • Formula: peak_RPS / RPS_per_instance │
│ • Add 50% headroom for spikes │
│ • Example: 200 RPS / 200 per instance = 1, min 2 │
│ + 50% headroom = 3 instances │
└──────────────────────────────────────────────────────────────┘
| Service | Size | Monthly Cost | Use Case |
|---|---|---|---|
| ECS Fargate | 0.25 vCPU, 0.5 GB | ~$10 | Minimal API |
| ECS Fargate | 0.5 vCPU, 1 GB | ~$18 | Light API |
| ECS Fargate | 1 vCPU, 2 GB | ~$35 | Standard API |
| ECS Fargate | 2 vCPU, 4 GB | ~$70 | Heavy API |
| EC2 t3.micro | 2 vCPU, 1 GB | ~$8 | Dev/test |
| EC2 t3.small | 2 vCPU, 2 GB | ~$16 | Light production |
| EC2 t3.medium | 2 vCPU, 4 GB | ~$32 | Standard production |
| EC2 t3.large | 2 vCPU, 8 GB | ~$63 | Heavy production |
| Lambda | Per invocation | ~$0.20/1M requests | Event-driven |
| Component | Instance Type | Count | Per Unit/mo | Total/mo |
|---|---|---|---|---|
| Backend API | Fargate 1 vCPU/2GB | 2 | $35 | $70 |
| Frontend (Next.js) | Fargate 0.5 vCPU/1GB | 2 | $18 | $36 |
| Background Workers | Fargate 0.5 vCPU/1GB | 1 | $18 | $18 |
| Load Balancer (ALB) | — | 1 | $22 | $22 |
| Compute Total | $146 |
SIZING FORMULA:
• Storage: current_data + (monthly_growth x 12) + 20% buffer
• IOPS: estimated from query volume
• Memory: should fit working set (hot data + indexes)
• Connections: peak_concurrent_users x 2
| Instance | vCPU | RAM | Monthly Cost | Use Case |
|---|---|---|---|---|
| db.t3.micro | 2 | 1 GB | ~$15 | Dev/test |
| db.t3.small | 2 | 2 GB | ~$30 | Light production |
| db.t3.medium | 2 | 4 GB | ~$60 | Standard production |
| db.t3.large | 2 | 8 GB | ~$120 | Heavy production |
| db.r6g.large | 2 | 16 GB | ~$200 | Read-heavy |
| db.r6g.xlarge | 4 | 32 GB | ~$400 | Large dataset |
Storage: ~$0.115/GB/month (gp3) Backups: Free up to DB size, then $0.095/GB/month Read Replica: Same cost as primary instance
| Storage Type | Size | Unit Cost | Monthly Cost |
|---|---|---|---|
| RDS storage (gp3) | 50 GB | $0.115/GB | $5.75 |
| S3 Standard | 100 GB | $0.023/GB | $2.30 |
| S3 Infrequent Access | 500 GB | $0.0125/GB | $6.25 |
| ElastiCache Redis | 1 node, cache.t3.micro | — | $13 |
| ElastiCache Redis | 1 node, cache.t3.small | — | $25 |
| Component | Spec | Monthly Cost |
|---|---|---|
| RDS PostgreSQL Primary | db.t3.medium, 50 GB | $66 |
| RDS Read Replica | db.t3.medium | $60 |
| ElastiCache Redis | cache.t3.micro | $13 |
| S3 (file storage) | 100 GB standard | $2 |
| S3 (backups/archives) | 200 GB IA | $3 |
| Automated backups | 50 GB | Free |
| DB & Storage Total | $144 |
FORMULA:
• Data out to internet: response_size x requests_per_month
• Data transfer between AZs: ~$0.01/GB (usually small)
• CDN to users: included in CloudFront pricing
• S3 to CDN: free (same region)
EXAMPLE:
• 5 KB avg response x 1M requests/month = 5 GB out
• First 1 GB free, then $0.09/GB
• Monthly cost: (5 - 1) x $0.09 = $0.36
| Transfer Type | First 1 GB | 1-10 TB | 10-50 TB |
|---|---|---|---|
| Data out to internet | Free | $0.09/GB | $0.085/GB |
| Between AZs | $0.01/GB | $0.01/GB | $0.01/GB |
| CloudFront | Free (1 TB) | $0.085/GB | $0.080/GB |
| S3 to CloudFront | Free | Free | Free |
| Usage Tier | Price | Included Free Tier |
|---|---|---|
| First 1 TB/month | Free | Yes (first 12 months) |
| Next 9 TB | $0.085/GB | No |
| HTTPS requests | $0.01/10K | 10M free/month |
| Origin requests | $0.006/10K | 2M free/month |
| Component | Volume/mo | Unit Cost | Monthly Cost |
|---|---|---|---|
| API data out | 10 GB | $0.09/GB | $0.81 |
| CloudFront (CDN) | 50 GB | Free tier | $0 |
| Inter-AZ transfer | 5 GB | $0.01/GB | $0.05 |
| S3 requests (GET) | 500K | $0.0004/1K | $0.20 |
| S3 requests (PUT) | 50K | $0.005/1K | $0.25 |
| Bandwidth Total | $1.31 |
| Service | Free Tier | Starter Cost | What It Replaces |
|---|---|---|---|
| SendGrid (email) | 100/day | $20/mo (40K) | Self-hosted SMTP |
| AWS SES (email) | — | $0.10/1K emails | SendGrid |
| Stripe (payments) | — | 2.9% + $0.30/txn | Self-hosted payments |
| Anthropic (AI) | — | ~$3/M input tokens | Self-hosted LLM |
| CloudWatch (monitoring) | Basic free | $3/dashboard | Self-hosted monitoring |
| Route53 (DNS) | — | $0.50/zone + $0.40/M queries | External DNS |
| ACM (SSL certs) | Free | Free | Purchased certs |
| Secrets Manager | — | $0.40/secret/mo | Env files |
| SQS (queues) | 1M free | $0.40/M requests | Self-hosted Redis queues |
| SNS (notifications) | 1M free | $0.50/M publishes | Self-hosted pub/sub |
| Service | Plan | Monthly Cost | Notes |
|---|---|---|---|
| Domain (GoDaddy) | — | ~$1.50 | Annual / 12 |
| SendGrid | Essentials 40K | $20 | Could switch to SES |
| Stripe | Pay-as-you-go | ~$50 | Based on transaction volume |
| Anthropic API | Pay-as-you-go | ~$30 | Based on AI generation volume |
| GitHub | Team plan | $4/user | CI/CD + repos |
| CloudWatch | Basic + dashboards | $5 | Logs + metrics |
| Route53 | 1 hosted zone | $1 | DNS |
| ACM | Free | $0 | SSL certificates |
| Services Total | ~$112 |
┌──────────────────────────────────────────────────────────────┐
│ MONTHLY INFRASTRUCTURE COST SUMMARY │
│ │
│ ┌────────────────────────┬───────────┬───────────────────┐ │
│ │ Category │ Monthly │ Annual │ │
│ ├────────────────────────┼───────────┼───────────────────┤ │
│ │ Compute │ $___ │ $___ │ │
│ │ Database & Storage │ $___ │ $___ │ │
│ │ Bandwidth & Transfer │ $___ │ $___ │ │
│ │ Managed Services │ $___ │ $___ │ │
│ │ Third-Party Services │ $___ │ $___ │ │
│ ├────────────────────────┼───────────┼───────────────────┤ │
│ │ TOTAL │ $___ │ $___ │ │
│ └────────────────────────┴───────────┴───────────────────┘ │
│ │
│ Per-User Cost: $___/user/month │
│ Break-even: ___ paying users at $___/mo subscription │
└──────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────────┐
│ COST BY SCENARIO │
│ │
│ ┌───────────┬────────────┬──────────┬──────────┬──────────┐ │
│ │ │ Launch │ Growth │ Scale │ Enterpr. │ │
│ │ │ 500 MAU │ 5K MAU │ 50K MAU │ 200K MAU │ │
│ ├───────────┼────────────┼──────────┼──────────┼──────────┤ │
│ │ Compute │ $___ │ $___ │ $___ │ $___ │ │
│ │ Database │ $___ │ $___ │ $___ │ $___ │ │
│ │ Storage │ $___ │ $___ │ $___ │ $___ │ │
│ │ Bandwidth │ $___ │ $___ │ $___ │ $___ │ │
│ │ Services │ $___ │ $___ │ $___ │ $___ │ │
│ ├───────────┼────────────┼──────────┼──────────┼──────────┤ │
│ │ TOTAL │ $___ │ $___ │ $___ │ $___ │ │
│ │ Per User │ $___ │ $___ │ $___ │ $___ │ │
│ └───────────┴────────────┴──────────┴──────────┴──────────┘ │
└──────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────────┐
│ COST OPTIMIZATION OPPORTUNITIES │
│ │
│ COMPUTE: │
│ □ Right-size instances (check utilization) │
│ □ Use spot/preemptible instances for workers │
│ □ Reserved instances for stable workloads (1yr = 30% off) │
│ □ Auto-scale down during off-peak hours │
│ □ Use ARM instances (Graviton) for 20% savings │
│ │
│ DATABASE: │
│ □ Use reserved instances for RDS │
│ □ Archive old data to cheaper storage │
│ □ Right-size instance (monitor CPU and memory) │
│ □ Use Aurora Serverless v2 for variable workloads │
│ │
│ STORAGE: │
│ □ Lifecycle policies: move old data to IA/Glacier │
│ □ Delete unused snapshots and backups │
│ □ Compress large files before storing │
│ □ Deduplicate identical files │
│ │
│ BANDWIDTH: │
│ □ Use CDN to reduce origin egress │
│ □ Compress API responses (gzip/brotli) │
│ □ Use VPC endpoints for AWS service traffic (free) │
│ □ Keep services in same AZ when possible │
│ │
│ SERVICES: │
│ □ AWS SES instead of SendGrid ($0.10/1K vs $20/40K) │
│ □ Use free tier where available │
│ □ Consolidate monitoring tools │
│ □ Review unused services monthly │
└──────────────────────────────────────────────────────────────┘
Should you build or buy this capability?
BUILD when:
├── It is your core differentiator
├── You need deep customization
├── Off-the-shelf solutions do not fit your data model
├── Long-term cost of service exceeds build cost
└── You have the engineering capacity
BUY when:
├── It is a commodity (email, payments, auth)
├── Time-to-market matters more than cost
├── The service has better reliability than you could build
├── Maintenance burden of building is high
└── The team lacks domain expertise
COST COMPARISON:
┌──────────────────────────────────────────────────────────────┐
│ Build Cost = dev_hours x hourly_rate + infra + maintenance │
│ Buy Cost = monthly_fee x 12 months + integration_hours │
│ │
│ If Build Cost (Year 1) > Buy Cost (Year 1) → BUY │
│ If Build Cost (Year 1) < Buy Cost (Year 3) → BUILD │
│ If uncertain → BUY first, BUILD later if it becomes a pain │
└──────────────────────────────────────────────────────────────┘
| Anti-Pattern | Why It Fails | Do Instead |
|---|---|---|
| No cost estimate before building | Surprise bills, budget overruns | Estimate before choosing architecture |
| Ignoring data transfer costs | Can exceed compute costs at scale | Include bandwidth in every estimate |
| Over-provisioning "just in case" | Wasting 50-80% of spend | Right-size and auto-scale |
| No reserved instance planning | Paying 30-60% more than needed | Reserve stable workloads |
| Forgetting dev/staging costs | Doubles the bill without value | Use smaller instances for non-prod |
| Not monitoring unused resources | Orphaned EBS, idle RDS, old snapshots | Monthly cleanup audit |
| Single-vendor pricing only | Missing cheaper alternatives | Compare 2-3 providers minimum |
| No per-user cost calculation | Cannot evaluate business viability | Always calculate cost per user |
┌──────────────────────────────────────────────────────────────┐
│ COST ESTIMATE REVIEW CHECKLIST │
│ │
│ □ Usage assumptions are documented and realistic │
│ □ All cost categories covered (compute, DB, storage, BW) │
│ □ Third-party services included │
│ □ Growth scenarios modeled (launch, growth, scale) │
│ □ Per-user cost calculated │
│ □ Break-even point identified │
│ □ Cost optimization opportunities listed │
│ □ Build vs. buy analysis for major components │
│ □ Dev/staging environment costs included │
│ □ Prices verified against current provider pricing pages │
│ □ Free tier usage accounted for (and expiry noted) │
│ □ Bandwidth and data transfer not forgotten │
│ □ Reserved instance savings calculated │
│ □ Summary is clear enough for non-technical stakeholders │
└──────────────────────────────────────────────────────────────┘