cost-knowledge

name: cost-knowledge description: Real pricing data for cloud compute, databases, LLM tokens, auth, payments, email, hosting, and monitoring services. Use when estimating infrastructure or operational costs.

Cost Knowledge

Real pricing data for cloud infrastructure, databases, LLM tokens, and third-party services. Use this data to produce grounded cost estimates. When data may be stale, use web search to verify current pricing.

Last verified: February 2026. Prices change — always present as approximate ranges and note that users should verify before committing.

Staleness note: The pricing data in this skill is a snapshot. Cloud providers, LLM vendors, and SaaS tools update pricing regularly. When generating cost estimates, use web search (if available via MCP) to verify current pricing for the key services. If web search is unavailable, state that prices are approximate and recommend the user verify at the provider's pricing page before committing.

Pricing Assumptions (CRITICAL)

All pricing in this skill assumes the following unless explicitly noted otherwise:

• Region: US East (N. Virginia) for AWS/Azure/GCP, US regions for other services
• OS: Linux for compute instances
• Billing: On-demand pricing (not reserved instances, spot instances, or annual contracts)
• Currency: USD, excludes taxes and VAT
• Data transfer: Excludes egress costs unless explicitly mentioned (egress can add 20-50% to costs)
• Pricing date: Snapshot from early 2025

These assumptions can cause 10-30% variance from actual costs.

When presenting pricing to users, ALWAYS:

1. Label costs as "planning estimates" or "approximate"
2. Mention region assumptions when relevant (e.g., "~$50/month in us-east-1")
3. Flag egress costs as additional where significant (S3, CloudFront, etc.)
4. Recommend verification at provider pricing pages before committing
5. Note that free tiers may require credit card verification or have time limits

Cloud Compute

AWS

GCP

Azure

Budget Hosting

Databases

LLM Token Pricing

Prices per million tokens (MTok).

Anthropic (Claude)

OpenAI

Google

Others

Token Cost Estimation Method

To estimate monthly LLM costs:

1. Estimate conversations per month (e.g., 1,000)
2. Estimate tokens per conversation: input (500-2,000) + output (500-2,000)
3. Calculate: conversations x tokens x price per token
4. Add overhead: system prompts, tool calls, retries (+20-30%)

Example: 1,000 conversations/mo x 2,000 input + 1,000 output tokens per conversation using Sonnet:

• Input: 1,000 x 2,000 / 1M x $3.00 = $6.00
• Output: 1,000 x 1,000 / 1M x $15.00 = $15.00
• Overhead (25%): $5.25
• Total: ~$26/mo

Auth Services

Payment Processors

Email & SMS

Monitoring & Error Tracking

Storage & CDN

Cost Presentation Rules

When presenting cost estimates, be thorough and comprehensive:

1. Infrastructure & Service Breakdown (MUST be detailed)

Format as a comprehensive table listing EVERY service:

Requirements:

• List EVERY service from the architecture (hosting, database, auth, storage, email, monitoring, payment, LLM, third-party APIs)
• Break down by clear categories (minimum 5-8 categories based on architecture)
• Show specific tier names (not just prices): "Vercel Hobby $0" not just "$0"
• Include what's included in each tier in Notes column
• Show monthly totals for each scenario (Low/Medium/High)
• Show first-year total for each scenario

2. Development Costs (MANDATORY section)

Always include development cost estimates based on complexity:

Time Estimation Formula:

• Simple projects (complexity 1-3): 2-6 weeks
• Moderate projects (complexity 4-6): 6-12 weeks
• Complex projects (complexity 7-8): 12-20 weeks
• Very complex projects (complexity 9-10): 20-30+ weeks

Rate Options (provide all three):

Calculation example for complexity 5 (moderate):

• Solo: 10-20 weeks × 40 hrs × $50-150 = $20,000 - $120,000
• Contractor: 10-20 weeks × 40 hrs × $75-200 = $30,000 - $160,000
• Agency: 10-20 weeks × 40 hrs × $150-300 = $60,000 - $240,000

Factors that increase development time (+20-50% each):

• Complex real-time features (WebSockets, live collaboration)
• Multi-tenancy with complex permission models
• Heavy data migration or integration with legacy systems
• Custom design system (not using component library)
• Advanced AI/ML features requiring training or fine-tuning
• High security/compliance requirements (SOC 2, HIPAA, PCI-DSS)

3. Cost Optimization Tips (minimum 5-7 specific tips)

Each tip MUST:

• Reference a specific service from the breakdown
• Include quantified savings where possible
• Be actionable (not generic advice)
• Be prioritized by impact (highest savings first)

Template for each tip:

✅ [Action to take]
   - Saves: $X/month or Y%
   - Effort: [hours/days]
   - Trade-off: [what you lose, if anything]
   - Example: [concrete implementation detail]

Example tips:

✅ Start on free tiers and upgrade only when you hit limits
   - Saves: $45-70/month initially
   - Effort: None (just don't upgrade prematurely)
   - Trade-off: May need to upgrade quickly if growth spikes
   - Example: Supabase free tier supports 50K MAU, Vercel Hobby supports unlimited bandwidth

✅ Batch email notifications instead of real-time
   - Saves: ~60% on email costs ($12-18/mo)
   - Effort: 2-3 hours to implement digest system
   - Trade-off: Notifications delayed by 15-30 minutes
   - Example: Instead of 10K individual emails, send 2K daily digests (500 users × 4 emails/day → 1 digest)

✅ Use Cloudflare R2 instead of AWS S3 for public assets
   - Saves: $50-200/mo on egress fees at 1TB/month traffic
   - Effort: 4-6 hours migration
   - Trade-off: Slightly smaller ecosystem than S3
   - Example: R2 has zero egress fees; S3 charges $90/TB

✅ Implement Redis caching for database queries
   - Saves: $30-100/mo by reducing database tier needed
   - Effort: 1-2 days implementation
   - Trade-off: Added complexity, cache invalidation logic
   - Example: Cache user profile queries (10K/day → 100/day DB hits) allows staying on $25 tier

✅ Use serverless functions instead of always-on containers
   - Saves: $30-70/mo for low-traffic APIs (<1M req/mo)
   - Effort: Depends on existing architecture
   - Trade-off: Cold start latency (100-500ms)
   - Example: Cloud Run with min instances = 0 costs only $5/mo vs $50/mo for always-on

✅ Limit file upload sizes and use compression
   - Saves: $20-50/mo on storage costs
   - Effort: 2 hours to implement limits + compression
   - Trade-off: User experience if limits too strict
   - Example: 10MB limit + image compression reduces 50GB/mo uploads to 20GB/mo

✅ Use cheaper LLM models for simple tasks
   - Saves: 70-90% on LLM costs
   - Effort: 4-8 hours to implement model routing
   - Trade-off: Slightly lower quality for simple tasks
   - Example: Use Haiku ($0.80/MTok) for classification, Sonnet ($3/MTok) for generation

4. Cost Risk Flags (MANDATORY)

Identify and explain services that can spike costs:

Pay-per-use traps (services where costs grow non-linearly):

• LLM token costs: Can explode with long contexts or infinite loops
• Email services: Notification storms can send thousands of emails
• SMS: Verification code spam or loops
• Database bandwidth: Large table scans or missing indexes
• Serverless invocations: Retry loops or webhook spam

Tier jump risks (services with large price jumps between tiers):

• MongoDB Atlas: M0 Free → M10 $57 (+$57)
• Supabase: Free → Pro $25 (+$25) → Team $599 (+$574!)
• Auth0: Free 25K MAU → Essentials $35 for 500 MAU (danger if you grow past 500)
• PlanetScale: Free → Scaler $39 (+$39)

Scale traps (services that get expensive at scale):

• Datadog: $15/host/mo becomes $1,500/mo at 100 hosts
• Sentry: Volume pricing above free tier
• Real-time database subscriptions: Cost grows with concurrent connections
• Video/image processing: Pay per transcode/operation

For each risk, provide:

• Why it's risky (specific scenario that triggers high cost)
• Typical cost at risk ($X/month if it happens)
• Mitigation strategy (rate limiting, caps, monitoring, alternative)
• Warning threshold (set alert at $X usage)

Example risk flag:

⚠️ LLM Token Cost Risk — High
   Scenario: User creates chatbot with 50K context window and 1M conversations/month
   Cost: Could reach $5,000-15,000/month vs expected $100/month
   Mitigation:
   - Implement context window limits (8K max)
   - Add rate limiting per user (10 requests/minute)
   - Use prompt caching (reduces input token costs by 90%)
   - Set billing alerts at $500, $1000, $2000
   Warning: Monitor token usage daily for first 2 weeks

5. Scale Warnings (REQUIRED if project targets 1K+ users)

Provide specific breakpoints where costs jump:

Format:

🚨 Scale Warning: [Service Name]

Current Tier: [Name] ($X/mo)
Limit: [Specific metric]
Expected to hit limit: [Timeline based on growth projection]
Next tier: [Name] ($Y/mo, +$Z)

Migration plan:
1. [First step before hitting limit]
2. [Second step]
3. [Upgrade trigger point]

Cost projection:
- Month 1-3: $X/mo (free/current tier)
- Month 4-6: $Y/mo (upgraded tier)
- Month 7-12: $Z/mo (scale tier)

Example:

🚨 Scale Warning: Supabase Database

Current Tier: Free ($0/mo)
Limits: 500MB database, 1GB file storage, 50K MAU
Expected to hit limit: Month 2-3 at 500 active users with file uploads
Next tier: Pro ($25/mo, includes 8GB database, 100GB storage)

Migration plan:
1. Set up database size monitoring (alert at 400MB)
2. Implement file cleanup policy (delete after 90 days)
3. Optimize database indexes and queries
4. Upgrade to Pro when database reaches 450MB or 40K MAU

Cost projection:
- Month 1-2: $0/mo (free tier)
- Month 3-6: $25/mo (Pro tier)
- Month 7-12: $25/mo (Pro tier sufficient for 10K users)
- Year 2+: Consider Team tier ($599/mo) if exceeding 100K MAU

6. Monthly vs Yearly Summary (REQUIRED)

Always provide both:

Include note about:

• Annual payment discounts (typically 15-20% savings)
• Which services offer annual plans
• Reserved instance savings for compute (AWS/GCP/Azure: 30-70% savings)

7. Total Cost of Ownership (TCO) Summary

Combine infrastructure + development + maintenance:

Year 1 Total Cost of Ownership

Development (one-time):
- Solo developer: $X - $Y
- Contractor: $X - $Y
- Agency: $X - $Y

Infrastructure (recurring):
- Months 1-12 average: $X/month = $Y/year

Maintenance (ongoing):
- Bug fixes + minor updates: 10-20% of development cost/year = $X - $Y/year
- Major feature additions: Budget $X - $Y/quarter

Year 1 TCO Range:
- Minimum (solo dev + free tiers): $X
- Typical (contractor + starter tiers): $Y
- Maximum (agency + production tiers): $Z