A founder walks into a vendor scoping call without a number. The vendor produces one — and the entire conversation pivots around defending or discounting the vendor’s quote rather than the founder’s scope. That sequence is the most expensive mistake at the procurement stage. The fix is to walk in with your own number — not a guess, not a vendor’s marketing-page range, but a defensible estimate built from five inputs that you control. This calculator does exactly that: five inputs, a $60K baseline, additive math you can audit in your head, and three worked examples that show why the same idea produces $60K, $115K, or $215K depending on scope.
It pairs with the AI MVP economics playbook, which describes the cost lines; this article is the calculator that turns those lines into one number. Both sit within the idea-to-product manifesto, the master guide for non-engineer founders shipping AI products in 2026.
Why the standard MVP calculator breaks for AI
The standard SaaS MVP calculator asks two questions: how many features, and how complex. It multiplies feature count by hours-per-feature, multiplies hours by a blended rate, and adds a 20% buffer. That math worked for a 2018 web MVP because the cost lines were deterministic.
It is wrong for a 2026 AI MVP for one structural reason: the dominant cost line is no longer code, it is evals. McKinsey’s State of AI survey has tracked that roughly 80–85% of AI pilots stall before reaching production. The pilots that stall did not fail at the code line — they failed at the eval line, because the build shipped against an eyeball test rather than a graded representative sample. A calculator that ignores eval discipline funds a prototype and misses the artifact that lets it ship.
A defensible 2026 calculator starts at a baseline that already includes the eval contract and names five inputs that move the price for structural reasons (not feature count). Each input maps to a discrete cost line in the economics playbook: capability count drives the build line, users target drives the integration line, eval tier drives the eval-engineering line, fallback complexity drives the architecture line, and on-call window drives the hardening line.
The $60K baseline — what is always in the price
Every defensible AI MVP starts at $60K in 2026 market terms. The baseline is not a discount; it is the floor below which the build stops being a defensible MVP and becomes a prototype. The $60K covers:
| Baseline line | Spend | What it buys |
|---|---|---|
| Discovery + scoping workshop | $4,500 | A 2-page scoping memo naming the capability, the workflow, the success criterion, and the explicit exclusion list. |
| Eval-bound PRD | $7,500 | A 6–8 page PRD with an eval-contract appendix — the rubric the build will be graded against. |
| Architecture decision record | $2,500 | One page naming prompt-only / retrieval-augmented / agentic / fine-tuned, with trade-offs and cost band. |
| Build (one capability, prompt + light retrieval) | $14,000 | Prompt scaffolding, structured-output schemas, error handling, model-layer integration. |
| Eval set curation | $6,000 | 100–200 founder-curated representative inputs against the buyer’s actual workload distribution. |
| Eval harness | $5,500 | Runnable script that loads the eval set, calls the build, captures outputs, writes graded results. |
| Eval grading + iteration loop | $7,500 | Three iteration cycles across weeks 3–5, founder + fractional eval partner. |
| Minimal UI | $4,500 | A Next.js page or thin web app where a user enters input and inspects output. |
| Handoff package | $3,000 | README, runbook covering the three likeliest failure modes, prompt files, eval CSV. |
| Inference + infra (6-week build window) | $5,000 | Frontier-model API calls during build and eval iteration; vector store and embeddings if retrieval-augmented. |
| Baseline total | $60,000 | One capability, one integration surface, founder co-authorship, 6-week window, no on-call. |
The baseline is the same scope the $75K anatomy piece names at $74,800 — minus the integration layer (this calculator treats integration as an additive input). If a vendor proposal comes in below $60K for a defensible build, the line cut is almost certainly the eval contract.
Input 1 — Capability count
Question: How many distinct AI capabilities does the MVP need to prove?
A capability is one end-to-end AI workflow step graded against a written rubric (triage is one; summarization is another). The baseline funds one. Each additional capability adds a build line and a separate eval set.
| Capabilities | Add to baseline |
|---|---|
| 1 (baseline) | +$0 |
| 2 | +$18,000 |
| 3 | +$32,000 |
| 4+ | Escalate — the scope is no longer an MVP |
The second capability is cheaper than the first ($18K vs the $14K build line plus its eval lines) because it shares the discovery, PRD, architecture decision, and infra baseline. Most defensible MVPs at the 6-week timeline have one capability; two capabilities push the timeline to 8–10 weeks.
Input 2 — Users target
Question: Who is the MVP shipping to inside the 6-week window?
This input drives the integration layer, the auth requirements, and the data-isolation surface. The baseline assumes the founder and a small internal team are the only users.
| Users target | Add to baseline |
|---|---|
| Internal only (founder + 1–3 teammates) | +$0 |
| Single design-partner customer (single-tenant) | +$8,500 |
| 5–20 design-partner customers (light multi-tenant) | +$22,000 |
| Public launch (multi-tenant, auth, customer isolation) | Escalate — not an MVP scope |
Single design-partner adds $8.5K for real auth, customer-specific data isolation, and an integration to the partner’s existing tool (CRM, document store, ticketing). Light multi-tenant at 5–20 customers adds $22K for per-customer logging and the operational surface to onboard each one in under a day. A public launch is not an MVP scope — it is a productionized application.
Input 3 — Eval tier
Question: How structured does the eval discipline need to be?
The baseline funds a founder-graded eval set (Tier 1). Higher tiers add automated grading and regression gates that catch model-alias drift. The decoding-cost-per-query piece explains why eval tier becomes a unit-economics question once the MVP serves real users.
| Eval tier | What it adds | Add to baseline |
|---|---|---|
| Tier 1 — Founder-graded against rubric (baseline) | Spreadsheet + manual review | +$0 |
| Tier 2 — LLM-as-judge harness with rubric anchors | Automated grading on each build | +$12,000 |
| Tier 3 — CI-gated regression suite with model-alias pinning | Build blocks merges if eval score drops | +$24,000 |
Most pre-PMF MVPs run at Tier 1. The trigger to go Tier 2 is the first model-alias update during the build window — Anthropic and OpenAI have both shipped multiple frontier-model updates in the past year (Artificial Analysis LLM Leaderboard), and a Tier 1 build cannot tell you whether the update silently regressed quality. Tier 3 is for builds shipping to paying customers in week 6, where a regression becomes a customer-facing incident.
Input 4 — Fallback complexity
Question: When the model fails, what does the product do?
Every AI MVP fails at some inputs. The architecture decision drives the build line because it determines how much non-AI code the engineer has to write around the model. The baseline assumes a simple “log it, surface a friendly error, retry” fallback.
| Fallback complexity | Add to baseline |
|---|---|
| Simple — log, surface error, ask user to retry (baseline) | +$0 |
| Rule-based fallback — deterministic path when model fails | +$6,500 |
| Human-in-the-loop fallback — route low-confidence outputs to a reviewer queue | +$14,000 |
| Agentic recovery — model attempts a second strategy after first fails | +$22,000 |
Rule-based ($6.5K) buys explicit logic for the three common failure modes. Human-in-the-loop ($14K) adds a reviewer interface, a confidence-threshold router, and a feedback loop returning reviewer judgments into the eval set. Agentic recovery ($22K) funds a second model call with a different prompt strategy plus the orchestration to track which strategy succeeded — the stop-budgeting-AI-projects-in-eval-runs piece argues that an agentic build should be sized in eval-runs across both strategies.
Input 5 — On-call window
Question: After the 6-week window ends, who fixes a production regression?
The baseline ends at the week-6 handoff: runbook, eval CSV, prompt files, README — and the founder owns the rest. If the MVP needs vendor support after handoff, that becomes a separate line.
| On-call window | What it covers | Add to baseline |
|---|---|---|
| No on-call (baseline) | Clean exit at handoff | +$0 |
| 14 days post-launch | Slack channel, 1 incident response, runbook updates | +$8,000 |
| 30 days post-launch | Slack channel, 2 incident responses, eval re-grade | +$15,000 |
| 90 days post-launch | Slack channel, 4 incident responses, monthly eval re-grade, 1 prompt iteration | +$32,000 |
Pre-PMF builds usually skip on-call because the founder is hands-on and the cost-of-incident is low. Shipping to paying customers needs at minimum the 14-day window; enterprise customers with procurement expectations need 90 days. The hidden-cost-of-AI piece walks the on-call line in detail.
The worksheet — fill in 5 numbers, get one estimate
The full calculator:
| Line | Your input | Your dollar value |
|---|---|---|
| Baseline | — | $60,000 |
| Input 1 — Capability count | 1 / 2 / 3 | +$0 / +$18,000 / +$32,000 |
| Input 2 — Users target | Internal / single-tenant / light multi-tenant | +$0 / +$8,500 / +$22,000 |
| Input 3 — Eval tier | T1 / T2 / T3 | +$0 / +$12,000 / +$24,000 |
| Input 4 — Fallback complexity | Simple / rule-based / human / agentic | +$0 / +$6,500 / +$14,000 / +$22,000 |
| Input 5 — On-call window | None / 14d / 30d / 90d | +$0 / +$8,000 / +$15,000 / +$32,000 |
| Estimate | Sum the column |
Five inputs, one number. The math is additive because each line maps to a discrete cost line in the build — no multiplier, no complexity factor, no hidden buffer. A founder filling out the worksheet should be able to point at any line and ask the vendor “is this number in your proposal, and what does it buy?”
Three worked examples
Example A — Lean confirm-or-kill ($60,000)
Founder profile: Domain-expert solo founder pre-seed, validating an inbox-triage hypothesis against a 200-input eval set.
| Input | Choice | Add |
|---|---|---|
| Capability count | 1 (triage only) | +$0 |
| Users target | Internal only | +$0 |
| Eval tier | T1 — founder-graded | +$0 |
| Fallback complexity | Simple | +$0 |
| On-call window | None | +$0 |
| Total | $60,000 |
The baseline build. Six weeks, one capability, founder is the only user, manual grading, friendly-error fallback. Output: a confirmed-or-killed hypothesis backed by a graded eval CSV.
Example B — Design-partner pilot ($115,500)
Founder profile: Seed-funded operator-founder, shipping to one design-partner customer in week 6, light eval discipline.
| Input | Choice | Add |
|---|---|---|
| Capability count | 1 | +$0 |
| Users target | Single design-partner (single-tenant) | +$8,500 |
| Eval tier | T2 — LLM-as-judge | +$12,000 |
| Fallback complexity | Rule-based | +$6,500 |
| On-call window | 30 days | +$15,000 |
| Total | $102,000 + $13,500 partner integration premium = $115,500 |
The $13,500 premium accounts for the design partner’s integration specifics (their CRM, their auth, their on-call schedule). One capability, one integration surface, but the on-call window and Tier 2 discipline reflect that a customer-facing regression is no longer an internal bug. Most seed-stage AI MVPs land in this bracket.
Example C — Paying customer launch ($215,500)
Founder profile: Series A operator-founder, launching multi-tenant to 5–10 paying customers in week 6, full eval discipline.
| Input | Choice | Add |
|---|---|---|
| Capability count | 2 (triage + summarization) | +$18,000 |
| Users target | Light multi-tenant | +$22,000 |
| Eval tier | T3 — CI-gated regression | +$24,000 |
| Fallback complexity | Human-in-the-loop | +$14,000 |
| On-call window | 90 days | +$32,000 |
| Subtotal | $170,000 | |
| Multi-capability eval interaction premium | +$15,000 | |
| Multi-tenant operational premium | +$30,500 | |
| Total | $215,500 |
The interaction premiums capture compounding operational complexity — two capabilities under a CI-gated regression suite cost more than the sum of “two capabilities” and “CI-gated regression” because the suite has to gate both. Above $200K is the upper limit of what is honestly an MVP; the what-50k-100k-250k-buys-you piece walks the full bracket.
How to interpret your result
| Your estimate | What it tells you |
|---|---|
| $60K–$75K | Lean confirm-or-kill bracket. Funds one capability, founder co-authorship, no on-call. The $75K anatomy piece is the dedicated walkthrough. |
| $80K–$130K | Defensible MVP bracket. Single design-partner customer, light eval discipline, modest on-call. Most seed-stage AI MVPs land here. |
| $130K–$200K | Paid-pilot bracket. Multi-tenant or multi-capability scope, full eval discipline, real on-call. The $50K/$100K/$250K piece walks the full spectrum. |
| $200K–$250K | Productionized-MVP bracket. Multi-capability multi-tenant with regression gating. Above this is no longer an MVP — it is a v1 product. |
| Above $250K | The calculator has hit its escalation gate. Treat the number as a scope warning rather than an estimate. |
A number outside your fundraising envelope is the first signal to rescope. The next move is rarely to argue with the calculator; it is to revisit which input pushed the number up and decide whether the structural reason behind that input is one you can defer.
When the calculator breaks — four named cases
The calculator is honest within the assumptions of a defensible 2026 AI MVP. Four cases break it:
- Compliance scope — HIPAA, SOC 2, GDPR add $20K–$60K in evidence and audit work that maps to no input.
- Multi-tenant SaaS launch — true multi-tenant (50+ customers, per-tenant billing) is not an MVP scope. Input 2 escalates rather than pricing it.
- Fine-tune or open-weights deployment — the build line shifts because GPU infra and training-run cost enter the equation. The calculator assumes frontier-API inference.
- Agentic on-call — agentic systems with autonomous tool use and multi-step recovery need on-call windows in the $50K–$100K range, not the $32K cap the calculator allows. The day-one observability stack piece walks agentic operations.
If you hit one of these four cases, the number is a scope warning, not an estimate.
The founder time line — unbilled but real
A line the calculator does not price: founder time. A baseline $60K MVP requires 80–120 hours of founder engagement across 6 weeks — heaviest in weeks 1–2 (scoping, PRD, eval set curation) and again in weeks 4–5 (eval grading, iteration). At a $200 per hour founder opportunity cost, that is $16K–$24K of unbilled labor on top of the vendor invoice.
BCG’s Build for the Future frames AI value capture as a co-creation problem. The founder time line is the structural expression of that frame — vendors at the MVP price point cannot absorb the work only the founder can do (sampling representative inputs, owning the rubric, deciding what “acceptable output” means). A vendor offering to absorb eval-set curation inside the $60K is either over-promising or planning to ship against a synthetic eval set.
From calculator output to vendor proposal
Your calculator output is the number you walk into the next vendor scoping call with. Three rules:
- Lead with your number, not the vendor’s. Hand them the worksheet and ask them to price each input against their proposal. If they refuse, you are about to sign a black-box engagement.
- The exclusion list is the diagnostic. A proposal that names every line AND a separate exclusion list is scope-controllable. One naming only inclusions will scope-creep in week 2 — the AI MVP scope-creep piece names the six patterns.
- Reserve 15% for the unknown. No calculator captures every line. The why-your-AI-MVP-should-reserve-15-percent piece argues the reserve is structural.
The decoding AI project TCO piece extends the frame across a 24-month horizon — the seven cost lines that show up after the MVP ships, that this 5-input calculator does not price.
Frequently asked questions
How accurate is this 5-input AI MVP cost calculator?
Accurate to roughly ±15% for builds inside the five-input scope (1–3 capabilities, internal-to-light-multi-tenant, frontier-API inference, no compliance scope). Above $200K or in any of the four break-cases (compliance, multi-tenant SaaS launch, fine-tune, agentic on-call), treat the output as a scope warning rather than a quote.
Why is the baseline $60K and not $30K or $50K?
$60K is the floor for a defensible MVP — a build that includes a real eval contract, named senior engineers, and a graded handoff package. Below $60K, the line that gets cut is almost always eval engineering, which means the build ships against an eyeball test. The anatomy of a $75K MVP names the 12 lines at the lean-defensible bracket and shows where $60K is structurally tight.
Why does capability count add $18K for capability 2 rather than $30K?
Capability 2 shares discovery, PRD, architecture, and infrastructure baseline with capability 1. What it adds is its own build scaffolding, its own eval set, and a second eval grading loop. Capability 3 adds another $14K because no further infrastructure sharing is possible. Beyond three, the calculator escalates.
Does the calculator price inference cost across the build window?
Yes — $5K of the $60K baseline is pass-through inference and infra across the 6 weeks. That assumes frontier-API inference (Claude Opus 4.8, GPT-5, Gemini 2.5 Pro) at standard 2026 rates per Anthropic and OpenAI public pricing. Fine-tune or open-weights self-hosted breaks the calculator (case 3 above).
What if my idea needs more than three capabilities to prove?
The calculator escalates. Four-plus capabilities is no longer MVP scope — it is a v1 product. The right move is to ask which one or two capabilities, if proven, let you raise the next round or sign the design-partner contract. The 6-week MVP framework walks the deferral logic.
Does the calculator work for non-engineer founders?
Yes — it is built for them. The five inputs name structural decisions (how many capabilities, who uses it in week 6, what happens when the model fails), not technical ones. The eval tier input is the only one that needs a senior partner to translate; the eval-first build playbook is the dedicated walkthrough.
Where does the founder time of 80–120 hours come from?
From cumulative founder-led work across discovery, PRD co-authorship, eval set curation, and three eval grading cycles. Scoping plus PRD is 25–35 hours; eval set curation is 20–30 hours; three eval grading cycles run 25–40 hours combined; handoff is 5–10. The total is unbilled but real — the line that distinguishes a co-created MVP from a vendor-delivered prototype.
How is this different from a vendor’s “get a quote” form?
A vendor form collects your scope and routes you to a sales rep — the math is hidden and the output is a meeting. This calculator publishes the math, names the inputs, and produces a number you can defend before any vendor conversation. The point is to flip the procurement dynamic: you walk in with a number, the vendor defends theirs against yours.
Key takeaways
- A defensible 2026 AI MVP starts at a $60K baseline that funds one capability, a real eval contract, and a clean handoff. Below $60K is a prototype.
- Five inputs drive the price above baseline: capability count, users target, eval tier, fallback complexity, on-call window. Each maps to a discrete cost line.
- Three worked examples — lean confirm-or-kill ($60K), design-partner pilot ($115.5K), paid customer launch ($215.5K) — show how the same idea produces wildly different numbers based on scope.
- The calculator breaks for four cases: compliance scope, multi-tenant SaaS launch, fine-tune or open-weights, agentic on-call.
- Founder time is the unbilled line — 80–120 hours across the 6 weeks, structural and non-negotiable.
- Walk into the next vendor call with your calculator number, not their quote. The procurement dynamic flips when the founder owns the math.
Ready to walk into the next scoping call with a defensible number? Book a 30-minute idea review and bring your worksheet — we will pressure-test the five inputs against your idea before any vendor proposal lands in your inbox.
Arthur Wandzel
