The cost of building an MVP with AI breaks into six parts: AI tools (subscriptions or credits), AI model usage if you run agents through an API, hosting and services, fixed fees such as domains and app store accounts, paid expertise like a security review or a freelancer for the hard parts, and your own time. For a simple MVP built mostly by you with AI tools and free hosting tiers, the cash cost can stay small. The two things that move the total most are rework, which multiplies every usage-based cost, and whether you pay a person to build or review it. You can estimate each part in advance with the worksheet below.
Prices change often, so this guide focuses on how each cost works and how to estimate it, with a few verified examples dated October 2026.
The six cost categories
1. AI building tools
How you pay depends on the type of tool:
- App builders (Lovable, Bolt.new, Replit) usually combine a monthly plan with credits or usage limits. Lovable's documentation, for example, explains that you need credits to send messages (Lovable docs). Every fix-and-retry loop spends credits.
- AI coding tools (Cursor, Claude Code, GitHub Copilot, Kiro) typically have a monthly subscription with usage included, and some charge extra beyond a limit.
- Planning tools have their own plans. Many offer a free tier.
- A domain name, renewed yearly
- App store developer accounts if you publish a mobile app (Apple and Google each charge a developer fee; check their current terms)
- Any paid API your product depends on, such as maps, SMS, or payments
- A security review before launch, especially for payments, health data, or personal data
- A freelancer for one hard part (an integration, a migration, app store submission)
- Legal templates for terms and privacy policy
- A written scope with an explicit "not in version one" list
- Small tasks with acceptance criteria
- One feature per prompt or agent run
- Stopping after two failed attempts to fix the instructions instead of trying a third time
- Assume 40 tasks in the MVP.
- Assume each task takes one successful agent run averaging 300,000 input tokens and 30,000 output tokens (agents read files and context repeatedly).
- At $2 per million input and $10 per million output tokens (Claude Sonnet 5.5 list prices, October 2026, without caching), one run costs about $0.60 + $0.30 = $0.90.
- 40 tasks at one run each: about $36.
- If half the tasks need a second attempt: about $54.
- If vague tasks average three attempts: about $108.
- Planning tool: monthly plan × months of planning
- Build tool or tools: monthly plan × months of building, plus expected overage
- API usage: tasks × runs per task × average cost per run
- Hosting and database: monthly plan once you need backups and no pausing
- Auth, email, storage, other services: free tier limits versus expected users
- Domain and app store fees: yearly
- Expert help: security review, freelancer hours
- Buffer: add a margin for rework and surprises
- Your hours: estimate them, even if you don't pay yourself
- Plan before you build. Cutting a feature in a document is free. Cutting it after it's built costs the build plus the removal. See how to plan an MVP before using Lovable, Bolt, or Cursor.
- Use free tiers knowingly. Fine for building and testing; check backups, pausing, and usage limits before launch.
- Route simple work to cheaper models and keep the expensive ones for hard problems.
- Keep sessions short and focused so you don't pay to resend irrelevant history.
- Set spend limits in every tool that supports them.
- Pay for expertise where it reduces risk, not where AI does fine.
- Lovable documentation: Plans and credits
- Anthropic documentation: Prompt caching and model pricing
- Supabase pricing
What to check on each pricing page: what counts as a unit of usage, what happens when you run out, and whether unused credits roll over.
2. AI model usage through an API
If you run coding agents with your own API key, you pay the model provider per token. Prices differ widely by model. As of October 2026, Anthropic's published prices for Claude Sonnet 5.5 were $2 per million input tokens and $10 per million output tokens, with cached input billed at a fraction of the base price (Anthropic pricing). Smaller models cost much less, and larger ones more.
3. Hosting and services
Hosting, database, authentication, file storage, and email often have free tiers that cover an MVP. Read the limits carefully. For example, Supabase's free plan (checked October 2026) includes a 500 MB database and 50,000 monthly active users, pauses projects after a week of inactivity, and doesn't include automatic backups (Supabase pricing). Backups and "never paused" are often reasons to move to a paid plan before real users arrive.
4. Fixed fees
5. Paid expertise
Even when AI writes most of the code, it can be worth paying for:
These are usually the largest single line items, so get quotes against a written scope.
6. Your time
Your time is the cost most founders leave out. Hours spent re-prompting, debugging, and re-explaining the project are real, and they're where poor planning shows up first.
The multiplier: rework
Usage-based costs scale with attempts, not with features. A feature that takes three tries costs roughly three times as much in credits or tokens as one done right the first time, plus the tokens spent explaining what went wrong.
That's why the cheapest cost reduction is upstream:
The guide to reducing token waste goes deeper on this.
A worked example: estimating agent usage
Here's how to estimate API costs for the build phase. The token counts are assumptions for illustration; replace them with numbers from your own first few tasks.
The model price didn't change between those scenarios. Only the rework did. Prompt caching would lower all three numbers, but it doesn't change the ratio.
A budget worksheet you can fill in
Copy this list and fill in current prices from each provider's pricing page:
Then set a monthly cap on every usage-based item before you start.
How to keep the cost down
What Mogryat costs, and how it affects the rest
Mogryat has a free tier for getting started; at the time of writing it includes three projects, and paid tiers raise the limits. See pricing for current details.
Mogryat affects the other categories in three ways. Planning before building reduces rework, because every task has acceptance criteria and a focused prompt. If you run agents from Mogryat with your own API keys for OpenHands, Claude, or GPT-4o, the provider bills you directly. And the usage page shows estimated LLM and agent execution costs and tokens, with a monthly spend limit that warns at 80% and 95% and can block runs when the limit is exceeded.
Track AI spend as you go. This test account only used demo runs, so every figure is $0.00.
With your own API keys, model costs are billed by the provider directly to you.
Mogryat doesn't include hosting for the app you build, and it doesn't replace a security review where one is needed.
For the full process the budget supports, see from app idea to launch.
Plan your MVP and keep an eye on AI spend →