"What does custom software actually cost?" is the question every founder and CTO asks before they start the conversation, and the question vendors answer worst. The honest answer is that custom software programming costs vary by a factor of 20x for the same problem, depending on who builds it, where they're located, and what the project actually requires. The dishonest answer is the $5,000 estimate or the $500,000 estimate, both of which are wrong for the same project and which both get quoted often.
This guide is the math we'd give a friend asking. Real ranges, what drives the numbers, the price ladder by vendor type, and the questions to ask that flush out hidden assumptions. It applies to web apps, mobile apps, SaaS, internal tools, and most other forms of custom software development.
The honest answer in one paragraph
A real custom software project — meaning something a small team would build that solves a defined problem — costs between $25,000 and $400,000 for version one. Most land between $50,000 and $200,000. The 20x spread between cheap and expensive within that range is driven by complexity, who builds it, and where they're located. Past version one, you should plan on 15–25% of the build cost per year for hosting, maintenance, and ongoing improvements. Anything quoted dramatically outside these ranges deserves a hard look at what's actually being promised.
What "custom software programming" actually costs by vendor type
The single biggest cost driver is who's writing the code. Here's the realistic 2026 price ladder by vendor type for the same hypothetical mid-complexity project — a custom internal tool with three user roles, ten screens, basic integrations, and reporting:
| Vendor type | Hourly blended | Project range |
|---|---|---|
| Offshore freelancers (Upwork, Fiverr Pro) | $15–$45/hr | $8k–$25k |
| Nearshore agencies (Latin America, Eastern Europe) | $40–$90/hr | $25k–$80k |
| Offshore agencies (India, Southeast Asia) | $25–$60/hr | $15k–$60k |
| US mid-market agencies | $120–$200/hr | $80k–$250k |
| US premium agencies / consultancies | $200–$400/hr | $200k–$600k |
| Build partners with flexible engagement (one-time, host, revenue share) | Effective $50–$120/hr | $30k–$150k upfront, optional ongoing |
| Full-time hire (US senior engineer) | $80–$130/hr loaded | $140k–$220k/year |
The hourly rate alone tells you almost nothing — you need to know how many hours, how much rework, and how much project management you're paying for. A $25/hour freelancer who needs 1,200 hours produces the same bill as a $150/hour US team that needs 200. The total project cost is what matters, and the cheaper hourly often produces the bigger total.
The four real cost drivers
1. Complexity, not size
"Big" doesn't drive cost — complexity does. A 50-screen app where every screen is a simple form costs less than a 5-screen app with real-time multi-user editing, conflict resolution, and an undo system. The things that consistently expand cost:
- Multi-user concurrency and conflict resolution
- Background processing (queues, scheduled jobs, long-running calculations)
- Third-party integrations (each one is a real project, not a checkbox)
- Custom analytics or reporting beyond the basics
- Anything with a recommendation engine or AI
- Permission models more complex than role-based access
- Compliance requirements (HIPAA, SOC 2, PCI, GDPR)
- Multi-tenancy if it wasn't designed in from day one
2. Who writes the code
Senior engineers cost more per hour and ship faster. The ratio isn't 1:1 — a senior who takes 100 hours often produces what a junior takes 300 hours to ship, and the senior's output is more maintainable. The real cheap-vs-expensive math isn't hourly rates; it's total time-to-shipped and the maintenance burden afterward.
3. Where the team is located
Geography matters less than it used to, but still meaningfully. US engineers cost 2–4x what comparable engineers in Eastern Europe or Latin America cost. Indian and Southeast Asian engineers are typically 3–6x cheaper than US, with much higher variance in quality. The countries that have caught up most on engineering quality (Poland, Ukraine before the war, Argentina, Mexico, Brazil) command rates closer to US than to the cheapest offshore.
The hidden cost in geography is time zones. If you're in the US and your team is in India, real-time collaboration becomes async ticket-passing. The dollar savings often disappear into longer project timelines.
4. The engagement model
Fixed-price contracts include a risk premium — the vendor builds in 20–40% margin to cover scope they can't predict. Time-and-materials shifts that risk to you. Build partners with hosting models or revenue share defer cost in exchange for ongoing relationship. Each shape produces different total costs over a five-year horizon.
What you actually pay for in a typical project
If a vendor breaks down a $100,000 project quote into hours, here's the rough distribution that's realistic:
| Activity | Share of total |
|---|---|
| Discovery, requirements, technical design | 10–15% |
| UI/UX design | 10–20% |
| Frontend engineering | 20–30% |
| Backend engineering | 25–35% |
| Testing and QA | 10–15% |
| Project management and client communication | 10–15% |
| Deployment, infrastructure setup, handoff | 5–10% |
A vendor whose breakdown has 50% in engineering and 5% in discovery is either underestimating discovery or planning to skip it. Either is a warning sign.
The ongoing cost most founders forget
Software is never "done." After version one ships, you should plan on three categories of ongoing cost:
Hosting and infrastructure. Typically $200–$2,000/month for small-to-mid SaaS apps, $2,000–$10,000/month for larger apps, more for anything with real data volume or compliance requirements. AWS, GCP, and Azure costs scale roughly with active users; small projects in the low single digits per user per month, large ones with heavy data lower per user but higher absolute.
Maintenance. Bug fixes, dependency updates, security patches, browser and OS compatibility. A reasonable budget is 15–25% of the build cost per year. Less than 15% and you're accumulating technical debt; more than 25% and either your build was unusually fragile or your maintenance vendor is padding hours.
Phase 2 (and 3, and 4). Every shipped product reveals what version one missed. Plan on 30–60% of build cost in year one alone for the inevitable additions users will demand once they actually use the software. By year three the cumulative spend on improvements often exceeds the original build cost.
Five-year total cost on a $100k initial build typically lands between $250k and $450k. Founders who plan for $100k flat are unhappy founders by month 18.
Three engagement models and what they actually cost
One-time fee (own the code)
Pay the build cost upfront. You own everything — source code, design files, deployment. Pay separately for hosting and any ongoing work. This is the right model when you'll have engineers in-house eventually, or when the software is core IP you don't want any third party to control.
Total five-year cost: build cost + hosting + maintenance + new features. The math is most predictable here but also most front-loaded.
Subscription (host and operate)
Lower upfront, monthly fee thereafter. The vendor operates the software, handles hosting, applies updates, and includes some level of ongoing improvement. You don't own the source code in the traditional sense, but you typically have rights to it if the relationship ends.
Total five-year cost: usually 10–30% higher than one-time, but more predictable cash flow and lower upfront commitment. Right model when you don't want to deal with vendor management for hosting and ops.
Revenue share
The vendor builds at reduced or zero upfront cost in exchange for a percentage of revenue generated. Common in marketplace, SaaS, and B2C app projects.
Total five-year cost: depends entirely on success. If the product earns nothing, you owe nothing (good for you, bad for the vendor). If it earns a lot, the vendor's take can exceed what a one-time fee would have been (bad for you, good for the vendor). The model is structured to align interests but the alignment is imperfect at extremes.
How to read a custom software programming quote
The quote you should accept has all of these:
- Explicit assumptions section — what the vendor is assuming about your team, your data, your timeline
- Itemized scope — what's in, what's out, with the boundary stated specifically
- Exclusions — what's not in scope (almost always longer than the inclusions)
- Hours by phase or by role — so you can sanity-check the math
- Risk register — the top 5 risks and how they affect the price
- Change order process — what happens when scope shifts
- Ownership terms — who owns the code, the design, the deployment
- Payment schedule tied to milestones, not calendar dates
Quotes missing any of these are usually back-of-the-envelope guesses. The vendor will discover the missing parts during the project and price them in via change orders, and you'll end up paying more than the quote implied.
The price-quote red flags
- Quote arrives in hours. Real estimates require real understanding. A quote that comes back the day you ask is either generic or wrong.
- Single number with no range. "It'll cost $87,500" usually means "it'll cost between $60,000 and $200,000 and we didn't want to tell you that."
- No risk register. Every project has risks. Vendors who don't name them are either inexperienced or hiding.
- The cheapest by 40%. Sometimes a low quote is genuine efficiency, but more often it's missing scope. Ask for a line-by-line comparison against the more expensive quotes.
- "Hourly rate to be determined." Means change orders will arrive at whatever rate the vendor wants.
- Quote that doesn't reference what you asked for. Some vendors send the same template to every prospect. If the quote could apply to anyone's project, it doesn't apply to yours.
How to budget when you genuinely don't know yet
If you haven't talked to vendors yet and need a budget number to take to your board, do this:
- List the user roles your software will have.
- List the major workflows for each role (creating, editing, reporting, approving, etc.).
- List the integrations you need (payment, email, third-party APIs, etc.).
- Each user role: $5k–$15k.
- Each major workflow: $8k–$25k.
- Each integration: $5k–$20k.
- Add 25% for design, project management, and testing.
- Add a 20% contingency.
This back-of-the-envelope number is right within ±40% for most projects, which is good enough for board conversations. Use it to evaluate quotes you receive — anything dramatically lower is probably missing scope, anything dramatically higher is probably padded.
What to do next
If you have a defined project, the next move is two or three real quotes from real vendors. Our free software development RFP template covers the 13 sections vendors actually need to give you comparable proposals.
If you want a fast directional number before talking to anyone, our cost calculator takes about two minutes and produces a range based on your project shape.
If you're still in the figuring-out-what-to-build phase, talk to our chat assistant — it's designed to ask the kinds of questions that flush out scope before any quote conversation makes sense.
And if you want to read the rest of the build-vs-buy thinking, our blog has more on engagement models, vendor selection, and the build-vs-buy math by industry.