Customizable ERP vs Custom ERP: What You'll Actually Pay

A company decided to build something simple on top of a major CRM platform. Platform license, $25 a user a month, a few custom objects — $875 a month for 35 people seemed achievable. Somewhere along the way, they used two objects out of the core CRM: cases and opportunities. Same login they'd been looking at for months. Nothing on the screen said those objects were different.

At go-live — when it was too late to do anything but pay — they learned that touching those objects reclassified every user onto the $175 license. The bill went from $875 a month to $6,125: roughly $63,000 a year they hadn't planned, on a product that was already a square peg in a round hole. They carried it about two years, because leaving was more expensive than suffering. Until it wasn't.

Why would anyone have known to ask? That's what this article is for: how to calculate what any of this will actually cost you, when a platform is the right answer, and when you're paying serious money to force your business into the wrong shape. We sell custom software — we have an interest — and our pricing is in three tables near the end, same formula as everyone else. Everything before the tables is what makes them readable.

Why can't I find a straight price for this software?

Some vendors publish prices: HaloPSA, Microsoft Dynamics 365 Business Central, Odoo, and the unified RMM+PSA tools all put numbers on a page. Some price on consumption rather than seats: Acumatica. And some don't publish at all — ConnectWise, Autotask, and NetSuite will quote you after a sales conversation.

After decades on the buyer's side of these quotes, I have rarely seen a salesperson try to screw a client the old used-car way. What I see is market pricing: these vendors go to the same conferences, chase the same customers, and after a while they're pricing each other. The internet knows everything — you can more or less backtrack into the numbers.

So the entry price is fair. The full price is fair. The trap is the gap between them. The pricing works like a cell phone plan: it appears you're getting something for something, and to get the one little thing more you actually need, you pay the full pricing. The price isn't hidden because it's high — it's hidden because it's assembled: seat plus implementation plus modules plus escalation. No single number is honest in isolation.

Your first tool: never compare seat prices — compare assembled prices.

What's actually inside the price?

First, the terms, because the market uses them loosely. A customizable ERP is a platform built to be adapted — configuration (settings, no code) and, past that, customization (code in the vendor's proprietary extension layer). A custom ERP is built for one business; when people say bespoke ERP or custom ERP development, that is what they mean. The cost line: configuration is included in the price you were quoted; customization has its own developer market and its own recurring bill, and a heavily customized ERP can end up costing more than a custom ERP system built to fit.

The low band: software you configure yourself, or thin enough that there's nothing to configure. You're buying a starting point and deferring setup labor onto your own team.

The medium band is a real product with a real implementation, and it's where most buyers land. It's also where most of the market's published anger lives — almost all of it billing and invoicing: engines powerful enough for anything and complex enough that firms hire specialists or buy bolt-on tools just to reconcile invoices [reported]¹. The anger is real, but it's an outcome of misfit — the gap gets bridged with spreadsheets and external tools that don't talk to the original system. If the product doesn't match the workflow, neither will the billing.

The high band is deep machinery, long implementation, and ecosystem lock. Some firms genuinely need it — that case comes in the final section.

Three mechanisms move the number after you've signed:

1. The API paywall. Some vendors gate API access behind a higher tier. An API — let alone MCP — is now the bare minimum for connecting anything to anything, and a buyer who doesn't know what one is can skip it at signing and discover the gap at the first integration.
2. Migration fine print. The problem is scope: what will and won't be migrated. I have unfortunately seen the fine print that amounts to "we'll recreate your customer record, and you're going to do the rest."
3. The user-type trap. Per-seat pricing that doesn't match how your people actually use the product — the mechanism in the opening story. Before you sign, verify with evidence that your user-type assumptions hold, and that no business process will quietly upgrade everyone to a better user type.

How much does an ERP system really cost over three years?

One formula turns any quote into a comparable number:

Unified monthly cost = license + (one-time costs ÷ seats ÷ months)

Example: a 20-tech firm, $85 per seat, $30,000 implementation. $30,000 ÷ 20 seats ÷ 36 months = $42 — so the real number is $127 per seat per month, not $85.

Run six PSA vendors with three pricing philosophies through the formula: tools of comparable depth land in the same band regardless of how they price. Same for the mainstream ERPs, where software is typically 20–30% of first-year project cost and implementation and related services run 50–70% [reported — ERP Research]². Vendors choose when to collect, not how much — the philosophy you're quoted under tells you almost nothing about what you'll pay.

What the formula can't capture is escalation. One leading mid-market ERP's full-user license rose roughly 30%, an increase reported as standard at recent renewals [reported]³; Kaseya's published Master Agreement caps automatic-renewal increases at 5% plus CPI [published]⁴ — a cap on automatic renewals, not on separately quoted ones — with reported short-term increases running higher [reported]⁵. Beyond documented increases, there's incumbent behavior I've watched across industries: evergreen contracts, features quietly dropped, a "new" platform with "new" pricing while the old one you're on gets updated about as often as Wednesday's child gets hugs. Flat pricing doesn't do this. Per-seat pricing does, and it compounds.

What costs never show up on the quote?

Your own people's time. One client of ours ran a system that didn't talk to QuickBooks. The export and import weren't matched, so the automated part moved invoice numbers and totals — human beings did everything else: creating accounts and jobs, reconciling changes, keying receivables into invoices. Invoicing finished around the 21st of each month, consuming close to a full-time equivalent across two or three people. After we rebuilt it, the same invoicing runs in one to two hours, because the fields are captured correctly at the point of work. That was tens of thousands of dollars a year of internal labor that never appeared on any vendor's quote.

Price your team's workshops, data cleanup, testing, and training the same way; external help runs $150–$350 an hour, with large integrators above that [reported]⁶.

The bolt-on economy. Reconciliation tools, payment portals, CPQ, connectors — one analysis of a major PSA ecosystem calls it the integration tax [reported]⁷: a second billing tool plus a connector because the base product can't bill cleanly.

Customization inside walled gardens. Every platform has a proprietary customization layer — SuiteScript, AL extensions, xRP, Studio — each with its own developer market ($95–$300 per hour in reported ranges⁸) and a recurring cost most buyers miss: custom code carries an ongoing compatibility obligation, testing against platform releases, with some releases requiring paid remediation [reported]⁹. You pay for the deviation at build, then keep paying as the platform moves underneath it.

Two of my clients ended up on manufacturing packages from the same legacy roll-up vendor — one with 1970s origins that didn't support lowercase letters, one born in Visual FoxPro. The deeper problem wasn't the vendor's wall. After years of accumulated, well-intentioned changes, one client wasn't on the product anymore — they were on a platform of one sharing its name. "We can't move, it's complicated," while the product lost its backing and changed hands. One was quoted about $45,000 just to export some data, against roughly $50,000 the software had cost. When we took the project, we pulled the data's shape and indexes and hand-extracted the subset that mattered; the rest of the "impossible" migration cost was learning how the company actually works — money they'd spend with anyone. The alternative was moving their technology debt to another bank, or credit card.

Overrun risk. Gartner projects that by 2027 more than 70% of recently implemented ERP initiatives will fail to fully meet their original business-case goals [published — Gartner]¹⁰. Panorama's latest study reports more than a quarter of organizations exceeding their project budgets [published — Panorama]¹¹. Carry a caveat with all failure statistics: an academic review traced the most-quoted figures back to a personal estimate given in 1998, not empirical research [reported]¹². Budget the shape, not the number.

After forty years of building: custom software fails for one reason, one hundred percent of the time — lack of commitment from the parties to understand the business processes and do what's necessary. Remove that, and everything else is survivable. The overrun causes secondary reporting attributes to Panorama's research — understaffing (38%), scope expansion (35%) [reported]¹³ — are commitment failures by other names. It's why our engagements run on detailed goalpost-setting and a weekly meeting that is the clearinghouse for every decision: that structure is how we're hired, and it's the contractual form of good faith.

And our own disclosure, because overruns are the argument against fixed-price builds. We have never blown a client's budget. We have blown our own — twice, eating into our profit: once underestimating how hard it would be to dig data out of a 1970s-era Basic platform, once assuming a widely used booking platform's API would work — its search succeeded roughly 25% of the time. We absorbed both. Once we told a client our assumptions were wrong — and the goodwill turned into a project expansion. A blown budget is everybody's problem: get a contractor to do a $500,000 project for $200,000 and they won't do it happily, or well, or with much relationship left. It's in both parties' interest to be upfront.

Take this checklist into every sales call — ours included: API access at your tier; migration scope in writing; user-type assumptions verified with evidence; internal labor at loaded cost; the bolt-ons your workflow will require; customization rates and re-verification cost; renewal escalation terms; and the overrun conversation, out loud.

So what are the real numbers?

All figures are [estimate] blends of the sources above, computed with the unified-monthly formula at 20 seats over 36 and 60 months. Ours, for custom ERP solutions, are first-party, same formula, no favors.

Table 1 — PSA

Band	$/seat/mo (unified)	3-yr TCO	5-yr TCO
Low (unified RMM+PSA, published pricing)	$80–$180	$60K–$130K	$95K–$215K
Medium (dedicated PSA, published or quoted)	$75–$155	$55K–$110K	$85K–$165K
High (quote-only, bundled ecosystems)	$140–$250	$100K–$180K	$155K–$275K

Incumbent pricing checked August 2026; vendor list prices change, so re-check before relying on a figure.

(Low overlapping medium is not an error — unified tools bundle RMM, so the bands differ in what's included.)

Table 2 — ERP

Band	$/seat/mo (unified)	3-yr TCO	5-yr TCO
Low (published per-seat, light implementation)	$35–$130	$25K–$95K	$40K–$150K
Medium (published per-seat, partner-implemented)	$165–$320	$120K–$230K	$155K–$285K
High (quote-only or consumption-priced)	$220–$390	$160K–$280K	$245K–$430K

Before our table, the contrast in one sentence: a platform means adapting your business to a generalized data model and paying to customize the exceptions; a custom build means modeling the system around the way the business actually works — and keeping ownership and the marginal cost of a seat.

The custom build is us doing the work — what that looks like for an ERP is on Custom ERP Systems. The honest timeline:

Working system, with your data in it: weeks 4–6 Build: 6–10 weeks Business rollout and tuning: often longer

The build time is genuinely the build time. Engagements run longer because the real work is tuning the company, not running software — a weekly meeting clears every decision, so by go-live everyone has been using the system for weeks and the launch is the most boring thing in the history of boring things. The lease tiers are the same platform without us doing the building: self-serve, your own accounting-side or quasi-IT person builds; guided, we run that same process on periodic calls while your team supplies the elbow grease.

Table 3 — PurpleOwl (first-party)

Tier	Structure	$/seat/mo (unified, 20 seats)	3-yr TCO	5-yr TCO
Custom build	$100K–$400K one-time + 10%/yr support	$180–$720	$130K–$520K	$150K–$600K
Guided lease	$1,800/mo ($300 platform + $1,500 guidance) + tokens	$90	$64.8K	$108K
Self-serve lease	$300/mo + tokens	$15	$10.8K	$18K

Honest annotations, first-party: the $400K end of a custom build overlaps and can exceed the ERP high band — there, fit and ownership are the argument, not price. The 10% annual support covers bug fixes, questions, quarterly steering, and minor drift like added fields; a genuinely new subsystem runs in $5,000–$10,000 increments. Tokens run roughly $1–$2 per built item — a dashboard widget with charts, gauges, filters, export — and a full system rarely exceeds a hundred items, so setup token spend totals a couple thousand dollars, wrong turns included. Tokens are excluded the same way SaaS add-ons were excluded above; internal labor is excluded from every table here, including ours. And what no table shows: per-seat columns can compound with escalation and headcount, flat columns don't — marginal seat cost quietly decides the 5-year winner.

When do you have no choice?

Full stop, you buy a platform. Software is a machine — somebody has to maintain it as the business, the software, and the regulations change. If the software doesn't matter to the business, don't build custom. If the whole win is making life easier for one person in accounting for ten hours a month with no P&L impact, that's not where a growing company should spend. Commodity processes, no internal owner for requirements, or regulated contexts where a platform's certifications do compliance work you'd pay for anyway — buy. And if you're sitting on a broken homegrown system, the first question isn't which software to buy next. It's what process got you there, and whether you're willing to change it — because software doesn't change people. People change their behavior, and software is a great tool to make that happen.

Full stop, you build. A custom ERP is the answer when the platform structurally can't hold the business. One company I worked with sold a highly customized product with highly customized delivery, on a lightweight CRM that looked sufficient. Their business sold exclusivity: order uniqueness calculated across customers, with waitlisting when two clients wanted the same thing. That's not a missing field — it's a shape the product's data model has no place for. Everything worked in the sunny-day scenario and broke the moment two orders had to coordinate. They grafted structured tables onto it, then a second system onto that, and it still couldn't hold.

The diagnostic I use is the shouting limit. Between roughly 35 and 50 people, you can still resolve the exception cases by yelling across the company. Past that, you can't — if your exceptions are resolved by shouting, count your heads.

The other build cases: per-seat math breaking your unit economics at your growth rate, and having already paid for so many platform customizations that the walled garden owns you — one reported case: a SaaS company whose 45 recurring-billing customizations made switching cost more than three years of license fees [reported]¹⁴.

The third case nobody prices: the tiger by the tail. The most expensive option on the table is usually the unmade decision. One company chose to "stick with what they have" because their environment was so broken it left no time or clarity to move forward — which was precisely the problem statement. What felt like a one-quarter delay is still unresolved many quarters later. Software is no magic wand — but the cost of holding the tiger accrues monthly, invisibly, and never appears on anyone's quote.

Most readers live in the middle between the full stops — the tables above are how you price it.

Run the formula on your own quotes

Three tools: the assembly formula, the internal-cost checklist, and the full-stop tests. Our pricing is in the tables above on the same terms as everyone else's. The systems themselves are at Custom ERP Systems and Pricing. Take the quotes you're holding, run the formula, and compare assembled numbers — never seat prices.

---

Competitor figures are blends of published and reported sources and are marked that way in the text; ours are exact. Any of them is easy to check with a few AI prompts, which is how we found them. Client stories are real; names aren't.

Sources

Competitor pricing checked August 2026.

Footnotes

1. Rev.io, "The PSA integration tax" — https://www.rev.io/blog/the-psa-integration-tax-what-connectwise-add-ons-really-cost ; Rallied, ConnectWise Manage review — https://rallied.ai/blog/connectwise-manage-review/ ↩

2. ERP Research, ERP implementation cost breakdown — https://www.erpresearch.com/en-us/erp-implementation-cost-breakdown ; ERP Software Blog, cost breakdown guide — https://erpsoftwareblog.com/2026/08/erp-implementation-cost-breakdown-a-complete-guide-for-u-s-businesses/ ↩

3. Broken Rubik, NetSuite pricing guide — https://www.brokenrubik.com/blog/netsuite-pricing-the-definitive-guide ↩

4. Kaseya Master Agreement — https://www.kaseya.com/legal/kaseya-end-user-license-agreement-eula/ ↩

5. Rallied, Autotask pricing — https://rallied.ai/blog/autotask-pricing/ ; checkthat.ai, Kaseya pricing — https://checkthat.ai/brands/kaseya/pricing ↩

6. Adcirrus ERP, ERP cost — https://adcirruserp.com/erp-cost/ ; Nexify, NetSuite consultant rates — https://nexifygrowth.com/blog/netsuite-consultant-rates ↩

7. Rev.io, "The PSA integration tax" — https://www.rev.io/blog/the-psa-integration-tax-what-connectwise-add-ons-really-cost ↩

8. Broken Rubik, NetSuite development services — https://www.brokenrubik.com/services/netsuite-development ; Nexify, NetSuite consultant rates — https://nexifygrowth.com/blog/netsuite-consultant-rates ↩

9. Kore1, NetSuite implementation cost — https://www.kore1.com/netsuite-implementation-cost/ ; GSI, NetSuite pros and cons — https://www.getgsi.com/blog/netsuite-pros-and-cons ↩

10. Gartner, Enterprise Resource Planning — https://www.gartner.com/en/information-technology/topics/enterprise-resource-planning ↩

11. Panorama Consulting Group, The 2026 ERP Report — https://www.panorama-consulting.com/resource-center/erp-report/ ↩

12. Redlio Labs, ERP implementation costs — https://redliolabs.com/insights/erp-implementation-costs ↩

13. Kreative Core Tech, ERP statistics — https://kreativecoretech.com/erp-statistics/ ↩

14. GSI, NetSuite pros and cons — https://www.getgsi.com/blog/netsuite-pros-and-cons ↩