The honest answer: a simple business app usually lands between $35,000 and $80,000, a customer-facing mobile app between $70,000 and $160,000, and a two-sided marketplace with payments between $120,000 and $350,000. Anything with heavy legacy integration or enterprise compliance can pass $250,000.
Those ranges are wide because "build an app" is like "build a house" — nobody can price it before they know the size, the site, and the finishes. What follows is the breakdown we use when a project comes in, so you can sanity-check the quotes you already have.
Typical app costs by product type
| What you are building | Typical build cost | Timeline |
|---|---|---|
| Internal tool or single-purpose app (login, CRUD, one integration) | $35,000 – $80,000 | 6 – 10 weeks |
| Customer-facing mobile app (iOS + Android, notifications, payments) | $70,000 – $160,000 | 10 – 16 weeks |
| B2B SaaS product (roles, admin, reporting, integrations) | $90,000 – $250,000 | 14 – 24 weeks |
| Booking or rental platform (availability, calendar, deposits) | $60,000 – $150,000 | 10 – 18 weeks |
| Two-sided marketplace (onboarding both sides, search, payouts) | $120,000 – $350,000 | 16 – 30 weeks |
| AI-enabled features (LLM workflows, retrieval, guardrails, evaluation) | +$25,000 – $80,000 on top of the base app | +4 – 10 weeks |
| Enterprise replacement or integration-heavy platform | $250,000+ | 6 – 12 months |
Two caveats matter more than the numbers. First, these are US agency ranges; offshore teams quote 40–60% less on paper and the gap narrows once you add coordination, rework, and your own time. Second, the low end of each range assumes a clean scope that does not change mid-build. Scope change, not code, is what breaks budgets.
What you are actually paying for
Only about half of a typical invoice is writing application code. The rest is deciding what to build, verifying it works, and coordinating the people doing both:
| Phase | Share of budget |
|---|---|
| Discovery, scoping, architecture | 10 – 15% |
| Product and interface design | 10 – 20% |
| Client/front-end build | 20 – 25% |
| Server, database, integrations | 25 – 35% |
| Testing, release, deployment | 10 – 15% |
| Project management and communication | 10 – 15% |
If a quote has no line for discovery, the agency is guessing — and the guess is built into the price as a contingency you cannot see. Our own services are scoped the same way, with the discovery output written down before a build price is fixed.
The seven things that move the number most
- Third-party integrations. Each external system (accounting, CRM, payments, shipping, EHR) adds roughly $5,000–$25,000. The cost is rarely the happy path; it is the error handling, retries, and rate limits around it.
- Authentication and permissions. One login screen is cheap. Multi-tenant roles, team invitations, SSO, and audit trails are a real subsystem.
- Money movement. Marketplaces are the expensive end of this: split payouts, refunds, disputes, tax handling, and KYC are the difference between a $90,000 app and a $250,000 one.
- Realtime and offline behaviour. Live chat, presence, collaborative editing, and unreliable-network support require architecture decided on day one, not retrofitted.
- Data migration. Importing years of spreadsheets or a legacy database is usually underestimated by a factor of two.
- Compliance. HIPAA, PCI-DSS, or SOC 2 readiness typically adds 15–40% through additional engineering, logging, and review.
- AI features. The model call is the cheap part. Evaluation harnesses, prompt and retrieval tuning, guardrails, latency work, and per-request inference costs are what you are really buying — and they need to be designed like any other subsystem.
Hourly or fixed price?
Hourly billing is honest about uncertainty and punishes vague scope. Fixed price is honest about budget and requires that someone spent real effort defining scope before quoting.
A fixed-price quote is only as good as the scope document behind it. Ask to see that document before you compare two fixed prices, because the cheaper quote is usually the one with more assumptions you have not read. When we take a fixed-price project we write down what is in, what is out, and how change requests are priced — the same discipline that keeps the number from moving after signature. You can see the shape of that in our portfolio and start it with a scope and quote request.
What it costs to run after launch
- Maintenance and support: plan 15–25% of build cost per year. Security patches, dependency upgrades, and OS releases do not stop because the project shipped.
- Hosting and infrastructure: $50–$300/month for a small production app; four figures for high traffic, media, or heavy background processing.
- Third-party services: payments (roughly 2.9% + $0.30 per transaction), SMS, email, maps, search, and monitoring all bill monthly.
- AI inference: modest at low volume and easy to leave unbounded. Cap it per user from the first release.
- App store fees: $99/year for Apple's developer programme, $25 once for Google Play.
Skipping maintenance does not save that 15–25%; it converts it into an emergency rebuild two years later at 40–60% of the original build cost.
How to compare quotes honestly
- What is explicitly out of scope, and what does it cost to add it later?
- Who owns the repository, the cloud accounts, and the domain — you or the agency?
- What happens when a third-party API changes or a vendor raises prices?
- What are the acceptance criteria for each milestone, and who tests against them?
- Who is on the team, by name, and how much of your project is their time?
Red flags: a firm number with no discovery, "unlimited revisions", no named engineers, ownership of the codebase transferred only on request, and timelines that ignore testing entirely. Any one of these usually shows up later as a change order.
Frequently asked questions
How much does a simple app cost?
For a single-purpose app with login, a handful of screens, one integration, and a payment flow, expect $35,000–$80,000 in the US. Below that budget you are usually buying a template, a no-code stack, or a prototype — all legitimate choices, as long as you accept their limits on customisation, performance, and ownership.
Why do quotes for the same idea differ by 5x?
Almost always scope assumptions, not hourly rates. One quote assumes a single admin role and no reporting; the other assumes team accounts, exports, audit logging, and a support workflow. Comparing quotes without comparing assumptions tells you nothing.
Is offshore development cheaper?
Day rates are, often by half. Total cost depends on how much specification, review, and rework you absorb internally. Projects with a frozen scope and a detailed spec travel well; exploratory products do not.
How long before the first working version?
A useful first release that real users can touch usually takes 8–16 weeks depending on complexity. Add 4–8 weeks for store review, integrations with systems you do not control, and compliance review.
Next step
If you want a number that survives contact with reality, start with scope. We will map what you are building, what it integrates with, and what it will cost to run — then quote it fixed, in writing, with the assumptions listed. Request a scope and quote, or talk it through first if you are still deciding what to build. Spread payments across the build with project financing.