workflow-cost-estimator

name: workflow-cost-estimator description: Calculates the realistic monthly cost envelope for a workflow design including LLM tokens, third-party API spend, compute/queue infrastructure, and per-vendor pricing tiers. Use before committing to an engine or before a workflow ships to production short_desc: monthly cost envelope for workflow + LLM + infrastructure keywords: [cost envelope, monthly cost, token budget, vendor pricing, compute cost, "LLM cost", "cost of this workflow", "how much will this cost", "pricing for", "LLM cost estimate", "infra cost"] model: opus effort: high

Workflow Cost Estimator (Opus)

Purpose: Calculate the realistic monthly cost of a workflow BEFORE it ships, so the team knows what they're committing to. Covers LLM tokens, third-party API spend, workflow-engine cost, queue/storage cost. Outputs an envelope at current volume and at 10x scale, with sensitivity analysis on the biggest line items.

Model: Opus 4.7

Why this skill exists

Automation engineers regularly ship workflows that look fine in dev (10 events/day) and become the company's biggest cloud line item at production scale (10M events/day). The math is straightforward but the inputs are non-obvious — a half-hour cost model up front avoids quarter-million dollar surprises in Q3.

When to invoke autonomously

Invoke when:

1. Before engine choice: comparing Zapier vs. n8n vs. Temporal vs. Inngest at the design's expected volume.
2. Before launch: a workflow design exists; need a sanity check on the cost envelope.
3. After an incident: bill spike investigation — what step is driving it?
4. Quarterly review: project workflows running > 6 months, model their current and growth-projected cost.

Don't invoke for:

• Single API call wrappers (no meaningful cost model).
• Internal infra cost (use FinOps tooling).

Usage

/workflow-cost-estimator estimate [workflow design path]
/workflow-cost-estimator compare engines for [volume / requirements]
/workflow-cost-estimator audit [workflow] - find biggest line items

Inputs the skill needs

Required:

1. Volume: events per day at launch + projected growth (3, 6, 12 months).
2. Steps: each step's nature (LLM call, external API, internal DB write, queue, etc.).
3. LLM steps: model, average input tokens, average output tokens per call.
4. External API steps: provider, pricing tier, expected calls per workflow.
5. Engine choice: workflow engine + pricing model.

Ask for these explicitly if missing. Don't make up numbers; a confident wrong estimate is worse than no estimate.

Cost components

1. LLM cost (often dominant in modern workflows)

Cost per call = (input_tokens × input_price_per_M) + (output_tokens × output_price_per_M)
Monthly cost = Cost per call × calls per day × 30

Reference prices (2026-05; verify current via provider docs before quoting):

*Cached input refers to prompt caching where supported (Anthropic, OpenAI). Materially changes cost if your prompt has a large stable prefix (system prompt + few-shot examples).

Compute the realistic cost:

• Use AVERAGE tokens, not minimum.
• Add 20-30% for validation-correction round trips (see knowledge/concepts/function-calling-reliability-patterns.md).
• Apply prompt-caching discount IF the prompt has a stable prefix > 1024 tokens.
• For batch APIs: 50% discount but ~24h latency — only model if the workflow tolerates it.

Batch API note: Anthropic and OpenAI both offer ~50% discount for batched requests with deferred completion. Use for non-realtime workflows (nightly extraction, etc.).

2. Workflow engine cost

Decision pattern: at <1K runs/day, managed SaaS (Zapier/Make) is fine; at 10K+/day, self-host or use Temporal Cloud/Inngest; at 100K+/day, self-host is almost certainly cheapest.

3. Third-party API spend

For each external API call, note the provider's pricing:

Watch for:

• Per-event provider markups (Twilio per-segment counting, SMS over 160 chars splits).
• Currency conversion fees (Stripe charges 1% on cross-currency).
• Search/AI API per-query pricing (Algolia, Pinecone, OpenAI embeddings).

4. Infra cost

5. Hidden costs

• Retries: a workflow with 4-attempt retry policy on 1% failures consumes ~1.04× the base cost. Usually negligible UNLESS the retries hit expensive steps (LLM, paid API).
• Idempotency-key storage: Redis lookups cost almost nothing; Postgres rows for audit cost more (~1 KB each × N events × retention).
• Logs / traces: at scale, observability is often 10-20% of total infra cost.
• Dead-letter inspection / replay: ops engineering time, real but often unbudgeted.

The deliverable

Produce a markdown report:

# Workflow Cost Estimate: {name}

## Volume Assumptions
- Today: {N} events/day
- 3 months: {N×1.5} events/day
- 6 months: {N×3} events/day
- 12 months: {N×10} events/day

## Per-event breakdown (today's volume)

| Step | Type | Cost per event | Notes |
|---|---|---|---|
| Webhook receive | infra | $0.0000001 | nginx + worker |
| Validate signature | compute | $0.0000001 | inline, <1ms |
| Idempotency check | Redis | $0.000001 | 1 GET + 1 SET |
| LLM classification (Haiku) | LLM | $0.00012 | 100 tok in + 50 tok out |
| External API call (HubSpot) | external | $0 | within plan |
| LLM extraction (Sonnet, with 1.2× correction multiplier) | LLM | $0.018 | 5K tok in + 500 tok out × 1.2 |
| DB write | infra | $0.0000001 | Postgres write |
| Slack post | external | $0 | within free tier |
| **Total per event** | | **$0.01813** | |

## Monthly cost at each volume tier

| Volume | LLM | Engine | Third-party | Infra | **Total/month** |
|---|---|---|---|---|---|
| 10K/day | $5,439 | $150 (Temporal Cloud) | $0 | $100 | **$5,689** |
| 100K/day | $54,390 | $1,500 | $20 (SendGrid) | $400 | **$56,310** |
| 1M/day | $543,900 | $15,000 | $200 (SendGrid) | $2,000 | **$561,100** |

## Sensitivity analysis

What moves the bill most?

1. **LLM extraction step (96% of cost)**: dropping from Sonnet to Haiku for routine cases saves ~75% on this line item → $4,080/mo at 10K/day.
2. **Validation-correction multiplier**: tightening prompt + schema to reduce 1.2× to 1.05× saves ~12% → $650/mo.
3. **Engine choice**: Temporal Cloud vs. self-hosted at 10K/day = $150 vs. $50 = small. At 1M/day = $15K vs. $200 = huge — invest in self-hosting.
4. **Prompt caching**: if the system prompt is stable, cached input is ~90% cheaper. Estimated savings: $1,500/mo at 10K/day.

## Recommendations

1. Add a Haiku-first classifier to route easy cases away from Sonnet extraction → $4K/mo savings.
2. Enable prompt caching on the Sonnet step → $1.5K/mo savings.
3. Build out self-hosted Temporal before 100K/day volume → avoid Temporal Cloud bill scaling.
4. Tighten extraction schema to reduce correction loops → $650/mo.
5. Add a "circuit breaker" on the extraction step: if cost-per-day > $250 (50% buffer), alert and degrade to cheaper model.

## Open questions

- Confirm assumed average input size for the extraction step (5K tokens). If realistic 8K, cost rises 60%.
- Confirm correction-loop rate via offline eval — currently estimated at 20%.
- Will the volume actually grow 10× in 12 months, or is that pessimistic? (If realistic 3×, the self-hosting investment can wait.)

Common errors to flag

• Using minimum tokens instead of average — model the realistic case, not the lucky one.
• Forgetting validation/correction multiplier — easy 10-30% miss.
• Ignoring prompt caching when applicable — overstates cost.
• Pricing Zapier at "task" cost when each workflow has 5 steps — Zapier charges per step, not per workflow.
• Forgetting batch-API discount where applicable — non-realtime extraction can be 50% cheaper.
• Underestimating retry-on-transient-failure cost — usually small but verify on expensive steps.
• Not accounting for backfill / one-time migration runs — a one-week catch-up can be 10× the steady-state monthly bill.

Tooling

For ongoing tracking, recommend:

• LLM provider dashboards (Anthropic Console, OpenAI usage) — daily review.
• Self-built costs.jsonl (the orchestrator's cost tracker is one example) — per-call cost per workflow_id.
• Cloud cost alerts (AWS Budgets, GCP Budget Alerts) — fire at 50%, 80%, 100% of expected.

Knowledge graph integration

After estimating, write a project node knowledge/projects/cost-{workflow}.md with the assumptions, the estimate, and the date. Re-estimate every 90 days; track drift.

Knowledge Systems

Full reference: ~/.claude/shared/KNOWLEDGE_SYSTEMS.md

Decision tree:

• Known terms → kg-search CLI
• Conceptual → hybrid_search MCP
• Relationships → semantic_graph_search MCP
• Code by purpose → search_code_graph MCP
• Literal strings → Grep

Success metrics

• Estimate uses average (not minimum) token counts and call rates.
• Validation-correction multiplier applied where LLMs are involved.
• 10× volume scenario modelled — surfaces engine-choice break-even points.
• Sensitivity analysis identifies the top 3 cost drivers.
• Concrete optimisation recommendations with dollar amounts attached.
• Open questions flagged where assumptions could materially move the number.