Total Cost of Ownership: Custom vs. Off-the-Shelf

The honest way to compare the total cost of ownership of custom vs. off-the-shelf software is over five years, not one. The year-one sticker price almost always favors buying an off-the-shelf product — lower upfront cost, faster to launch, easy to approve. But software is a multi-year commitment, and the costs that decide whether you made a good call show up in years two through five: per-seat licenses that climb as you hire, annual price increases, integration middleware, and the quiet drain of staff working around a tool that never quite fit.

This guide gives your finance team the full model, not adjectives. We at Craftware — a Microsoft Partner with 20+ years on the Microsoft stack — walk through every cost bucket, a worked 5-year table, the break-even year where a custom build overtakes a subscription, an NPV pass that survives a budget review, and a version priced on real Dynamics 365, Business Central, Power Apps, and Azure licensing. Every dollar figure is illustrative — verify against a current quote — but the method is the one we run for clients.

Total Cost of Ownership, Custom vs. Off-the-Shelf Software: The 5-Year Question

Total cost of ownership (TCO) is everything you pay to acquire, run, and maintain a system over its useful life — not just the license or the build invoice. Over a five-year horizon, two forces pull in opposite directions:

• Off-the-shelf (SaaS) starts cheap and gets more expensive every year — a rising curve driven by seat growth and annual price escalators.
• Custom starts expensive and then flattens — a big upfront spike, then a modest, roughly flat maintenance line.

Plot both as cumulative spend and they cross. Before the crossover, buying is cheaper; after it, building is. The whole decision comes down to one question: where is that crossover, and is your realistic time horizon longer than it? The rest of this article shows you how to find that point for your own numbers.

What Actually Goes Into TCO: Every Cost Bucket That Matters

Most comparisons weigh only the license fee against the build fee. That's the mistake. A defensible model itemizes both stacks completely — including the costs vendors and agencies leave off their slides.

The Off-the-Shelf (SaaS) Cost Stack

• Subscription / per-seat licenses — the headline number, and the one that scales with headcount.
• Implementation and configuration — setup, data mapping, and rollout, often a one-time fee that rivals the first year of licenses.
• Customization and add-ons — premium tiers, modules, and connectors you discover you need after go-live.
• Integration and middleware — the iPaaS or connector subscriptions needed to make the tool talk to your other systems.
• Training and onboarding — initial and ongoing, as new hires keep arriving.
• Annual price escalators — most SaaS contracts allow renewal increases; 5–15% a year is common.
• Hidden workaround labor — staff hours on manual exports, re-keying, and reconciliation when the software doesn't fit your process. The single most underestimated line.
• Exit and switching costs — data extraction and migration when you eventually leave.

The Custom-Build Cost Stack

• Build cost — the fixed-scope development investment, usually phased.
• Overrun contingency — the honest line most agencies skip. Custom projects carry scope and estimation risk; a prudent model reserves 10–20%.
• Annual maintenance — bug fixes, security patches, and minor updates. Consensus lands at 15–20% of the build cost per year; we use 18% below.
• Hosting — cloud infrastructure to run it (Azure, in our world), billed on consumption.
• Enhancements — new features as the business evolves. A benefit, not just a cost: you spend it on what you need, not a vendor's roadmap.

Notice what's not on the custom side: a per-seat licensing tax. Adding your 200th user to a custom application costs essentially nothing; adding your 200th SaaS seat costs another full subscription — every month, escalating.

The 5-Year TCO Table: A Worked Custom Software vs Off-the-Shelf Cost Comparison

Here's a realistic mid-market scenario: a services firm replacing spreadsheets and a generic tool with a proper operations-and-billing system, starting at 50 users and growing to 150 over five years. All figures are illustrative — verify against a current quote — but they're internally consistent and reflect patterns we see repeatedly.

Assumptions: SaaS at $100/user/month, escalating 8% a year; seats grow 50 → 70 → 100 → 125 → 150. Custom build of $220,000 with 15% contingency, 18%/year maintenance beginning after go-live, and Azure hosting at ~$18,000/year.

Off-the-shelf (SaaS) — 5-year TCO

Custom build — 5-year TCO

Over five years, custom lands at $527,000 against off-the-shelf's ≈$932,000 — roughly $405,000 (43%) lower. Yet in Year 1 alone, off-the-shelf costs $153,000 and custom $283,000. Judge on the first invoice and you'd buy — and over this horizon be $405,000 worse off.

A fair caveat: the biggest swing factor is fit. The $90,000 of workaround labor exists only because the off-the-shelf tool doesn't match this firm's process. If a product genuinely fits out of the box, strike that line — off-the-shelf drops to about $842,000 here and break-even moves later. Fit is worth more than any discount.

And custom carries its own risks a fair model respects: projects can overrun (that's the contingency line), an under-maintained codebase accrues technical debt, and leaning on a single developer or vendor is real key-person risk. Price those in — with disciplined scope, a maintenance budget, and a partner who won't lock you in — rather than pretending they don't exist.

See the Crossover: The Custom Software Break-Even Point

The 5-year totals tell you who wins; cumulative spend tells you when. This is the custom software break-even point — the chart every competing article mentions but none actually draws.

The two lines cross partway through Year 3 — about month 33 in this model. Before that point the subscription is genuinely cheaper; after it, custom pulls away fast, because the SaaS curve keeps climbing while the custom curve stays flat. By Year 5 the gap is a still-widening $405,000.

The practical rule: if your realistic time horizon comfortably exceeds the break-even year, build; if it's shorter, buy. Most systems that matter run well past their crossover — which is exactly why year-one thinking so often leads to the wrong call.

The Hidden Costs of Off-the-Shelf Software

The reason off-the-shelf TCO surprises people is that its most expensive lines are the least visible at purchase. When you're evaluating a demo, you see the per-seat price. You don't see these:

• Per-seat scaling. At $100/user/month, going from 50 to 150 users triples your license bill before any price increase. Per-seat licensing turns headcount growth into a rising liability.
• Price escalators. An 8% annual increase compounds: the $1,200/user Year-1 rate reaches roughly $1,633 by Year 5 — a 36% climb layered on top of seat growth.
• Tier and license creep. The feature you need is one plan up; the integration you need requires the premium connector tier. Real-world spend drifts above the advertised rate.
• Middleware subscriptions. Making a SaaS product exchange data with your ERP, accounting, or CRM usually means a paid integration platform — an annual cost missing from the original comparison.
• Workaround labor. When the tool can't do what your business needs, people bridge the gap by hand. Half an FTE on manual reconciliation is $30,000–$40,000 a year that never hits the invoice.
• Switching costs. Leaving means extracting and migrating your data and retraining everyone — a barrier that also weakens your leverage at renewal.

None of this makes off-the-shelf a bad choice. It makes it a choice whose true cost you have to model, not assume.

The Build vs Buy Software Cost Analysis Formula (Paste It Into Excel)

You don't need our calculator to run the numbers — you need the model behind it. Here is the dual formula in plain terms.

Off-the-shelf, per year (then sum across years):

OTS_year =
  (monthly_license × users × 12 × (1 + escalator)^(year − 1))
  + implementation (year 1)
  + integration + middleware
  + training
  + workaround_labor

Custom, per year (then sum across years):

Custom_year =
  build × (1 + contingency)          [year 1 only]
  + (maintenance% × build)           [each year after go-live]
  + hosting
  + enhancements

Break-even is the year cumulative Custom first drops below cumulative OTS. To make it defensible, discount every future year to present value before comparing (next section). And grow users year over year — a static seat count is the most common way these models understate off-the-shelf cost. Prefer not to build the spreadsheet? We'll send you our ungated model preloaded with these formulas; just ask below.

Finance-Grade Modeling: NPV, CapEx vs. OpEx, and Sensitivity

A skeptical controller will push on three things. A good model answers all three.

1. Net present value (NPV). A dollar spent in Year 5 is worth less than one spent today, so raw totals slightly overstate the advantage of the option whose costs come later. Discounting fixes that. At a 10% discount rate:

Discounting narrows the gap (custom's costs are front-loaded, so they discount less) and pushes the break-even about two months later — but custom still wins clearly. When the conclusion survives NPV, it's real, not an artifact of ignoring the time value of money.

2. CapEx vs. OpEx. A custom build is often capitalized and depreciated over its useful life; SaaS subscriptions are operating expenses paid as you go. That changes how each hits your P&L, cash flow, and sometimes your tax position — SaaS is smoother month to month, custom is a larger upfront outlay you write down over time. Which is preferable depends on your capital position and accounting policy, so it's a conversation for your controller.

3. Sensitivity. The break-even year moves with your assumptions. It arrives sooner when headcount grows faster or the SaaS escalator is steeper; later when seats stay flat, the product genuinely fits (no workaround line), or your discount rate is high. Run optimistic, expected, and pessimistic cases — if custom wins in the expected and pessimistic ones, the decision is robust.

Priced on the Microsoft Stack: Dynamics 365, Business Central, Power Apps, and Azure

Generic figures illustrate the method; your real numbers come from real licensing. For a Microsoft-centric business, here's how the same model prices out. List rates below are illustrative and change — confirm current pricing on Microsoft's site before you budget, and Business Central is sold through Cloud Solution Provider partners, so effective rates vary.

Two things stand out for a Microsoft shop:

• Off-the-shelf here means named-user licensing. Whether it's Business Central or a Dynamics 365 app, you pay per seat, tiered by capability. Right-sizing tiers helps (many users need only Team Members or read access via an existing Microsoft 365 license), but the per-seat curve still climbs with headcount.
• Power Apps is the low-code middle path. At roughly $20/user/month (Premium plan), a Power Platform app is cheaper to stand up than a fully custom build and more flexible than rigid off-the-shelf software — but you're back on a per-seat model with real ceilings on complexity and data volume. For a stable, well-defined workflow it can be the lowest-TCO option of all; for a core system meant to scale, it's a stepping stone.

The custom side runs on Azure consumption, not per-seat licensing — which is why its curve flattens. A mid-market line-of-business app might cost $1,000–$2,500 a month to host whether 50 or 500 people use it. That is why custom TCO decouples from headcount.

A Representative Example: Mid-Market Services Firm

To make the model concrete, here's a representative scenario — an illustrative composite, not a specific named client, with clearly-illustrative ranges rather than fabricated hard numbers.

A ~120-person services firm ran billing on a generic subscription tool plus a lattice of spreadsheets. On paper the SaaS cost looked modest — well under $150,000 a year in licenses. But two people spent roughly half their time each on manual exports and reconciliation, because the tool couldn't model the firm's contract structure; every new client cohort added seats at a renewal rate that had risen three years running. With integration middleware on top, the true run-rate ran well above the license line.

Modeled over five years with seat growth and the escalator, a custom billing application on Azure — with the manual reconciliation designed out — reached break-even in the third year and opened a six-figure cumulative gap by year five. The decisive number was never the build price; it was the workaround labor and per-seat growth the spreadsheet comparison ignored. That is the pattern behind nearly every build-vs-buy case we see.

When Off-the-Shelf Still Wins

Balance matters, so let's be direct about when not to build. Off-the-shelf is the better-TCO choice when:

• Your user base is small and stable. Per-seat economics only hurt when seats multiply. Fifteen users who won't grow rarely justify a custom build.
• The process is genuinely standard. For commodity needs — email, accounting basics, standard CRM — a mature product fits well, the workaround line disappears, and you inherit years of vendor R&D for a low monthly fee.
• Your time horizon is short. If the system only needs to last two years, you may never reach the crossover.
• Speed to value outweighs five-year cost. Sometimes launching next month beats saving money in year four — a legitimate business call.

The goal isn't to build everything — it's to know which side of the crossover your situation lands on, and to make the call on a complete five-year model instead of a year-one invoice.

Frequently Asked Questions

What is the total cost of ownership of custom vs. off-the-shelf software? It's the full multi-year cost of each option, not the upfront price. Off-the-shelf TCO includes subscriptions, implementation, integration middleware, training, annual price increases, and hidden workaround labor. Custom TCO includes the build, a contingency reserve, ~15–20%/year maintenance, and hosting. Because off-the-shelf costs rise with headcount while custom stays flat, the comparison hinges on your horizon and growth — not the first invoice.

At what point does custom software become cheaper than off-the-shelf? For a growing mid-market team, the break-even typically lands around year three — about month 33 nominally, or month 35 after discounting to present value, in the scenario above. It comes sooner if you're adding users quickly or your SaaS price escalates steeply, and later if seats stay flat or the product fits without workarounds.

What are the hidden costs of off-the-shelf / SaaS software? The ones that don't appear in the demo: per-seat costs that scale with hiring, compounding annual price increases (often 5–15%), tier and license creep, paid integration middleware, staff time on manual workarounds when the tool doesn't fit, and data-extraction costs when you switch. These routinely add up to more than the license fee over five years.

What percentage of the build cost is annual maintenance? The industry consensus is 15–20% of the original build cost per year, covering bug fixes, security patches, and minor updates; we use 18% in our model. Enhancements — new features you choose to add — are budgeted separately, and that spend goes toward what your business actually needs rather than a vendor's roadmap.

How do you calculate 5-year TCO for build vs. buy, with NPV? Project each option's cost for every year, growing the SaaS seat count and applying its price escalator; sum implementation, integration, training, and workaround labor on the buy side, and build-plus-contingency, maintenance, and hosting on the build side. Discount each future year to present value (10% is a common default) and compare the cumulative curves. The year custom's discounted cumulative cost drops below off-the-shelf's is your NPV break-even.

Get a Free TCO Analysis for Your Situation

The model in this article is the same one we run for clients — and we'll run it on your real numbers. Give us your seat count, growth plan, and Microsoft licensing, and we'll return a defensible five-year build-vs-buy figure, your break-even year, and an honest recommendation — including when the answer is to keep buying. As a Microsoft Partner delivering through a Human + AI model, we've shrunk the traditional cost and timeline penalty of going custom, which shifts the break-even math in more companies' favor than it used to. Book a free TCO analysis and get a number you can take into your next budget meeting.