We build custom software. This post is mostly going to argue against buying it.
That is not modesty. It is that custom ERP is right far less often than founders believe, and the businesses that get talked into it usually discover why eighteen months later, when the developer who built it has moved on and nobody else can touch the thing.
Here is the honest framework.
Quick answer
Off-the-shelf wins in roughly 9 out of 10 cases. Odoo, ERPNext, SAP Business One and Dynamics 365 exist because most business processes are more similar than businesses think.
Custom is right when: your core process genuinely does not map to any standard system, and that process is your competitive advantage rather than an accident of history.
The cost: custom ERP starts around ₹3–5 lakh and climbs steeply. Odoo implementation runs ₹2–5 lakh for a typical Indian SME. The sticker prices look comparable. The five-year pictures do not.
The question that actually decides it
Not “is our process unique?” Everyone says yes.
“Is our process unique because it is better, or because nobody ever standardised it?”
That distinction is the whole decision. Most “our process is unique” turns out to be “our process is undocumented” — it grew organically, it lives in three people’s heads, and it looks unique because nobody has ever written it down and compared it to how anyone else does the same job.
Build custom software around an accidental process and you have permanently encoded your own historical mess into code you now maintain forever.
The test: if you cannot document your process in a way a stranger could follow, you are not ready to custom-build it. You are ready to examine it.
The case for off-the-shelf
Someone else already solved it. Odoo covers 82+ modules. ERPNext covers manufacturing, accounting, HR and CRM. These systems encode decades of accumulated knowledge about how businesses actually run.
The defaults are defaults for a reason. Odoo’s standard workflow exists because it works for most businesses. When teams migrate from SAP B1 to Odoo, custom code rarely ports — and it turns out faster than expected, because Odoo’s defaults often handle what required heavy customisation in the old system.
That is worth sitting with. Much of what businesses custom-build is a solved problem they did not know was solved.
Someone else maintains it. Odoo ships updates. Security patches happen. New features arrive. With custom, every one of those is a project you pay for.
You can hire for it. India has a large Odoo and ERPNext partner ecosystem. Custom software has exactly one expert — the person who built it — and their departure is your crisis.
Speed. Odoo goes live in 60–180 days. Custom ERP takes longer, always, and the estimate is always optimistic.
Cost predictability. ₹580–₹1,150/user/month for Odoo Enterprise, plus ₹2–5 lakh implementation. You can budget that. Custom development budgets are estimates, and estimates slip.
It scales without you. Odoo handles 20 users or 2,000. Your custom system handles what it was built to handle.
The case for custom — the honest version
There are real cases. Here they are.
Your process is genuinely your moat. If how you do the thing is why customers choose you, and no standard system models it, custom is defensible. This is rare and you will know.
You have tried and failed to fit. Not “we looked at Odoo and it seemed complicated.” Actually scoped it with a competent partner and found a genuine structural mismatch.
Regulatory or contractual constraints no vendor meets. Occasionally real.
You are building a product, not a system. If the software itself is what you sell, that is not ERP. That is product development.
You have the capacity to own it forever. Not the budget to build it. The capacity to maintain it, for as long as the business exists.
That last one is where most custom projects die, and it is the one nobody evaluates before signing.
The maintenance trap
This is the part the sales conversation skips.
Custom software means you own the maintenance permanently. Not for the warranty period. Forever.
Every OS update, every dependency deprecation, every security patch, every new requirement, every regulation change — GST rate revisions, e-invoicing thresholds, new compliance requirements — is your project to fund and your developer’s availability to depend on.
Odoo ships those. Your custom system does not, unless you pay someone to write them.
And there is the bus problem. Custom software has one expert. When they leave — and they will — the next developer inherits an undocumented codebase and their first honest estimate for any change will be three times what the original developer would have quoted. That is not padding. That is what understanding someone else’s system costs.
The five-year picture: a ₹5 lakh custom build with ₹15,000/month maintenance is ₹14 lakh over five years, assuming nothing major changes. Something major always changes. Odoo for a 25-user Indian manufacturer runs ₹25–40 lakh over five years — but that includes updates, a partner ecosystem, and someone else’s problem when the platform needs upgrading.
The gap is narrower than the sticker prices suggest, and the risk profile is completely different.
The middle ground nobody mentions
Off-the-shelf plus custom modules.
This is where most businesses with genuinely unusual requirements should land, and it barely gets discussed because it is not a clean sales pitch.
Odoo is open source. You can write custom modules in its Python framework that sit inside the standard system. You get the platform’s updates, ecosystem and defaults — plus the one thing your business genuinely does differently.
The discipline it requires: be ruthless about what gets custom-built. Every custom module is upgrade friction later. If you custom-build 40% of the system, you have bought the worst of both worlds — a platform you cannot upgrade cleanly and a custom system you do not fully control.
The right ratio: standard platform, one or two custom modules where the business genuinely differs. That is defensible. Beyond that, you are building custom with extra steps.
What we tell clients
We build custom software. Here is what we say when someone asks for a custom ERP:
“Show us the standard system that failed.”
Not a system you looked at. One you scoped properly with someone competent. Nine times in ten, that conversation ends with an Odoo or ERPNext implementation and a much smaller invoice than the custom project would have been.
The tenth time is real, and then custom is right and we build it.
The reason to say this out loud: a failed custom ERP costs us more in reputation than the project earns. A business running a system nobody can maintain does not refer anyone.
Which should you choose?
Standard manufacturing, trading, services: off-the-shelf. Odoo or ERPNext. Not close.
“Our process is unique” but undocumented: document it first. Then compare. You will probably find Odoo does it.
Genuine structural mismatch, verified with a partner: off-the-shelf plus custom modules.
Your process is your competitive moat: custom, and budget for owning it forever.
Budget under ₹5 lakh: off-the-shelf. Custom at that budget produces something worse than the spreadsheet.
Regulated sector with hard compliance needs: off-the-shelf, usually SAP B1. See Odoo vs SAP Business One.
You are building software to sell: that is not ERP. Different conversation.
The bottom line
Off-the-shelf wins in roughly nine out of ten cases, and the tenth case is rarer than founders think.
The sticker prices mislead. Custom looks cheaper at ₹3–5 lakh against an Odoo implementation, until you price five years of maintenance, the bus problem, and every compliance change becoming a billable project.
Try hard to fit an off-the-shelf system first. Genuinely hard. Scope it with someone competent. If it fails, you have lost a discovery call. If you skip that step and build custom, you may have bought a permanent dependency for a problem Odoo solved in 2015.
And if the answer genuinely is custom — build the platform standard and the difference custom. That middle ground is where most unusual businesses belong.
We build custom software and implement Odoo. We will tell you which one your business needs, and it is usually the smaller invoice. For the field, see top 10 ERP software in India. For what goes wrong, 8 ERP implementation mistakes.
Frequently Asked Questions
Should I build a custom ERP or buy off-the-shelf?
Off-the-shelf in roughly nine out of ten cases. Odoo, ERPNext and similar systems encode decades of accumulated knowledge about how businesses run, and most “unique” processes turn out to be undocumented rather than genuinely different. Custom is right when your process is a real competitive moat and you can maintain the software permanently.
How much does a custom ERP cost in India?
Custom builds start around ₹3–5 lakh and climb steeply from there. The sticker price misleads though — a ₹5 lakh build with ₹15,000/month maintenance is ₹14 lakh over five years, before any major change. Odoo implementation runs ₹2–5 lakh for a typical Indian SME, with updates and a partner ecosystem included.
What is the biggest risk with custom ERP?
Permanent maintenance ownership. Every OS update, dependency change, security patch and compliance revision — GST rate changes, e-invoicing thresholds — becomes your project to fund. Custom software also has exactly one expert, and when they leave, the next developer’s honest estimate for any change is roughly three times the original.
Can I customise Odoo instead of building custom?
Yes, and for most businesses with genuinely unusual requirements this is the right answer. Odoo is open source, so custom modules can be written in its Python framework inside the standard system. You keep platform updates and the ecosystem while adding the one thing your business does differently. Keep custom modules minimal — each one adds upgrade friction.
How do I know if my business process is actually unique?
Test it: can you document the process so a stranger could follow it? If not, it is likely undocumented rather than unique — it grew organically and lives in a few people’s heads. Building custom software around an accidental process permanently encodes your historical mess into code you then maintain forever.
