Ask three firms to quote the same custom software project and you can get $30,000, $90,000, and $400,000. All three may be quoting in good faith. They are quoting different projects, because "custom software" is not a specification — it is a category.
Ranges by what you are actually building
- Process automation / internal tool — $15,000–$45,000. Replaces a manual workflow. One user type, modest reporting, a couple of integrations.
- Line-of-business system — $50,000–$150,000. Runs a real part of the business: scheduling, dispatch, case management, inventory. Multiple roles, real permissions, audit trail.
- Customer-facing platform — $100,000–$400,000. External users, meaning security, availability, support, and accessibility obligations you cannot defer.
- Legacy replacement — $150,000–$600,000+. Rebuilding a system the business already depends on, with years of data and undocumented rules. The rules discovery alone is a project.
- Integration / middleware — $20,000–$80,000. Making two systems talk. Frequently the highest-ROI work available, and the most overlooked.
Why the same brief gets wildly different quotes
Usually one of these:
- Different assumptions about scope. One firm assumed you have clean data and an API. Another assumed neither. Neither asked.
- Different definitions of done. Does the price include testing, documentation, deployment, training, and a warranty period? Firms differ enormously here, and the cheap quote usually excludes most of it.
- Different quality floors. Automated tests, code review, and a maintainable structure cost more up front and dramatically less over five years.
- Optimism. Some quotes are the best case with nothing going wrong. Something always goes wrong.
The line items to insist on
A proposal you can actually compare should separate:
- Discovery and specification
- Design
- Build, broken into phases with deliverables
- Data migration — separately, always
- Testing and QA
- Deployment and environment setup
- Training and documentation
- Warranty period — and what it covers
- Ongoing support, priced per month
If a proposal is one number with one paragraph, ask for this breakdown. How a firm responds to that request tells you most of what you need to know about working with them.
What you are actually paying for
Development is priced from effort, and effort is people multiplied by time. Blended rates in the US market generally run $100–$185/hour for a competent domestic team, with specialist security or compliance work higher. That means a $60,000 project is roughly 400–600 hours — three to four months of a small team, not a fortnight.
It also means that when a quote comes in at a third of everyone else's, the question is not "why are they cheap" but "what are they not doing." Usually it is one of these:
- No automated tests. Cheaper to build, far more expensive to change, and every future modification carries regression risk.
- No discovery. They will build what you said in the first meeting, and the change orders start in week three.
- No documentation or handover. Which is fine until you need a different firm, at which point you are quoted a rewrite.
- Junior staff without review. The work gets done; the architectural decisions that determine your cost for the next five years get made by whoever is available.
None of that makes a low quote wrong. It makes it a different product, and you should choose it deliberately rather than by accident.
Where projects overrun
Overruns are rarely "the developers were slow." In order of frequency:
- Data migration. The old data is messier than anyone admitted. Always budget more here.
- Undocumented business rules. The exceptions nobody remembers until the new system refuses to allow them.
- Integration with a system that resists it. No API, poor documentation, or a vendor who charges for access.
- Decision latency. The build stalls waiting for answers. This is a client-side cost and it is real.
- Scope creep dressed as clarification. Each addition is small; the aggregate is not.
How to spend less without buying worse
- Cut scope, not quality. Ship the smallest genuinely useful version. Phase two funds itself with what you learn.
- Clean your data first. This is work you can do in-house and it directly reduces the biggest overrun risk.
- Accept conventional interface patterns. Standard components are cheaper, faster, and more accessible than bespoke ones.
- Assign one decision-maker. Committees are the most expensive project management structure available.
- Reuse what exists. Authentication, payments, notifications — buy these. Nobody needs custom login.
If part of your motivation is that the current system is fragile rather than missing features, it may be worth reading our take on outgrowing your IT setup first — sometimes the answer is infrastructure, not a rebuild.
We scope this as application development work, starting with a paid discovery phase whose output you own outright.
Send us what you have — even a rough description is enough for a useful first conversation.