Big-bang deployments
Every module going live on the same weekend creates too many failure points at once and overwhelms the people who have to use the system on Monday.
ERP projects rarely fail because the software can't do the job. They fail because of decisions made, or dodged, long before anyone writes a line of code. Here are the patterns that separate calm go-lives from expensive ones.
By Anvexis Stack Engineering9 min read
Often enough that it's worth planning for. Gartner analyst Dixie John told a 2025 Gartner symposium that around 70% of ERP initiatives fail to fully meet their original business case goals, and that about 25% fail catastrophicallySource [1]. Treat those as an analyst's forecast rather than a census, but notice what she named as the causes: bad business cases, unrealistic scope, underestimated complexity, scope creep, conflicting stakeholder interests, customization too wedded to existing processes, and limited change managementSource [1].
Not one of those is a software bug. That matches what we see on Odoo implementations: the platform is rarely the bottleneck. The project around it is. The good news is that organizational problems are cheaper to fix than technical ones, as long as you fix them early.
Most struggling projects can be traced back to the first conversations. A prospect asks whether Odoo can do something, the answer is “yes, with a bit of customization”, and nobody writes down what “a bit” means. Multiply that by forty requirements and the budget was wrong before the contract was signed.
The fix is unglamorous: a written discovery phase that maps every requirement to one of three buckets, standard Odoo, configuration, or custom development, with an estimate for each. When the business sees that a cherished workaround costs more than the module it replaces, priorities change quickly. That's not a negotiation failure. It's the conversation working as intended.
Discovery also surfaces the conflicting interests Gartner warns aboutSource [1]. Sales wants flexible pricing rules, finance wants clean margins, the warehouse wants fewer clicks. Those trade-offs need a decision from someone with authority, written into the specification, not discovered in user acceptance testing.
Every module going live on the same weekend creates too many failure points at once and overwhelms the people who have to use the system on Monday.
Custom modules that were never exercised against production-sized data, real edge cases, or the next Odoo version.
No internal champion, no training plan, and no way to tell whether people are actually using the system the way it was designed.
Every company believes its processes are unique. Some are, and those are worth building for. Many are simply habits formed around the limitations of the old system. Rebuilding those habits in Odoo produces custom code that fights the standard workflows.
That code has a running cost. Odoo's own upgrade documentation is blunt about it: a database with custom modules cannot be upgraded until a version of those modules exists for the target Odoo releaseSource [2]. Each major version is supported for three years, and on Odoo Online a major upgrade is mandatory every two yearsSource [2]. Every unnecessary customization is a small tax you pay at each upgrade, forever.
A useful test is to ask why a step exists. If the answer is legal, contractual, or competitive, customize it properly, as a clean module that never patches the core. If the answer is “that's how we've always done it”, try the standard flow first. Teams are often surprised how quickly they adapt once they see it working.
Teams plan carefully for features and casually for data. Then they discover that the old system has five spellings of the same customer, products without units of measure, and open invoices that don't reconcile. Each issue is small. Together they can delay go-live by weeks.
Treat migration as a workstream with its own owner, rehearsals, and acceptance checks. Cleaning data at the source, before it moves, is far cheaper than cleaning it in production while invoices are going out. Our migration service is built around this rehearsal loop, and the same idea runs through our guide to planning an ERP migration.
Take a copy of the legacy data at a known point in time, so every rehearsal starts from the same place and results are comparable.
Run the full import, not a sample. Volume problems, duplicate keys, and slow imports only show up at real size.
Finance reconciles balances, sales checks customers and price lists, the warehouse counts stock. Engineers can't judge whether a number is right; the people who use it can.
Correct the root cause in the old system or the mapping, then rehearse again. Schedule the real cut-over only when a rehearsal passes without manual patching.
A two-hour demo before go-live is not training. People learn a new system by doing their real work in it, with someone nearby to answer questions. Projects that budget for role-based training on realistic data, plus a few weeks of close support after go-live, see far fewer spreadsheets creeping back.
The research on change management points the same way. In Prosci's survey of more than 2,600 change practitioners, 88% of those with excellent change management met or exceeded their project objectives, against 13% of those with poor change managementSource [3]. It's self-reported data from a firm that sells change management training, so read it as a strong correlation rather than proof, but it's consistent with every go-live we've watched.
Identify a champion in each department early. Champions test workflows during the build, help colleagues after launch, and become the people who know why the system is configured the way it is. Our training programme is designed around them.
Odoo rarely lives alone. It talks to an online shop, a payment provider, a shipping carrier, a bank, or a legacy system that isn't going away yet. When integrations are left until the end, they become the critical path: go-live waits on an API nobody tested, and the first weeks are spent cleaning up duplicate orders and missing stock updates.
Design integrations during discovery. Agree which system owns each piece of data, and build connectors with retries, logging, and reconciliation reports from the start. Make every write safe to repeat, so a retry after a timeout doesn't create a second order; idempotency explained with coffee covers why. Then test with realistic volumes before go-live, not after. Our integration work follows the same rules.
Finance and management often assume the reports they rely on will simply appear in the new system. They rarely appear in the same form. Collect the reports people actually use today during discovery, decide which ones still matter, and design them as part of the project, rather than discovering the gaps at the first month-end close.
This is also where business cases quietly fail. If the original case promised faster closing or better margin visibility, the reports that prove it have to exist on day one. Otherwise nobody can show the project delivered, even when it did.
Successful implementations have one person on the client side who owns the project: someone with the authority to make decisions, the time to attend workshops, and the respect of the teams affected. When ownership is spread across a committee, decisions stall, scope drifts, and the implementation partner ends up guessing what the business wants.
That owner doesn't need to be technical. They need to understand the business, keep priorities clear, and be willing to say no to requests that would delay go-live without adding real value. A strong owner matters more to the outcome than the size of the budget or the choice of modules.
The weeks after go-live decide whether a project succeeds. Small issues appear daily, reports need adjusting, and users discover edge cases nobody tested. A project with no budget or attention left for this period leaves people frustrated and quietly returning to their old tools.
Plan a hypercare period with daily check-ins, one clear way to report problems, and fast fixes. Then move to a steady rhythm of improvements, with support and maintenance that has written scope. An ERP that improves every month earns trust. One that is frozen at go-live slowly loses it. Rolling out in phases, as our delivery process does, also means each go-live is small enough to support properly.
Drift is easier to fix when you catch it early, and the signals are usually visible weeks before the budget is. Watch for workshops where the same decision is postponed twice, change requests that arrive without an owner or a business reason, and a migration rehearsal that keeps slipping because “the data isn't ready yet”.
Other signs are quieter. Key users stop coming to demos. The project owner delegates decisions to people who can't make them. Testing happens on ten sample records instead of a realistic copy. Each of these is a small conversation now, or a large one at go-live. When we see two or more of them together, we stop and re-plan with the client rather than pushing the date and hoping.
Written by Anvexis Stack
We build Odoo, AI, web, and cloud systems for growing companies, and we write about the patterns we use. This is engineering guidance, not a product guarantee: check vendor details for your version before you decide. Last reviewed .
Odoo implementation
End-to-end Odoo implementation: process discovery, configuration, data migration, testing, training, and a phased go-live with hypercare.
InsightsPlan an ERP migration
A practical framework for inventorying customizations, validating data, rehearsing cutover, and communicating an ERP migration plan.
ProcessHow we work
How we deliver software projects: discovery sprint, written specification, two-week sprints with demos, testing, launch, and support.
Next step
Thirty minutes with an engineer, no slide deck required. You'll leave with a clearer picture, whether or not we work together.