What custom software actually costs in 2026 (and why the quotes got weirder)

"What will this cost?" is the first question on every intro call, and the honest answer annoys people: somewhere between $15,000 and half a million. That isn't an agency dodging. It's what the data says. One pricing study built on more than 5,000 real projects puts the average custom app at about $171,000, and the same guides show simple builds closing under $50,000 while enterprise platforms sail past $500,000.

A range that wide is useless until you know which part of it your project lives in. So this is the article we wish we could send before every first call: the real 2026 numbers, the five decisions that move them, and why AI has made quotes lower but also noticeably stranger.

The 2026 numbers, minus the fog

Across this year's big pricing guides the bands are surprisingly consistent. A simple app, a few screens with a thin backend, runs $15,000 to $50,000. Most small and mid-sized business builds land between $50,000 and $120,000. Anything with a custom backend, third-party integrations, analytics, and proper QA sits in the $100,000 to $500,000 band. A lean MVP from an established team starts around $25,000.

Why is the spread 30x? Because "an app" describes scope about as precisely as "a building" describes architecture. A booking tool for one clinic and a booking platform with payments, two-sided accounts, and calendars across time zones are both "an app." One is a shed, the other is an office block, and they get priced accordingly.

Rates explain another chunk of the spread. In 2026 a senior developer bills $40 to $70 an hour in Eastern Europe, $35 to $60 in Latin America, $25 to $50 in Southeast Asia, and $100 to $200 or more in the US and Western Europe. The same 1,500-hour project is a $75,000 build or a $250,000 build depending on whose hands are on it. That is the single biggest lever most buyers never ask about.

The five decisions that move your number

After enough scoping calls, you can predict where an estimate will land from five answers. Not perfectly. Close enough to budget.

1. How many user roles. Every role you add (customer, vendor, admin, support) multiplies the flows, permissions, and edge cases. Two roles is a product. Five roles is three products in a trench coat.
2. What it has to talk to. Integrations look small on a feature list and rarely are. Payment providers, ERPs, and legacy calendar systems each bring their own auth, their own failure modes, and their own documentation written in 2014.
3. Whether regulation touches it. We build HIPAA-regulated systems, and the access controls, audit trails, and encryption requirements are engineering work, not paperwork. If your product handles health, financial, or children's data, say so in the first call, because it changes the architecture, not just the estimate.
4. How many platforms. Web only is the cheapest path. If you need iOS and Android, a cross-platform build saves 20 to 40 percent over two native codebases, and in 2026 the trade-offs are acceptable for most products that aren't games or heavy on device hardware.
5. How much AI is in the box. A conversational assistant adds $8,000 to $20,000 to integrate; a recommendation engine runs $15,000 to $40,000. The build cost is the smaller half of the story, though. Inference is metered, so an AI feature is the rare line item that keeps charging you after launch.

Run a real project through those five and the fog clears. Say you want a booking product: two roles (customers and staff), Stripe plus one calendar integration, no regulated data, web first with mobile later, and an AI assistant that answers availability questions. That's a $60,000 to $90,000 build with an Eastern European senior team, roughly double with a US one. Add a third role, HIPAA, and native iOS and Android on day one, and the same idea quietly becomes a $250,000 project. Nothing went wrong. The scope was just never the same scope.

About that AI discount

In 2026 most buyers open with some version of "AI should make this cheaper now, right?" Partly, yes. Rate guides tracked developer rates falling roughly 9 to 16 percent across many regions over the past year as AI tooling compressed delivery time and sharpened competition. The discount is real and you should expect to see it.

But the productivity behind it is smaller than the keynote version. DX, which measures engineering output across hundreds of organizations, found a median gain of 7.76 percent in pull-request throughput from AI coding assistants, with most companies landing between 5 and 15 percent. Useful, and it compounds. Not 10x. The 10x demos you've seen are real too; they're just demos.

Meanwhile agencies picked up a cost line that didn't exist two years ago. Realistic AI tool spend now runs $200 to $600 per developer per month once token usage joins the seat price, and agentic workflows burn 5 to 20 times more tokens than plain autocomplete. When GitHub changed Copilot's billing on June 1, some developers watched a $29 month turn into $750. Those costs land somewhere, and that somewhere is overhead, which is quotes.

Net effect: quotes are a little lower than they were in 2024, and a lot less certain. The error bars got wider. Which brings us to the weirdness.

Why the quotes got weirder

The strangest thing about 2026 pricing is the gap between the cheapest and the priciest bid on the same brief. That gap always existed. AI stretched it. A demo got dramatically cheaper to produce; a product did not. So when a $20,000 bid and a $150,000 bid arrive for the same RFP, both can be sincere. They are pricing different deliverables. One prices the thing that works in a screen recording. The other prices that thing plus everything that lets it survive contact with real users: authentication, error states, data migrations, monitoring, support, and the unglamorous majority of the work that never appears in a demo.

A serious estimate in 2026 has a recognizable shape. Discovery is paid, short, and produces something you keep even if you walk away. The assumptions are written down where you can argue with them. Change has a defined path, because it's coming. And the running costs after launch get their own line, because model API fees moved real money from the build column to the operations column.

Fixed-price contracts deserve a word here. They feel safe, and in 2026 they usually cost more, because the vendor prices in the risk of volatile tooling costs and every unknown your brief didn't cover. Time and materials with a cap, after a paid discovery, tends to land cheaper in practice. Less comforting on paper, fewer fights in month four.

The costs that outlive the invoice

Maintenance runs 15 to 25 percent of the original build cost per year. On a $120,000 project that's $18,000 to $30,000 annually for dependency updates, OS and platform changes, security patches, and the steady drip of small improvements. Skip it for two years and you aren't maintaining anymore, you're rebuilding.

Then come the bills that arrive monthly whether anyone ships anything: hosting, third-party API fees, and inference if your product has AI in it. The chatbot that cost $12,000 to integrate keeps charging you per conversation, forever. None of this is a reason not to build. It's a reason to budget version one plus twelve months of ownership, and to find out the total before kickoff rather than at month nine.

Three questions that sort vendors fast

1. What does discovery cost, and what do I keep if we stop there? If discovery is free and instant, the estimate is decorative.
2. Which assumptions is this number built on? A vendor who can't list them hasn't made any, which is worse.
3. What will this cost me per month, one year after launch? The answer should include maintenance, hosting, and any metered AI usage, with numbers attached.

The 2026 answer to "what will it cost" is still a range, and anyone who gives you a single number on the first call is guessing or selling. But the range narrows fast once you know your roles, integrations, compliance load, platforms, and AI scope. The $171,000 average is nobody's actual project. Yours will land above or below it for reasons that are mostly in your control, and the cheapest time to control them is before anyone writes a line of code.