Build vs buy: choosing between custom software and off-the-shelf packages

For every board, CTO or management team facing the choice between a standard package and a platform of their own. This page isn't a sales pitch for custom software; it's an honest assessment. When does a COTS solution deliver more value than a custom build, and when is it the other way round? We walk through the real decision factors: total cost of ownership, vendor lock-in, package fit, time-to-value and the strategic question of whether the process is your competitive advantage or a commodity. Want to read more? Also see website development costs.

Build vs buy Package vs custom TCO analysis Vendor lock-in Package fit
Request an independent assessment Go to the decision tree
BUY BUILD VS

Build vs buy: a decision that has little to do with software

Most build-vs-buy discussions get stuck in feature comparisons. "Package A has 84 modules, our process needs 12 specific adjustments, so we have to build." That's the wrong level. The real question is strategic: is this process your competitive advantage, or is it a commodity? A logistics company that earns its margin from unique planning algorithms shouldn't outsource that logic to a vendor. A law firm that differentiates itself through the quality of its case files has no need to build its own time-tracking system. Want to read more? Also see AI agents for businesses.

Geoffrey Moore calls this core versus context. Core processes deserve investment in custom software because they contribute directly to your differentiation. Context processes, such as accounting, payroll and generic CRM flows, are best handled by packaged software because the market already offers mature solutions. The mistake boards often make is building custom software for context (expensive, no ROI) or forcing packaged software onto core processes (friction, rising modification costs, and vendor lock-in limiting every step forward).

There is also a second dimension that usually gets overlooked: pace. How often does the process change? A process that changes structurally every year, through new regulations, new business models or new markets, rarely fits a package with quarterly release cycles. A process that has been unchanged for ten years and will stay that way for another ten is ideal for COTS (Commercial Off-The-Shelf). So build vs buy isn't just about what you build, but also about how fast it needs to keep up and who pays for the friction.

Six reasons to build versus six reasons to buy

Not a marketing checklist, but the six arguments that consistently prove decisive in practice, on both sides of the decision.

When build (custom) wins

1. The process is your differentiator. If the way you work is the reason customers choose you, the logic should be in your own hands too.

2. Package fit is structurally below 70%. Below that threshold, the cost of modifying a package over a 5-year horizon almost always exceeds the cost of building custom software.

3. Vendor lock-in is a strategic risk. For processes that affect your cash flow, you don't want a supplier who can unilaterally reprice or stop supporting the product.

4. Integration requirements are fundamental. Deep integrations with specific ERP modules, industry APIs or legacy systems are often only supported superficially in off-the-shelf software.

5. Economies of scale lie in data processing. If processing costs money per transaction and you handle millions of them, it pays to own that layer yourself.

6. The process changes faster than release cycles. Package vendors plan functionality for the whole market; your business can't wait.

When buy (off-the-shelf / COTS) wins

1. The process is a commodity. Accounting, time tracking, leave administration: these are solved problems, and there's no need to reinvent the wheel.

2. Time-to-value is critical. A package implementation can be live within weeks; custom software requires a design phase, build, testing and stabilisation that take anywhere from several months to years.

3. Compliance is locked down. Off-the-shelf software in financial domains (accounting, payroll, tax returns) is often already certified, and that is a burden you rarely want to carry yourself.

4. The volume does not justify a custom build. For twenty users and a hundred transactions a day, a custom platform is overkill.

5. Package fit is high (>85%). Above that threshold, the TCO advantages of off-the-shelf software almost always outweigh the gains of custom software.

6. There is a healthy vendor market. Competition keeps price and quality in check; switching costs are then acceptable as long as alternatives are available.

Cost curves: off-the-shelf vs custom over a 3 to 5-year horizon

Total cost of ownership is the only sensible yardstick. If you only look at the entry price, you will usually choose wrongly. The two curves develop in fundamentally different ways.

The package curve: low start, rising tail

Off-the-shelf software starts cheap. A licence per user per month, an implementation of a few weeks, and you're up and running. But the curve climbs. Per-user monthly fees grow linearly with your organisation. Modification costs come on top as soon as package fit drops below 80%, and they build up with every release. Integrations with other systems require partner hours or expensive connector licences. Switching costs pile up the more custom work you build on top of the package.

By year 5, expect total TCO of 2x to 4x the entry price if package fit deteriorates.

The custom curve: high start, flatter tail

Custom software requires a substantial upfront investment: analysis, design, build, testing, deployment. After that, you run on hosting costs plus a development budget that you set yourself. The curve flattens once the platform is stable. No per-user licences. No vendor who can unilaterally set prices. The maintenance load is predictable if the architecture is set up correctly. Opportunity cost (what you gain because the system fits exactly) starts working in your favour.

The break-even point typically falls in year 4 or 5 for many organisations with more than 50 daily users, or where package fit is insufficient.

The mistake made most often is comparing only year 1. A package that starts at €50,000 and reaches €180,000 a year by year 3 loses out to a €250,000 custom build that costs €40,000 a year to maintain by year 4. Run the TCO calculation over at least 5 years, and include opportunity cost: what do you earn extra (or save) because the system fits your process exactly?

Build-on-buy: the hybrid model that often wins

In practice, build-vs-buy is rarely binary. The most successful architectures we come across are hybrid: a strong off-the-shelf package for the commodity layer, plus custom development for the processes that genuinely set you apart. This is called build-on-buy, and for many mid-sized organisations it is the best route.

A concrete example: a trading company uses Exact Online for its financial administration (commodity, locked down, certified) and builds on top of it its own trading platform with dynamic pricing, stock allocation and a customer portal (core, differentiating, integration via API). Another example: a training provider uses a standard payroll package but builds a custom LMS because the learning pathway itself is the product. In both cases they win on two fronts: low TCO on the boring layer, high value on the strategic layer.

What this model requires is a well-thought-out integration layer. That means API-first thinking, middleware that connects the package and the custom software, and clear agreements on which system is the leading source for which data. If you set this up badly, you end up with two sources of truth and permanent data friction. If you set it up well, you get the best of both worlds.

Build-on-buy also makes MVP validation easier. You can start with a package to validate whether a process works, and only later — once volume and differentiation justify it — move to custom software for specific components. That reduces the risk of a large up-front investment that may turn out not to fit.

Six sectors and the typical outcome of the trade-off

No sector has a fixed answer, but there are patterns. Below is the outcome we see most often in each sector, along with the rationale behind it.

Logistics and transport

Often hybrid. A standard TMS package for the basics, with custom development for planning algorithms and a customer portal where those make the difference in the market. Package fit for planning is usually below 70% for specialist carriers.

Care and healthcare

Often buy, with a thin custom layer. Strict compliance requirements make building a new EHR package virtually unfeasible. Custom work comes in with patient engagement, integrating your own measuring equipment and record extensions.

Construction and installation technology

Often build or hybrid. Packages such as Bouw7 cover part of the need, but project-specific cost estimating, materials management and site apps are generally differentiating and worth building yourself.

Retail and e-commerce

Often build-on-buy. Shopify/Magento for the shop, custom development for PIM flows, a B2B portal or fulfilment logic. Package fit for pure retail is high; for operations it is often low.

Financial services

Often hybrid with a strong build component. Compliance packages for KYC and AML, custom development for advisory flows, pricing engines and customer portals that make the difference.

Manufacturing and industry

Often build for MES/operations, buy for ERP. Production processes differ so much from factory to factory that MES packages rarely fit well. ERP does fit — there the standard solution usually wins.

The decision tree: four questions that make the choice

A simple sequential test. Answer them in this order — the first one that gives a clear "yes" or "no" usually gives you the answer.

Is it core or context?

Does the process define what sets you apart in the market? Then build is worth serious consideration. Is it a commodity (accounting, payroll)? Then buy is almost always better.

What is the package fit?

Above 85%, the package wins. Below 70%, custom wins. In between: look at build-on-buy, or an adaptable low-code platform as an intermediate solution.

What is the 5-year TCO?

Calculate licence + modification + integration + switching costs. Compare that with build cost + maintenance + opportunity cost. Make it quantitative, not emotional.

How quickly does the process change?

Does the process change structurally within the package's release cycles? Then a package fits. Does it change faster (regulation, market pressure, business model)? Then custom software is more agile.

After these four questions, the direction is usually clear. If the outcome is not obvious — and that happens — build-on-buy almost always emerges as the best hybrid. Ask for an independent assessment from someone who implements both packages and custom software; anyone who does only one or the other will, by definition, give biased advice.

Frequently asked questions about build vs buy

What is the difference between COTS and custom software?
COTS stands for Commercial Off-The-Shelf: ready-made packaged software that you license and configure. Custom software is designed and built specifically for your organisation. COTS offers fast time-to-value and familiar features; custom software fits your process exactly and avoids vendor lock-in on your business logic. The choice is rarely about technology and almost always about how unique the process you are supporting is.
When is packaged software the smart choice?
For commodity processes where the market already has mature solutions: accounting, payroll, time tracking, generic CRM. Also where compliance requirements are high and certification would cost more than you want to bear yourself. And where package fit is above 85%, in which case the TCO advantages almost always outweigh the gains of custom software.
When is custom software the right choice?
When the process is your differentiator, when package fit is structurally below 70%, when integration requirements are deep and specific, when the scale advantage lies in owning the data-processing layer, and when the process changes faster than a package vendor's release cycles. In practice, that means the processes that truly set you apart in the market.
What is build-on-buy and when does it work?
Build-on-buy is a hybrid model in which you use a strong package for the commodity layer and build custom software on top for your differentiating processes. It works best when the integration layer is well set up, with an API-first architecture and clear agreements on which system is the leading source for which data. For mid-sized organisations, this is often the best route.
How do I calculate the TCO of a package versus custom software?
Calculate over at least five years. For a package: licence costs per user, implementation, modification costs once fit deteriorates, integration hours, and switching costs if you want to move later. For custom software: design, build, deployment, hosting, maintenance and further development. Also factor in opportunity cost: what does a better fit deliver, or what does friction cost you each year? Anyone who only compares year 1 will almost always choose wrongly.
How risky is vendor lock-in with packaged software?
It depends on the market and the type of process. For processes that affect your cash flow, vendor lock-in is a strategic risk: a supplier can reprice unilaterally, wind down support or push through a roadmap that doesn't suit you. For commodity processes with a healthy, competitive vendor market, lock-in is manageable because alternatives are available. So the question is always: how critical is this process, and how easily could I switch?
What is a good package-fit threshold for making the decision?
As a rule of thumb: above 85% package fit, COTS almost always wins on TCO. Between 70 and 85%, the choice depends on strategic factors: is it core or context, how quickly does it change, how much modification cost are you willing to accept? Below 70%, modification costs over a 5-year horizon almost always exceed the cost of building custom software, and build-on-buy or fully custom software is advisable.
Can low-code be a middle path?
Yes, for specific cases. Low-code platforms (Mendix, OutSystems, PowerApps) offer faster time-to-value than fully custom software and more flexibility than packages. They work well for internal tooling and non-critical workflows. For core processes, high scale or complex integrations, low-code platforms often hit limits anyway, and then the build-vs-buy question comes back around.

An independent build-vs-buy assessment

We implement both packages (Exact, AFAS, Shopify, Bouw7) and custom software. That lets us honestly weigh up which route will help you most, not which route suits us best.

Schedule a no-obligation conversation

If you're leaning towards building it yourself, it helps to see what custom software looks like in practice in your sector. On applatenmaken.com you'll find an overview of custom software by sector and process.

Edit content