How Much Does Custom Software Development Cost? A Realistic Breakdown

The same 'CRM with a dashboard' can cost $15k or $150k depending on user roles, integrations, data model complexity, and whether the team has built anything like it before. The brief rarely captures the scope that actually drives cost.

When two agencies quote the same brief at wildly different prices, they're almost always quoting different things. The cheaper quote usually assumes: a simpler data model, fewer user roles, existing third-party integrations that don't need custom middleware, no discovery phase, and a fixed scope that won't change. The more expensive quote usually includes: a proper discovery phase, a technical architecture review, custom integration work, role-based permissions with audit logging, and a contingency for the scope changes that always happen.

Neither quote is dishonest. They're honest estimates of different things. The problem is that the brief doesn't specify which one the client actually needs — and the client usually doesn't know the difference when they're writing the brief. This is why the first step in any responsible custom software engagement is a discovery phase that produces a defined specification, not a line of code.

The specification is what the quote is actually for. Without it, you're quoting a guess at a guess. A well-scoped specification — user stories, data model sketch, integration list, permission matrix — narrows the range from $15k–$150k to something much more specific.

Integrations with third-party systems, role-based permissions and multi-tenancy, the number of distinct user journeys, and whether the client has a defined spec or needs discovery included in the engagement.

Integrations are the biggest single driver of cost variance. A standalone system with no external connections is the simplest possible build. Every third-party API you add — payment gateway, ERP, logistics platform, email provider, reporting tool — adds integration work that compounds. The integration work isn't just connecting the APIs; it's handling the edge cases, the error states, the rate limits, the schema mismatches between your data model and theirs. A system with 10 integrations costs significantly more than 10 times a system with 1 integration, because the combinations and dependencies multiply.

Role-based permissions and multi-tenancy are the second biggest driver. A single-role system where all users see the same data and have the same capabilities is straightforward. A system with five user roles — admin, manager, staff, auditor, external partner — each with different data visibility and different action permissions, is five times more complex to design, build, and test. Multi-tenancy (where multiple organisations share the same system with complete data isolation) adds another layer on top of that.

The number of distinct user journeys drives UI complexity. A system where all users do essentially the same thing has one UX to design and build. A system where admins configure the system, managers approve workflows, staff perform operations, and customers see a self-service portal has four distinct UX surfaces, each of which needs its own design, build, and QA pass.

Finally, whether the client has a defined spec or needs discovery is a direct cost: a proper discovery phase — workflow mapping, data modelling, architecture review — typically adds $5,000–15,000 to the project cost and 3–4 weeks to the timeline. It's not optional for a complex build. It's the work that prevents a $60,000 build from turning into a $100,000 one because the specification changed mid-build.

Internal tools and single-workflow automations typically land between $10,000 and $30,000. Purpose-built CRMs and ERP modules range from $30,000 to $80,000. Custom software projects with multi-tenant architecture and external-facing APIs start at $80,000 and scale from there.

POS systems for retail environments sit in the $40,000–$120,000 range depending on branch count and hardware integration. The wide range here reflects the difference between a recent build for a single-branch deployment with standard hardware versus a multi-branch system with centralised inventory management, inter-branch transfers, and compliance reporting.

Customer portals and self-service tools — where an external user (customer, partner, supplier) has access to a limited view of your internal data — typically add $15,000–25,000 to the cost of the underlying system they're built on top of. The portal itself isn't complex; the security architecture required to expose internal data to external users correctly is.

Mobile applications add 40–60% to the cost of a comparable web application, primarily because of the additional platform (iOS and Android both need to be built and tested), the App Store submission process, and the ongoing update overhead as operating system versions change.

These ranges assume a single-phase build. Most complex systems are better built in phases: a first phase that ships the core workflow (say, 8 weeks, $40,000–60,000), a second phase that adds reporting and integrations (say, 6 weeks, $25,000–35,000), and ongoing maintenance from there. Phased delivery reduces risk, allows real-world feedback to inform later phases, and avoids the situation where a $150,000 build produces something nobody wants to use because requirements changed during the build.

Discovery and workflow mapping, system design, phased build milestones, QA and rollout support, and a defined support window post-launch. Anything outside that scope is a change order — a transparent agency tells you this up front.

A well-structured fixed-price quote includes everything needed to deliver a working, production-ready system. It should specify: the number of user roles, the specific integrations included, the data retention and backup policy, the deployment environment (cloud, on-premise, client-managed), the testing protocol, and the post-launch support arrangement.

It should also specify what it doesn't include. 'Support for additional integrations discovered during build' is a scope change. 'Additional user roles identified after design sign-off' is a scope change. 'Migration of historical data from a system that wasn't part of the original brief' is a scope change. A transparent agency puts these exclusions in writing, not because they're looking for ways to add to the invoice, but because the alternative — absorbing scope changes silently — produces underbaked features and timeline overruns that affect every other client.

Write down the three workflows the software needs to replace, list every system it needs to talk to, and identify the users who need different permissions. That's 80% of what a developer needs to produce a meaningful estimate rather than a range wide enough to be useless.

The three-workflow exercise is the most valuable thing you can do before requesting a quote. Not 'we need a CRM,' but 'a sales rep creates a deal, adds notes from calls, and marks it won or lost — that's one workflow. A manager reviews all deals by stage and by rep — that's two. Finance exports won deals by month for commission calculation — that's three.' That description produces a meaningfully different quote from 'CRM with a dashboard.'

The integration list should include every external system the new software needs to send data to or receive data from. Email: yes or no? Payment processing: which gateway? ERP: which one, and what version? Logistics: which carriers? Each integration is a question and a cost. Knowing the list before the quote means the estimate includes the real work.

The user permission matrix doesn't need to be precise. 'Admins can do everything. Staff can process orders but not issue refunds. Managers can issue refunds and see all staff activity. No other users.' That's enough to understand the permissions complexity without a full technical specification.