Methodology

How we calculate this estimate

This page publishes the actual model, not a description of one. Every multiplier, percentage and rate below is read directly from the same configuration the calculator runs on — so what you read here cannot drift from what the calculator does.

The shape of the model

Hours first, dollars last

Most cost calculators start from a base price and multiply it by coefficients: one for platform, one for industry, one for complexity. That approach inflates without meaning. Two platforms and HIPAA compliance share nothing, so multiplying them together produces a number that describes neither.

Here, each answer contributes engineering hours into a named discipline bucket. Multipliers are applied only where something genuinely scales, and only to the specific bucket it scales. Dollars are calculated once, at the very end.

  1. Collect platform-agnostic hours: the app type’s scaffolding, the industry’s domain logic, each additional user role, every feature, and each admin module.
  2. Scale by complexity. This multiplies product work only — never platform setup, compliance regimes or integrations, which cost what they cost regardless of feature depth.
  3. Price design directly from your screen count and design level, because that is how design is actually quoted.
  4. Add fixed work: platform project setup, the device and OS test matrix, store releases, security posture, compliance regimes, integrations.
  5. Derive architecture from traffic. Peak concurrency selects a tier, and that tier’s requirements become line items.
  6. Expand client hours across surfaces. This is the step that stops iOS plus Android costing twice iOS.
  7. Derive the proportional disciplines: QA, DevOps, architecture, product floor and project management.
  8. Convert to dollars at each discipline’s own US rate.
Rates

Nine disciplines, nine US rates

These are US-market rates for a US-based product team in 2026: senior US engineers, US project management, US QA. There is deliberately no offshore or nearshore rate card, because a rate selector is how cost calculators end up comparing incomparable hours.

US hourly rates by discipline
DisciplineUS rate
Product & discovery$135/hr
UI/UX design$120/hr
Architecture$180/hr
iOS engineering$145/hr
Android engineering$145/hr
Cross-platform mobile$140/hr
Web engineering$135/hr
Tablet engineering$140/hr
Desktop engineering$150/hr
Wearable engineering$150/hr
TV & OTT engineering$150/hr
Backend engineering$148/hr
Integration engineering$148/hr
Security & compliance$172/hr
DevOps & cloud$152/hr
QA & testing$98/hr
Project management$130/hr
Published US band $98–$180/hr. Your blended rate is an output of your work mix, not an input — which is why a compliance-heavy build genuinely costs more per hour than a simple one.
Platform mixing

Why a second platform does not double the cost

Client engineering hours are quoted once, platform-agnostically, in the app type and in each feature. Each platform then carries two factors.

Platform surface factors
PlatformAs the only surfaceAs an additional surfaceDevice matrix (QA hrs)
iOS×0.95×0.6630
Android×1.00×0.7064
Cross-platform×1.25×0.7474
Web app×0.98×0.7234
Tablet×1.05×0.4846
Desktop×1.12×0.6654
Wearable×0.60×0.4434
TV / OTT×1.00×0.6088

The second column is well below the first because the product definition, data model, API contracts, design system and most test scenarios were already paid for by the first surface. Adding Android to an iOS build adds roughly 70% of one client implementation — typically 20–30% of total project cost, not 100%.

Choosing React Native / Flutter instead collapses both mobile apps into one codebase at ×1.25 of a single native app, plus 48 hours for the native capability no framework fully covers. You still ship to both stores and still test both device matrices.

Design grows sub-linearly too, because the second surface reuses the design system and every decision inside it. The multiplier by surface count is 1 surface ×1, 2 surfaces ×1.2, 3 surfaces ×1.38, 4 surfaces ×1.52.

Complexity

Depth, not size

Complexity multiplies product work — the app-type foundation, domain logic and features. Design gets its own, gentler multiplier, because polish scales faster than logic but not as fast as feature depth.

Complexity multipliers
LevelProduct workDesign workProject managementArchitecture
MVP
Prove it works
×0.56×0.666%4%
Standard
Production ready
×1×19%6%
Advanced
Built to grow
×1.38×1.2210.5%8%
Enterprise
Audited and integrated
×1.86×1.4612%10%
At MVP level, features the catalogue marks phase-two are genuinely removed from the estimate rather than discounted. That is the difference between an MVP price and a cheaper quote for the same project.
Traffic & scale

Scale is architecture, not a surcharge

The chain runs: monthly actives → daily actives → peak concurrent → the architecture tier that peak requires → that tier’s specific engineering requirements. The daily and peak ratios come from your industry’s traffic shape, which is why a payroll tool and a ticketing platform with identical monthly users end up on different architectures.

Traffic bands
Monthly active usersModelled atBaseline architectureLoad-sensitive work
Under 1,000500single×0.92
1,000 – 10,0005,000single×1
10,000 – 100,00045,000cached×1.15
100,000 – 1 million400,000scaled×1.34
1 million+2,500,000distributed×1.62

That last multiplier applies only to load-sensitive engineering — the backend, platform work, and features the catalogue tags as growing with traffic. It is never applied to the whole project. A login screen is the same login screen at ten users or ten million.

Design

A system cost plus a per-screen cost

Design is priced two ways at once, because that is how design work behaves: the design system is a one-off, and the screens are not.

Design levels
LevelHours per screenDesign system
Basic UI
Standard components and simple layouts. Fast, familiar, unremarkable.
1.9 hrs22 hrs
Custom UI/UX
Bespoke interface on a documented component library, with a polished flow.
3.3 hrs46 hrs
Premium / advanced UI
Motion, custom interactions, illustration and usability research.
5.4 hrs88 hrs
Derived disciplines

The work that is a proportion of other work

These are calculated last, from the build hours they support, so they cannot be gamed by moving hours between disciplines.

QA & testingFloor as a share of build hours, plus the full device and OS matrix for every platform, plus any testing disciplines selected.
14% + fixed
DevOps & cloudA floor, because even the simplest app needs a way to get shipped.
4% floor
ArchitectureA share of the backend and platform work it designs.
410%
Product & discoveryA floor, because someone has to decide what gets built.
4% floor
Project managementA share of every other hour in the project.
612%
Timeline

Phases overlap, and head-count is not linear

Two mistakes make published timelines useless, and the model avoids both.

Head-count does not scale linearly. Doubling the team does not halve the schedule, because coordination cost rises with every person added. Team size here grows with the square root of the work — tuned so roughly 1,200 hours lands on a team of about 2 and 20,000 hours on about 9 — against a working week of 32 productive hours per person.

Phases overlap. Design starts before discovery finishes, the client build starts before the backend is done, and QA runs alongside development. The phase spans below sum to well over 100% of the schedule on purpose. Laying them end to end is the single most common reason published timelines come out at roughly twice reality.

Phase overlap
PhaseStarts atEnds at
Discovery & planning
Requirements, user flows, technical approach, acceptance criteria.
0%13%
UI/UX design
Wireframes through production screens and a documented design system.
6%36%
Architecture & data model
Data model, API contracts, environments, security design.
10%30%
Backend development
APIs, business logic, background jobs, admin, cloud infrastructure.
16%74%
App development
Every surface in scope, screen by screen, against the live API.
26%86%
Integrations
Third-party systems, reconciliation and failure handling.
44%88%
QA & testing
Functional, device, performance, accessibility and security testing.
50%96%
Deployment & launch
Store submission, production cutover, monitoring and handover.
87%100%
The range

Why we publish a range, never a figure

The midpoint is the model’s central estimate. The published range runs from ×0.86 to ×1.19 of it — asymmetric on purpose, because software overruns more often than it underruns, so the upside tail is longer.

Figures are rounded by magnitude so the output never implies precision it does not have: a $60,000 estimate rounds to the nearest $2,500, a $600,000 one to the nearest $10,000. A calculator that reports $487,213 is telling you something false about how well it knows your project.

Annual maintenance is derived rather than assumed: 1522% of build cost as a floor, rising with each app store you ship through, each third-party integration that changes on somebody else’s schedule, and materially with a regulated security posture — capped at 28%.

Limits

What a calculator cannot know

This is a planning estimate and an indicative range. It is useful for sizing a budget, comparing options and sanity-checking a vendor quote. It is not a fixed development quote, and final development cost depends on finalised technical requirements.

No calculator can know your existing systems, the state of your data, how quickly your stakeholders make decisions, what your security reviewers will ask for, or how much of your scope will change once real users see version one. Those are the things that actually move a software budget, and they are discovered rather than selected from a dropdown.

Use the estimate to start the conversation, then get a fixed-scope proposal against written requirements before you commit. The result page reports its own confidence interval, and that interval widens honestly when your scope is still moving.

FAQ

Questions about the methodology

Why price in hours rather than in fixed packages?
Because a fixed package hides the assumption that matters. Two "e-commerce app" quotes at $150,000 can differ by a factor of two in scope. Pricing 3,000 hours at $130 an hour makes both numbers arguable: you can challenge the hours, challenge the rate, or both. It also means the model composes — features, platforms and compliance each contribute their own hours instead of multiplying a base figure by coefficients that inflate without meaning.
How do you avoid double-counting?
Each axis contributes hours to named discipline buckets, and only the multipliers that describe genuine scaling are applied — each to the specific bucket it actually scales. Complexity multiplies product work but not platform setup, compliance regimes or integrations, which cost what they cost regardless of feature depth. Traffic multiplies only load-sensitive engineering. Client hours are quoted once and expanded across surfaces. QA, DevOps, architecture and project management are percentages of the work they support, calculated last.
Why does the itemised list add up exactly to the total?
Because it is normalised to. QA, DevOps, architecture and project management are proportions of the whole project and cannot honestly be attributed to one feature, so every line carries its proportional share of them. Computing each line independently and hoping the total matched produced a 20% gap between the itemised list and the headline figure in testing — and an itemised list that does not add up to the number above it is worse than no list at all.
Where do the hour figures come from?
Delivery experience on comparable US builds, expressed as hours per feature, per platform and per compliance regime at a Standard level of finish for one client surface. Every figure lives in one configuration layer rather than inside the interface, and the reference scenarios are pinned by automated tests to bands US agencies actually publish — so a change to any rate or hour figure that would quietly reprice the site fails loudly instead.

See the model run on your project

Every figure on this page is applied to your own answers, itemised, in about three minutes.