Custom software or off-the-shelf? A five-year cost model and a decision table
By Validure team · · 16 min read
A build-versus-buy framework with real arithmetic. A five-year cost comparison, a decision table by process type, the cost of glue code, exit tests for data portability, how to scope a custom build so it doesn't balloon, and when buying is simply right.

Take a 50-person job-work company in Pune that has outgrown its spreadsheets. It has two quotes on the table. A SaaS operations tool at 1,800 rupees per user per month, and a custom build at 45 lakh. The finance head looks at year one and says the build costs more than twice as much. The operations head looks at year five and says the licences never stop. Both are right, and neither has done the sum that settles it.
This post is that sum, plus the questions around it: what never to build, what integration costs, how to test whether you can leave a product, and how to scope a build so it stays the size you quoted. We sell custom development, so we'll say plainly where buying wins. It wins more often than people who sell development admit.
Start with the process, not the software
Before any arithmetic, sort the process into one of three kinds. The kind sets your default, and the arithmetic only confirms or overturns it.
Commodity processes are done the same way by everyone in your industry: payroll, GST invoicing, email, basic accounting. Differentiating processes are part of why customers pick you: how you quote, schedule or price a rush job. Regulated processes have rules set outside the company that keep changing: statutory deductions, tax filing, personal data. A commodity process should almost never reach the build column, however the numbers fall.
A five-year cost model
Compare over five years. Every option has the same six cost lines, and people most often forget the last three.
total_5yr = licences_or_build + customisation + integration
+ maintenance_and_hosting + people + workaround_cost
Here is a worked example. It's an illustration with round numbers, not a quote, and you should replace every figure with your own. The firm has 40 users in year one and grows to 100 by year five.
| Year | 1 | 2 | 3 | 4 | 5 | Total |
|---|---|---|---|---|---|---|
| Users | 40 | 55 | 70 | 85 | 100 | 350 user-years |
Option A, buy. The licence is 1,800 per user per month, or 21,600 per user per year.
| Line (lakh) | How it's calculated | Cost |
|---|---|---|
| Licences | 350 user-years x 21,600 | 75.60 |
| Implementation and data load | one-off | 6.00 |
| Customisation by the vendor | 4.0 in year 1, then 1.5 a year for four years | 10.00 |
| Integration with accounts and the customer portal | 5.0 build, then 1.0 a year for five years | 10.00 |
| Internal admin | 25% of a 6.0 lakh salary, for five years | 7.50 |
| Workarounds | 10 hours a week x 48 weeks x 400 an hour, for five years | 9.60 |
| Total | 118.70 |
Option B, build. Say the build is 45 lakh, with the typical overrun priced in rather than hoped away.
| Line (lakh) | How it's calculated | Cost |
|---|---|---|
| Build | quoted | 45.00 |
| Overrun allowance | 25% of build | 11.25 |
| Maintenance | 18% of build a year, from year 2 | 32.40 |
| Hosting and tools | 2.4 a year for five years | 12.00 |
| Integration with accounts | 4.0 build, then 0.8 a year for four years | 7.20 |
| Enhancements | one release a year at 3.0, years 2 to 5 | 12.00 |
| Product owner | 20% of an 8.0 lakh salary, for five years | 8.00 |
| Total | 127.85 |
At these inputs buying is cheaper by about 9 lakh over five years, which is inside the margin of error of the estimates. That's an honest result: for a firm that grows to 100 users, the two options are roughly level, and the decision should turn on fit and risk, not on cost.
The 18 per cent maintenance figure is a rule of thumb. Published estimates of yearly maintenance as a share of the original build cost mostly sit between 15 and 20 per cent, with some going as low as 10 or as high as 25, and most of them come from vendor blogs rather than measured studies. Treat it as a planning input and ask any developer you hire what they actually see on systems they run.

Where the model changes its answer
Change one input and the answer moves. The one that moves it most is user growth, because licences scale with people and a build mostly doesn't.
Suppose the same firm grows faster, from 40 to 200 users: 40, 70, 110, 150, 200, which is 570 user-years. Licences become 570 x 21,600 = 123.12 lakh. Buying now totals 118.70 - 75.60 + 123.12 = 166.22 lakh, while the build stays at 127.85 (we've held hosting flat, which is generous to the build, so add a little). The build is cheaper by about 38 lakh.
You can find the crossover directly. The non-licence part of buying is 118.70 - 75.60 = 43.10 lakh. The build is 127.85. So licences have to cost at least 127.85 - 43.10 = 84.75 lakh before building pays off:
break_even_user_years = (build_total - buy_non_licence_total) / licence_per_user_year
= 84,75,000 / 21,600
= about 392 user-years over five years
= an average of about 78 users
So below an average of 78 users on this licence price, buy. Above it, the build starts to win on cost alone. Also test the maintenance percentage, the overrun allowance and the yearly licence price rise.
A model with this many guessed inputs has an error band bigger than the gap you're measuring. Its job is to find the inputs that matter, then argue about those.
A decision table by process type
| Process type | Examples | Default | Why | Build only if |
|---|---|---|---|---|
| Commodity | Payroll, accounting, GST invoicing, email, ticketing | Buy | Hundreds of firms already pay for the maintenance. Your version would be a worse copy. | You have a genuinely unusual constraint the market can't meet |
| Differentiating | Quoting, scheduling, pricing logic, customer-facing workflows | Build, or buy a base and build the edge | A standard tool flattens the thing customers pay you for | The process is stable enough to specify |
| Regulated | Statutory deductions, tax filing, consent and data handling | Buy | A vendor tracks rule changes full time. You'd need a person to do that. | You can staff the compliance tracking for the life of the system |
Rules keep moving. E-invoicing applied from 1 August 2023 to businesses with aggregate turnover above 5 crore, and the Digital Personal Data Protection Rules were notified in November 2025 with most obligations phased in over roughly 18 months. Press coverage disagrees on details, so check the CBIC and MeitY sites. Every such change is a maintenance item. If you build, it is yours.
Integration, and what glue code costs
Most hidden cost in both options sits in the connections between systems. A bought tool still talks to your accounts and portal, and so does a built one. The arithmetic is unforgiving. If every system connects directly to every other, the number of links is n(n-1)/2:
| Systems | Point-to-point links | Adapters if you add a hub |
|---|---|---|
| 3 | 3 | 3 |
| 6 | 15 | 6 |
| 10 | 45 | 10 |
Say a link costs 3 lakh to build (an example figure) and 20 per cent of that a year to keep alive, because someone's API changes, a field gets renamed, a certificate expires. With six systems wired point to point, that's 15 x 3 = 45 lakh to build and 9 lakh a year to maintain. With a hub, you pay for six adapters at 3 lakh plus perhaps 8 lakh for the hub itself: 26 lakh to build, with fewer places for a change to land.
With three systems, direct links are fine. Watch for the day a new system needs four new links, not one. Agree the data contract between systems first, so a change on one side is a visible, versioned event, and log every message so you can see where an invoice total changed. Most integration pain is the argument about which system was right.

Data portability and the exit test
Everyone says they can export your data. The test is whether you can, before you need to. Run it during evaluation, on a trial account with real-looking data, and treat a failure as a price.
| Exit test | Pass looks like |
|---|---|
| Export everything, not just reports | A complete export in a documented format (CSV, JSON, SQL dump) in under a day, without a support ticket |
| Round trip | Load the export into a scratch database and the counts match the source |
| API parity | The API can read everything the screens can, including attachments and history |
| Contract | A clause that returns your data on termination, a notice period, and a cap on renewal increases |
The second test is the one people skip, and you don't need a developer for it. Open the exported files in Excel, or ask whoever loaded the trial to, and do two things.
| Check | What to look for | What a hit means |
|---|---|---|
| Row counts | Count the rows in each exported file (customers, orders) and compare with the number the live system shows for the same thing | A lower count means the export dropped records |
| Orphans | In a spare column next to each order, look up its customer ID in the customers file, for example with COUNTIF. Any order that returns 0 has no customer | The order came across but its customer didn't, so the export is incomplete |
If the counts differ, or any order has no matching customer, the export is lossy, and you've learned what leaving would cost while it's still cheap to learn.
Signs you're being locked in
A proprietary format with no documented schema. Features reachable only through the vendor's services team. An API that exposes less than the screens do. Per-record or per-call pricing that bites as you grow. Renewals with no price cap. Custom software has its own lock-in: if one developer or agency holds the knowledge, you're locked in to them. The remedy is the same. Code and documentation sit in your repository, a second person has built it from scratch once, and the contract says who owns what.
How to scope a custom build so it doesn't balloon
Most overruns are scope growth, not slow coding. The fix is to decide, in writing and before starting, what the first release is for.
Pick one workflow. Rank your workflows by how often they happen and how much each failure costs. The top one is the first release. In the Pune example that might be quote-to-job-card, because every quote that takes two days is a lost customer. Everything else waits.
Write a cut list. Alongside what's in, write what's out, and get it signed. Reports, mobile apps, role hierarchies and "while we're at it" integrations belong on this list until the first release has been used for a month.
Define what version one must prove. A first release exists to answer a question, such as whether the shop floor uses it and whether quote time drops. This is also how we start custom engagements: a discovery workshop where we map your processes, model the domain and agree what version one has to prove.
Fix the rate of change. After release, reserve a fixed monthly allowance for changes, or every request becomes a negotiation.
Here is an acceptance checklist you can adapt. Don't pay the final milestone until every line is true.
- The one named workflow runs end to end on real data, done by the people who will use it, not by the developers.
- Every item on the cut list is still on the cut list, or has a written, priced change request.
- Staff can export their own data without developer help, and the export passes the round-trip test above.
- A removed user can no longer log in.
- There is a recorded restore from backup into a clean environment.
- The code, build instructions and a runbook sit in a repository you control, and a second person has built it from them.
- Monitoring alerts someone when the system is down.
- Maintenance terms, response times and the monthly change allowance are in the contract.
The hybrid approach, with an example
Often the right answer is neither. Buy the commodity parts, build only the piece that is yours, and connect the two with a defined interface.
Back to the Pune firm. Its accounts, GST invoicing and purchases are commodity, so it buys an ERP for those. Its edge is how fast and how accurately it quotes a job from machine-hours and material, so it builds only a quoting and job-card tool and connects it to the ERP, which receives the confirmed job as an invoice draft. The build is 14 lakh instead of 45, because it does one thing. Same method as before, with the ERP at 8 accounting users on 1,200 a month:
| Line (lakh) | How it's calculated | Cost |
|---|---|---|
| Build | quoted | 14.00 |
| Overrun allowance | 25% of build | 3.50 |
| Maintenance | 18% of 14.0 = 2.52 a year, years 2 to 5 | 10.08 |
| Hosting | 0.9 a year for five years | 4.50 |
| Integration with the ERP | 4.0 build, then 0.8 a year for four years | 7.20 |
| Enhancements | 1.0 a year, years 2 to 5 | 4.00 |
| Product owner | 20% of an 8.0 lakh salary, for five years | 8.00 |
| ERP licences | 8 users x 1,200 x 12 x 5 years | 5.76 |
| Total | 57.04 |
That is roughly half of either pure option, with the same caution: it assumes the ERP does the commodity work well and the seam stays small. If the two systems disagree about what a customer is, you've bought a reconciliation job.
For the commodity side, a product built for the job is usually right. Validure ERP, for example, is made for GST invoicing, purchases and double-entry accounts for Indian businesses, and it imports existing data from Excel and CSV. If that is the process you're looking at, buy something like it and put your design effort elsewhere. If you're weighing a custom piece beside one, our custom software development and API and system integration work covers exactly that seam.
How each side fails
| Typical failure | Early sign | |
|---|---|---|
| Buy | The tool fits 80 per cent, then the missing 20 per cent is where your staff live, in spreadsheets | A parallel sheet appears within three months |
| Buy | Costs grow faster than headcount: add-ons, tiers, API limits | Renewal quotes need a meeting |
| Build | Scope grows until release date is a rumour | The cut list is quietly shrinking |
| Build | Nobody owns it after the project ends | Only one person knows how to deploy |
| Build | You rebuild a commodity product badly, then maintain it | Half the feature list matches a product you could buy |
Failures on both sides come from fit and ownership, not technology.
When buying is simply right
Buy if the process matches your competitors', you have fewer than a dozen users, nobody wants to own a system, or you need it in weeks, and the product passes your exit test at your five-year headcount. Build, or build the edge, when the process is why customers choose you, or licences would overtake the build cost within five years. If you can't yet state what the process is, do neither: run it by hand another quarter and write down what hurts.
Sources and checks
Rates, thresholds and dates change, and parts of this post rest on press summaries, so check them against the official sources: the CBIC and the GST portal for e-invoicing thresholds, and the Ministry of Electronics and Information Technology for the Digital Personal Data Protection Act and Rules. The maintenance range of 15 to 20 per cent a year is a widely repeated rule of thumb from vendor and consultancy blogs, not a measured standard. Every rupee figure in the worked examples is an invented illustration to show the method; none is a quote or a benchmark.
Frequently asked questions
Is custom software always more expensive than buying?
No. Year one is almost always higher, but over five years it depends on user growth. A growing team on per-user licences can make a build cheaper. A stable team of a dozen on a standard process should buy.
How much should I budget for maintenance on a custom system?
A common planning range is 15 to 20 per cent of the original build cost per year, from the second year, plus hosting and a budget for enhancements. Ask whoever builds it what they see on systems they run, and put the figure in the contract.
What is the biggest hidden cost when buying?
The gap between what the product does and what staff need: workarounds, extra tools and re-entry. Count that time in the model.
Can I start with a product and build later?
Yes, and it's often the cheapest path, provided the product passes the exit test. Choose one that exports complete data and has an API that covers what the screens do, so the later build can take over one workflow at a time.
How do I stop a custom project running over budget?
Release one workflow first, keep a signed cut list, price every change, and hold back the final payment until the acceptance checklist is true. Overruns are mostly scope growth, which you can control.
Who should own the code?
You should, or at least have a documented right to it and a copy in a repository you control. If a single developer or agency is the only one who can run the system, you have a lock-in problem even though the software is yours.
