Methodology: two hour models, every assumption written down

Two columns, two independent models

Every estimate shows two numbers for the same scope at the same team rate. Built AI-native (2026) is the primary column: a bottom-up model for a small, senior-led team using agent-assisted coding and modern scaffolding. What agencies typically quote is the second: the effort norms behind published agency quotes.

The two are built feature by feature, separately. Neither column is a percentage, ratio or multiplier of the other, and there is no "AI makes development X% faster" factor anywhere on this site, because the published evidence disagrees with itself (see how AI changed app costs). The gap between the columns is whatever the two tables produce, scenario by scenario.

The shared cost categories

Both columns are split into the same categories, so you can see where the gap comes from. Whether AI materially compressed each one is our judgement, stated plainly:

Worked through for the booking app example at the Clutch US band midpoint ($74.50 an hour): design 92 h vs 160 h; app and backend build 170 h vs 507 h; auth, payments and integrations 113 h vs 216 h; code review and hardening 81 h vs in build; testing across devices 144 h vs 145 h; release and app-store cycles 26 h vs in testing; project and stakeholder time 83 h vs 103 h. Totals: 709 h ($53,000) built AI-native, 1131 h ($84,000) at agency-quoted effort.

Model 1: Built AI-native (2026)

Who it assumes: a small team, usually two to four people, led by experienced developers who use AI coding agents for most first-draft code, start from current scaffolding (Expo or Flutter templates, Next.js, component kits), use managed sign-in and hosted payment pages, and review everything that ships. What it includes: design, build, integrations, AI features, explicit code review and hardening, testing on real devices, store release cycles, and project and stakeholder time.

Per-feature hours

How the per-feature numbers were set: features that are mostly screens and data handling (profiles, search, analytics, admin) shrink the most, because agents generate that code well. Features with hard correctness problems shrink least: offline sync and conflict handling, real-time chat, booking rules and time zones, and in-app purchase entitlements still need careful human work. Payments and sign-in sit in between: managed providers do the heavy lifting, but webhooks, refunds and security settings get extra hardening hours.

The rest of the AI-native model

• Foundation (screens and set-up outside the ticked features): 24 / 64 / 160 build hours and 20 / 48 / 120 testing hours for simple / standard / complex.
• Platforms, build: x1.15 for one cross-platform codebase, x1.55 for two native codebases (agents port a second codebase quickly, but it is still a second codebase), x0.85 for web, x1.85 for web plus mobile.
• Platforms, testing: x1.15 for Android only (more device variety), x1.45 cross-platform, x1.75 for two native apps, x0.8 web, x2 web plus mobile.
• Backend: managed backend 12 h set-up and x0.7 on server hours; existing API 8 h and x0.6; custom backend 48 h and x1.
• Design: a base by depth (UI kit 10 h, custom 40 h, design system 96 h), plus a size allowance and 1 / 4 / 6 h per feature. Design is counted from scope, not from build hours, because faster coding does not make design decisions faster.
• Code review and hardening: 25% of build, integration and AI-feature hours, plus the per-feature hardening passes above. This is the category that grows when more code is generated.
• Release and store cycles: 16 h for the App Store, 10 h for Google Play, 4 h for a web deployment, plus 6 h when in-app purchases need review.
• Project and stakeholder time: 8 h for kickoff and discovery plus 12% of everything else.
• Range: 0.8x to 1.5x hours. Wider than the agency band because AI-assisted delivery practice is newer and less settled.

Model 2: What agencies typically quote

Who it assumes: an agency team estimating the way published agency cost guides do: feature-by-feature effort with testing and project management as overhead shares. What it includes: the same categories, except that code review sits inside build hours and store release work inside testing and project management, as it does in this model.

Evidence that this is the quoted market, not our invention. Its outputs sit inside the ranges agencies publish. Our booking app comes to $84,000 at the Clutch US band midpoint; DashDevs publishes $60,000 to $180,000 over 4-9 months for a medium-complexity app. Our validation MVP comes to $22,000 and our marketplace MVP to $133,000; Appinventiv publishes $15,000 to $40,000 for a basic MVP and $100,000 to $200,000 for a complex one. Clutch reports an average reviewed app project of $90,780. Those are agencies' own figures, quoted as their claims.

Size allowance

Features

Fifteen features with app-side and backend allowances, listed on cost by feature. Each third-party integration is 16 app hours and 32 backend hours.

Platforms

Backend

Design

Overheads, range and time

• Testing 20% of build hours: manual and automated testing, device checks, store review fixes.
• Project management 10%: planning, communication, releases.
• Range 0.85x to 1.35x hours. Deliberately wider above the midpoint than below it. Our assumption, not a measured overrun rate. For why software budgets slip, see BudgetOverrun.com.

Shared by both columns

• Cost = each category's hours x the rate for that role, summed. The rate is the same in both columns.
• Timeline = total hours / (people x 32 productive hours a week).
• First-year running cost = upkeep hours a month x 12 x developer mid rate + Apple fee (if iOS) + Google fee (if Android) + AI model API cost, the same whichever way the app was built.

AI features (step 4)

AI features appear in both columns, with their own hours in each model (agency-quoted: chat assistant 112 h, semantic search 72 h, content generation 64 h). The running cost is shared: monthly active users x requests per user x (input tokens x input price + output tokens x output price) / 1,000,000. Semantic search is priced on Google's published gemini-embedding-2 rate ($0.2 per 1M input tokens) whichever chat model you pick, because it was the only embedding price we could read from a provider page on 2 October 2026.

Models offered, with prices read 2 October 2026: Anthropic Claude Sonnet 5.5 ($2 / $10), Anthropic Claude Haiku 4.5 ($1 / $5), OpenAI gpt-6.1-sol ($2 / $10), OpenAI gpt-6-luna ($0.1 / $0.5), Google Gemini 3.8 Flash ($0.75 / $3.75). Base prices only; prompt caching and batch discounts are not modelled.

Rates: sourced

Each option in step 7 of the calculator, and exactly how its rate is built:

The US in-house option prices each role separately. Employer cost per hour (25th percentile / median / 75th percentile): developers $72.26/hr / $93.40/hr / $118.11/hr; designers $71.43/hr median; QA $71.63/hr median; project managers $70.27/hr median. The other options use one rate for every role, because their sources publish one band.

Accelerance options blend the junior and senior bands by the senior share you set: low = share x senior low + (1 - share) x junior low, and the same for high. Mid is the midpoint of the blended band.

What is not included

• Hosting, backend service bills and third-party subscriptions (AI model API costs are included when you add AI features).
• Store commissions on revenue (see app store fees).
• Legal, marketing, content creation and recruiting.
• Sales tax or VAT on services.

Change log

• 2 Oct 2026. First version. All rates read 2 Oct 2026.
• 2 Oct 2026 (later). Added the AI features step (build hours plus model API running cost from Anthropic, OpenAI and Google pricing pages read 2 Oct 2026), replacing the single "AI feature" checkbox.
• 2 Oct 2026 (reframe). The calculator now shows two independent hour models: Built AI-native (2026) as the primary column, and What agencies typically quote, which keeps the earlier hour model and its totals. Both are split into the same cost categories. Agency-quoted outputs checked against DashDevs and Appinventiv published ranges and Clutch averages.