You get three quotes for the same app. One says $40K, one says $180K, one says $400K. They can't all be right, and your instinct is to assume two of them are lying. Sometimes that's true. More often, all three are describing genuinely different things, and the spread tells you nobody agreed on what "the same app" means.
Here's what custom software actually costs in 2026, what drives the number, and how to read a quote so a 10x spread stops being mysterious.
What you're actually paying for
A software quote is almost entirely labor. Hosting, licenses, and tools are rounding errors next to people's time. So the real question behind any number is: how many people, how senior, for how long.
That breaks into a handful of cost drivers. Move any one of them and the quote moves with it.
The one people underestimate most is integrations. "Just connect it to our existing system" is the single most expensive sentence in a kickoff meeting, because the cost lives in someone else's undocumented, half-broken API that you can't control.
The team-shape math
Most of the 10x spread comes down to who's on the team and for how long. A useful mental model: monthly burn times months.
$8K-$18K
Offshore solo dev, per month
$20K-$40K
Small senior team (US/EU), per month
$45K-$90K+
Full pod: PM, design, 2-3 eng, per month
15-25%/yr
Of build cost, ongoing maintenance
A three-month project with a $30K monthly burn is a $90K quote. The same project at a $12K monthly burn is $36K, and at a full pod's $70K it's $210K. None of those is automatically wrong. They're different team shapes solving the same problem at different speeds, seniority levels, and risk profiles.
The cheap monthly rate isn't a bargain if it takes three times as long, ships twice the bugs, and leaves you with code nobody can maintain. Outcome cost matters more than hourly rate, and the only way to compare outcomes is to compare what each team is actually committing to deliver.
Fixed-price vs time-and-materials
How you're billed changes both the number and who carries the risk. There's no universally right answer, only a right answer for a given project.
Fixed price feels safe because the number is certain, but that certainty is bought with padding (the agency prices in the worst case) and friction (every change becomes a negotiation). Time-and-materials is honest about uncertainty but demands you stay involved and watch the burn. For exploratory product work, T&M with a clear budget cap and weekly demos usually serves you better than a fixed price built on requirements everyone knows will change.
Honest ranges by project type
Ballparks for a competent US-based or hybrid team in 2026. Ranges are wide because scope is the variable, but these are the brackets we actually quote within.
$8K-$25K
Landing page / marketing site
$40K-$120K
MVP / focused product v1
$120K-$400K+
Full custom platform
$60K-$200K
Mobile app (iOS + Android)
A few notes on reading these. A "web app" can be a $40K MVP or a $400K platform depending entirely on how many of the cost drivers above are switched on, which is exactly why two honest quotes for "a web app" can differ by 10x. And every one of these numbers carries a maintenance tail: budget 15 to 25 percent of the build cost per year to keep it alive. A $100K build is a multi-year financial commitment, not a one-time purchase. You can find per-project breakdowns in our cost guides.
The cheap-quote red flags
A suspiciously low number isn't a discount. It's a forecast of how the project will go. Here's what usually hides behind it.
The specific tells:
- The quote arrived in a day with no scoping conversation. They can't have priced your project. They priced a fantasy and you'll pay for the gap.
- No line for QA, testing, or deployment. That work doesn't disappear; it just shows up as bugs you pay to fix.
- No maintenance story. If nobody mentions what happens after launch, you're buying an orphan.
- The price is round and the scope is vague. "$25K for the whole thing" with a half-page brief means the number came first and the scope will be reverse-engineered to fit it, by cutting things.
- You can't find out who writes the code. If the team won't tell you the seniority of the people actually building it, assume the cheapest possible.
The most expensive software you'll ever buy is the cheap quote that gets rebuilt eighteen months later.
How to get a quote you can trust
Make the spread legible before you compare:
- Write a one-page brief before you ask anyone. Same brief to every bidder, so you're comparing the same thing.
- Ask each bidder to break the quote into phases with deliverables, not one lump sum.
- Demand the team shape: who, how senior, for how long.
- Ask for the maintenance number explicitly. Their answer tells you whether they're thinking past launch.
- Compare outcomes and risk, not hourly rates.
Do that and the 10x spread resolves into three clearly different offers, and you can pick on value instead of guessing. When we quote at our Custom Software Development practice, we phase it and name the team, because a quote you can't interrogate isn't a quote, it's a number. Send us a brief and we'll show you the math.
Read next:
- Build vs buy: a framework for custom software
- Choosing a dev agency: 12 questions to ask
- How to scope an MVP that ships in six weeks
Related: