Most first versions land in one of three bands: $15,000–$50,000 for a focused single-workflow app on one platform, $50,000–$150,000 for a real MVP with accounts, payments, a backend and two platforms, and $150,000+ for marketplaces, fintech, healthcare or heavy real-time products. Timelines run roughly 2–3 months, 4–8 months, and 8–14 months respectively. Here's the method to produce your own number, and the reason the quotes you're about to receive will disagree with each other by 300–500%.
How to estimate your own app in six steps
Every credible estimate — including every calculator online — is the same arithmetic. Do it once yourself and you can read any quote you're handed.
- Write release 1 as workflows. "An owner uploads a menu and it appears in the customer app within 60 seconds" is a workflow. "Menu management" is a wish.
- Count screens and services separately. Screens are the visible cost. Services — auth, payments, notifications, search, admin, permissions — are the real cost.
- Attach hours. A simple screen runs 8–16 hours across design, build and QA. A screen with real state, validation and error handling runs 24–60. A backend service like payments or role-based access runs 60–150 on its own.
- Add the invisible 35% for project management, environment setup, code review, release engineering and store submission.
- Multiply by a blended rate covering design, engineering and QA together.
- Add contingency: 15–25% if scope is genuinely defined, 40%+ if you haven't run discovery.
Worked example: a booking app, 14 screens, Stripe payments, notifications, customer app plus small admin panel. Screens ≈ 380 hours, services ≈ 180 — that's 560 hours of direct work, and the 35% overhead from step 4 adds ≈ 196 more, so call it 756 hours. At a blended $65/hour that's $49,140, or about $59,000 with 20% contingency. The same 756 hours at a Los Angeles agency's $150/hour is $113,400. Nothing about the app changed.
Inside that number, a common planning split (vendor convention, not measured data) is discovery 10–15%, design 20–25%, engineering 40–55%, QA 15–20%. Discovery itself typically runs 1–4 weeks, 20–200 hours, roughly $4,500–$40,000. It's the cheapest thing you'll buy: it's the only stage where changing your mind is free.
Why the same spec produces quotes 300–500% apart
The rate assumption is the whole story, and almost nobody says it out loud. Every online cost calculator is a generic hours model multiplied by the author's own hourly rate. A US agency's tool multiplies by $120–180. An offshore shop's multiplies by $22–50. Same spec, triple-digit spread — not because they disagree about the work.
Three things explain the rest: what's inside the number (one quote includes design, QA, PM, deployment and 30 days of fixes; another quotes engineering hours only), assumed scope (the $22,000 quote assumed no admin panel because you never mentioned one and they never asked), and seniority mix (a $45 blended rate can mean two seniors, or one lead and four juniors learning on your budget).
What a number produced before discovery is actually worth
In software estimation, the cone of uncertainty — McConnell's model, and the standard framing in the field — holds that an estimate made at initial-concept stage can be wrong by roughly 4x in either direction, a ~16x total spread, narrowing only as the definition is refined. That's the best case for skilled estimators, not the average.
Treat any pre-discovery number, ours included, as a range-setting device. It tells you whether you're in a $30k conversation or a $300k conversation. It is not a price.
So don't sign a fixed price against a two-paragraph brief. Either run a paid discovery first, or accept that the fixed price is padded — the vendor is pricing their own uncertainty and you're paying for it.
What your budget actually buys
Most guides index on complexity. You don't know your complexity yet — you know your budget.
| Budget band | What you realistically get | To a live listing | What is NOT included | Who delivers it | Biggest failure mode |
|---|---|---|---|---|---|
| Under $15k | One workflow, one platform, off-the-shelf auth, template UI, managed backend, no admin panel | 4–10 weeks | Custom design, real QA cycle, analytics, admin tooling, scalability work, support | No-code builder, solo freelancer, small offshore team | Finding out mid-build that the backend was never scoped |
| $15k–$50k | Focused MVP: 8–15 screens, accounts, payments, notifications, basic admin, cross-platform | 2.5–5 months | Deep integrations, offline sync, compliance work, load testing, design system | Small studio, or a strong offshore team with a senior lead | Scope creep eating contingency by week six, then shipping with no QA budget |
| $50k–$150k | Production v1: custom design, real data model, two platforms, admin, analytics, CI/CD, proper QA | 4–8 months | Regulated certification, 24/7 support, ML features, enterprise SSO, multi-region infra | Full-service agency or a dedicated hybrid team | Building the whole roadmap before validating one workflow |
| $150k+ | Marketplace, fintech, healthcare or real-time platform: multi-role, compliance, scale architecture | 8–14 months | Nothing structural — but marketing, support and operations are still yours | Full agency with specialists, or in-house plus contractors | Twelve months of build before one paying user touches it |
| Ongoing cost per band, year one after launch (maintenance, hosting, store fees, mandatory platform updates — before any new features): under $15k → $3k–$8k · $15k–$50k → $8k–$20k · $50k–$150k → $20k–$60k · $150k+ → $60k and up. | |||||
Your app type moves the number more than your screen count
- Utility or content app — bottom of every range; little backend.
- Auth-heavy app with user data — add 25–40% over a content app.
- E-commerce — the edge cases are the cost: refunds, inventory, tax, failed payments.
- Marketplace or on-demand — two sides means two apps plus an ops panel, matching, ratings, disputes, payouts. Realistically 2x a single-sided app.
- Fintech and healthcare — plan for 1.5–2x a comparable consumer app. The extra isn't features; it's audit trails, encryption, access control, documentation and review cycles.
- AI-native — the model call is easy; evaluation, guardrails, fallbacks and inference cost are not.
The systematically under-weighted item is the backend. Ask every vendor: does this need multi-tenancy, real-time updates, role-based permissions, offline sync, or reporting? Each "yes" moves the number materially, and none of them appear on a screen mockup.
Native, cross-platform, or a web wrapper
React Native and Flutter are consistently reported to cut build cost roughly 25–50% against two separate native codebases — directional consensus rather than a measured figure, but it matches what we see. Cross-platform stops saving money when the product depends on heavy camera or sensor work, background processing, high-frame-rate graphics, or deep OS integration like widgets and watch apps; there you pay the saving back in workarounds.
Two cheaper routes are legitimate. A PWA skips the stores and can cost 40–60% less, at the price of weaker iOS push support and no store discovery. A website-to-app wrapper often lands at $5,000–$15,000 when your site already does the job — but it fails app review if it adds no native value.
What developers actually charge, by region
| Region | Typical hourly range | Where it makes sense |
|---|---|---|
| North America | ~$100–250 (top metros higher) | Regulated work, close stakeholder collaboration, enterprise procurement |
| Western Europe | ~$64–76 for seniors | GDPR-heavy products, EU market entry |
| Latin America | ~$60–75 for seniors | US timezone overlap without US rates |
| Eastern Europe | ~$30–90 by seniority | Deep engineering talent, partial US overlap |
| South & Southeast Asia | ~$24–41 typical; $60–90 for senior AI/cloud/DevOps specialists | Cost-efficient delivery at volume — though the senior-end discount is narrowing fast |
Honestly, from a studio that works across both: the offshore discount is real for well-specified execution and unreliable for ambiguous product work. Thin spec plus a twelve-hour gap gets paid back in rework. It works when a senior lead owns the definition and the delivery team executes against something written down.
The costs that never appear in a build quote
Before any code: developer accounts (Apple's Developer Program is an annual subscription, long-standing at $99/year — confirm the current figure; Google Play charges a one-time registration fee), store listing assets at $500–$3,000, privacy policy and terms at $500–$5,000, and third-party services — error monitoring, analytics, email/SMS, maps — at $100–$800/month combined.
Store commissions, not the $99, are the largest lifetime cost
Apple's Small Business Program gives a reduced 15% commission on paid apps and in-app purchases to developers who made up to $1 million USD in proceeds in the prior calendar year, plus developers new to the App Store; pass $1M during the year and the standard rate applies to future sales. Google Play restructured on 30 June 2026: in the US, EEA and UK the service fee now starts at 10% on your first $1M in annual earnings, with a separate 5% billing fee that applies only when using Play's billing system — not to alternative billing or external web links. Rollout elsewhere is staggered. Most cost guides still print the old 15%/30% framing; if a vendor's ROI model does, their revenue projection is wrong. On iOS, US external-link commission remains unsettled after the Ninth Circuit's December 2025 ruling left the rate to the district court — don't model a specific number there yet.
Your app costs money every year even if you change nothing
- Apple: since 28 April 2026, apps uploaded to App Store Connect must be built with Xcode 26 or later using an iOS 26, iPadOS 26, tvOS 26, visionOS 26 or watchOS 26 SDK.
- Google: from 31 August 2026, new apps and updates must target Android 16 (API 36) to be submitted to Google Play, with an extension available to 1 November 2026.
That's a mandatory upgrade cycle roughly every year, plus dependency updates, OS behavior changes and expiring certificates. Stop paying for maintenance and you eventually stop being able to ship anything at all.
What it costs to run as users arrive
The working rule is annual maintenance at 15–20% of build cost, with year one often 30–50% while the codebase stabilizes under real usage. It's a convention, not a measurement, but it's the right order of magnitude. Infrastructure is separate and scales with load — as an illustration of the curve rather than a benchmark, a typical cloud setup runs roughly $200–300/month at 1,000 active users, $1,500–1,600 at 10,000, $3,500–4,000 at 100,000, and $11,000–13,000 at a million.
So the 24-month picture for a $60,000 build: $60,000 build, $18,000–$30,000 year-one stabilization at 30–50%, $9,000–$12,000 year-two maintenance at the 15–20% rule, $5,000–$25,000 infrastructure depending on traction, plus store commission on revenue. Roughly $92,000–$127,000 of committed spend against a $60,000 quote.
Compliance triggers that add a budget line
- EU consumers? The European Accessibility Act has applied since 28 June 2025 to consumer apps and e-commerce services, with WCAG 2.1 Level AA the practical bar. Micro-enterprises — under 10 staff and turnover at or below €2 million — are exempt for services. Penalties are set nationally and vary.
- Health data? HIPAA plus a business-associate agreement chain across every vendor that touches it.
- Card data handled directly? PCI DSS. Using Stripe and never touching card data avoids most of it — a decision worth tens of thousands.
- Any EU users? GDPR: consent, export, deletion, records of processing.
- Users under 13? COPPA, plus stricter store review.
Engagement model, and who carries the risk
| Model | How you pay | Who absorbs scope creep | Accuracy to expect | Worst fit | Clause to insist on |
|---|---|---|---|---|---|
| Fixed price | Milestones against a signed scope | Vendor — priced in as padding | Exact on paper; change orders float the real number | Anything exploratory | Written change-request process with a stated hourly rate |
| Time & materials | Hours billed monthly | You | Honest range, no false precision | A hard ceiling with no product owner | Not-to-exceed cap with notice at 80% |
| Dedicated team | Monthly per-seat retainer | You, but spend is predictable | Cost predictable, date is not | A single six-week project | Named people, notice period, no silent substitutions |
| No-code build | Build fee plus platform subscription | You — via platform limits | Cheap and fast until you hit the ceiling | Unusual logic or real scale | Data export rights and a migration path |
| In-house hire | Salary, equity, overhead | You, entirely | Slowest start, best long-run control | A one-off v1 | IP assignment in the employment contract |
Contract terms that are cost items in disguise: source code and IP ownership in writing, the change-request mechanism and its pricing, what happens to the estimate when scope moves, the post-launch rate, and handover with documentation and repository access. Unclear code ownership is the most expensive red flag on the list, because it removes your ability to take the work elsewhere and re-bid it.
How to put three incompatible quotes on the same axis
- Convert everything to hours. Ask for the hour estimate and blended rate even on a fixed price. A vendor who won't share hours is hiding the assumption you most need.
- Mark in-scope vs out-of-scope line by line — design, QA, PM, deployment, store submission, post-launch support: line item, absorbed, or absent?
- Normalize currency and tax. VAT/GST, withholding and transfer fees can hide 5–20%.
- Compare the exclusions, not the inclusions. The cheapest quote is cheapest because of what it left out.
- Add the 24-month line — post-launch hourly rate × assumed 15% annual maintenance, plus hosting. A cheaper build with a $180/hour support rate is not cheaper.
One reliable signal: a team that returns a firm quote within 24 hours without asking a single hard question has quoted a guess.
Does AI actually make development cheaper in 2026?
Nearly every cost guide this year asserts a flat 30–50% AI discount with nothing behind it. The evidence is contested. A randomized controlled trial published by METR in July 2025 — 16 experienced open-source developers, 246 tasks, on repositories they averaged five years with — found developers took roughly 19% longer using early-2025 AI tools while believing they were about 20% faster. Small sample, specific population, and greenfield MVP work with 2026 tooling is a different situation; other vendor-run trials report gains.
What we see: AI compresses boilerplate, first-draft UI, test scaffolding and migrations, and inflates review, QA and rework. Net effect on a typical MVP is real but modest. Treat a quote with a blanket AI discount as a red flag.
When your budget is $8,000 and your scope is $80,000
This happens constantly and every cost guide answers it with "contact us." Four honest paths: cut to one workflow done properly for one user type, rather than a thin version of everything; buy instead of build — if 80% of your idea is a solved problem, pay $200/month for that and spend your budget on the 20% that's yours; validate with no-code first, then rebuild knowing what to leave out; or wait. An $80,000 product built for $8,000 isn't a cheap product, it's a write-off with a login screen.
Turning the estimate into a budget decision
Add contingency, stage the spend behind gates — pay for discovery and decide again, pay for a prototype and put it in front of five real users, then commit to release 1 — and write your stop condition down before you're emotionally invested. Prepare eight inputs before you talk to anyone: problem statement, target user, five to eight must-have release-1 workflows as user stories, integrations, expected year-one user volume, compliance exposure, deadline and the reason behind it, and your real budget.
You can generate the range described above in about five minutes with our Project Estimator at mymindstudio.ai/estimateyourproject — five steps covering project type, feature complexity, design requirements, timeline urgency and add-ons like payments, dashboards, multi-language and notifications. The ROI calculator alongside it tells you whether the spend pays back.
One discrepancy worth naming, because it should make you suspicious of any calculator. Our estimator's lowest published band is ',500–$4,000 for a simple site while this article puts a US-built MVP at $50,000–$150,000. Both are correct and they describe different products: the low band is a single-workflow, single-platform build on template UI and managed infrastructure; the high band is a two-platform custom product at US agency rates. Any tool that doesn't tell you which one it's pricing isn't telling you much.
For context on where these numbers come from: MyMind Studio is a Newport Beach-based digital product development company, led by founder Steve Dawson, with a team of 58 experienced professionals and offices in California and Florida (USA), India and China. Our services span custom web and native app solutions, website to app conversion, UI/UX design and product strategy, backend development and API integration, and deployment, scaling and long-term support. We also specialize in web-to-app transformation, mobile app development for startups and enterprises, hiring dedicated mobile app developers, eLearning and education platforms, and scalable SaaS and automation systems. If you want a human to sanity-check a range before you talk to anyone: hello@mymindstudio.ai or +1-949-996-3051.
Frequently Asked Questions
How much does it cost to build an app in 2026?
Most first versions cost between $15,000 and $150,000 — $15,000–$50,000 for a focused single-workflow app, $50,000–$150,000 for a real MVP with accounts, payments and a backend, and $150,000+ for marketplaces, fintech or healthcare. The largest single variable isn't the app, it's the hourly rate of whoever builds it, which ranges from about $24 to $250 by region and seniority.
Why do two agencies quote wildly different prices for the same app?
Because they multiply similar hour estimates by very different hourly rates — a US agency at $120–180/hour against an offshore team at $22–50/hour gives a 300–500% spread on identical work. The rest of the gap is what sits inside the quote: whether design, QA, project management, deployment and post-launch support are included, and whether the cheaper vendor quietly assumed a smaller scope.
Is $10,000 enough to build an app?
Yes for one complete workflow on one platform with template UI, off-the-shelf authentication and a managed backend — and no for anything with multiple user roles, custom design or a real admin panel. The usual way a $10,000 build fails is that the backend was never scoped: the data model, permissions and reporting were assumed away and surface halfway through as a change order you can't afford.
How accurate is an app cost estimate made before any discovery work?
It can be wrong by roughly 4x in either direction. That's the cone of uncertainty from standard software estimation practice: at initial-concept stage the spread between plausible low and high outcomes is around 16x, narrowing only as the definition is refined. Use a pre-discovery number to decide which budget conversation you're in, never as a price.
How much does it cost to maintain an app each year?
Budget 15–20% of the original build cost annually, with year one often 30–50% while the codebase stabilizes under real usage. Hosting is separate and scales with users — illustratively a few hundred dollars a month at 1,000 users rising to several thousand at 100,000 — and store commissions apply to whatever revenue you earn.
Do I still have to pay for development if I never change my app?
Yes, because Apple and Google enforce minimum build targets. Since 28 April 2026 uploads to App Store Connect must be built with Xcode 26 and an iOS 26-generation SDK or later, and from 31 August 2026 new Google Play apps and updates must target Android 16 (API 36), with an extension available to 1 November 2026. Miss them and you can't ship updates at all, so bugs and OS changes go unfixed.
What do I need to prepare before asking for an app development quote?
Eight things: the problem statement, the target user, five to eight must-have release-1 workflows written as user stories, your integrations list, expected year-one user volume, your compliance exposure, your deadline and the reason behind it, and your actual budget. Withholding the budget doesn't get you a better price — it gets you a quote priced against the vendor's guess about you.
