Implementation · Project recovery
Odoo project recovery: what the diagnostic audit checks
When an Odoo project stalls, or goes live and nobody trusts it, the fix starts with finding out what is really there. This is what a recovery audit examines, area by area, and how the findings become a keep, repair or rebuild plan with a price.
Key takeaways
- Start with how people use the live system, not with the code.
- Read every custom module against standard Odoo and the next upgrade.
- Test the data against the books: stock, bank lines and valuation.
- Trace integrations for silent failures and switched-off scheduled actions.
- Quote the recovery after the diagnosis, not before it.
A stalled Odoo project rarely has one cause. Custom code, data, integrations and adoption problems feed each other, and the loudest complaint is often a symptom of something quieter. So an Odoo project recovery should start with a diagnosis, not a fix list, and the diagnosis should come before anyone quotes a price.
Here is what a diagnostic audit examines, how findings become a keep, repair or rebuild decision, and what the written recovery plan contains. It reflects the Diagnose phase of our Odoo rescue work, and it works as a checklist whoever runs the audit.
Start with how people actually use the system
The code can wait. First find out who uses the system and for what, because a module nobody uses is a different problem from one used every day that breaks.
Odoo keeps most of the evidence. The Users list can show when each user last authenticated, which quickly tells you who has quietly stopped. Every record carries the user who created it and when, so grouping sales orders, vendor bills, receipts or manufacturing orders by creator and month shows which teams work in Odoo and which enter data later, in bulk, or not at all. A warehouse that validates a week of transfers every Friday is not running the warehouse in Odoo.
Then find out where the spreadsheets have come back. Ask each team which exports they run every week and what they do with them. The answers point at reports people distrust, steps that take too long, or wrong data. Watching one person per role work a normal day finds more than any questionnaire.
Custom modules, one at a time
Every custom module gets the same questions. What does it do, and who asked for it? Does standard Odoo already do it, in your version or the next one? Modules written a few versions ago often duplicate features Odoo has since shipped, and retiring one costs less than maintaining it. Our guide to customization versus standard Odoo covers where that line usually sits. On the SF Dyes migration, we audited every custom module and rewrote each one for Odoo 18, checking each against its original behavior before sign-off.
Then the code itself. These patterns cause most of the damage:
- Overrides that skip
super(). The method replaces standard behavior instead of extending it, and silently cuts off every other module that extends the same method. - Hard-coded record ids. Code that browses record 7 to find a warehouse or a tax works in the database where it was written and points at the wrong record anywhere else. XML ids, read with
env.ref, are the stable way. - SQL where the ORM belongs. Raw queries skip access rights and record rules, and writes made behind the ORM can leave its cache and computed fields out of step with the database.
- Edits to Odoo's own source files. Changes made in core instead of an inherited module are overwritten by the next update, often without anyone noticing.
- No tests. Without them there is no quick way to prove a module still does what it did after a fix or an upgrade.
Finally, will it survive the next upgrade? Odoo's subscription agreement covers the three most recent major versions, currently 18, 19 and 20, and a database with custom modules cannot be upgraded until those modules have a version for the target release. View syntax that Odoo 17 removed and widgets written for the legacy JavaScript framework add the most cost. Our Odoo 16 to 19 custom module guide lists the changes that break code most often.
Marketplace apps
Apps from the Odoo Apps Store run on Odoo.sh and on-premise, not Odoo Online, and carry the same risks as custom code with less control. For each one, check that the vendor publishes a version for your release and the next, when it was last updated, and whether anyone answers support questions. Check what it overrides: two apps that change the same method or view can behave differently depending on load order, which produces bugs that come and go. And ask whether an app installed for one small feature still earns its place.
Data integrity
Data problems are the ones users feel most, and they hide behind plausible-looking reports. The audit tests the data against reality and against the books.
Duplicates come first. Duplicate customers split sales history and credit limits; duplicate products split stock between two records. On Enterprise, the Data Cleaning app's deduplication rules help find them. Units of measure come next: a purchase unit with the wrong conversion factor quietly multiplies or divides every receipt, and the error only surfaces at the stock count.
Negative stock is a sign that goods leave before they arrive in the system. Odoo lets a delivery be validated for stock it does not think is there, so a negative quantity usually means receipts are recorded late or not at all, or products are picked under the wrong code. Unreconciled bank statement lines tell the same kind of story on the finance side.
Where stock is valued automatically, compare inventory with accounting: the value in the inventory valuation report should agree with the balance of the stock valuation account. When it does not, the gap has a cause, often entries posted to that account by hand. Check in the documentation for your version how stock value reaches the accounts before you judge a gap.
Integrations and scheduled actions
Integrations usually fail quietly. Start with scheduled actions: which are active, when each last ran, and what the server log says. Recent Odoo versions switch off a scheduled action that keeps failing. That protects the server, but if nobody reads the warning, a sync can stop unnoticed.
Many integrations catch an exception, write it to a log nobody reads, and move on. The practical test is to count both sides: orders in the web shop against sales orders in Odoo, shipments at the carrier against delivery orders, payments at the provider against payments recorded. Then check the queues: failed messages in the outgoing mail queue, waiting jobs if the OCA queue_job module is in use, and webhooks stuck on retry. A backlog is a failure nobody has noticed yet.
Access rights
Access rights drift in a troubled project, because granting admin is the quickest way to silence an error. Count the users with Settings access, and those in accounting groups who have no reason to be there. Look for shared logins, which make the created-by evidence above useless, and for former employees and former partner staff who are still active. In the custom code, look for sudo() used to get around a missing access right instead of fixing the right, and for record rules that break in multi-company setups.
Hosting and backups
Which Odoo version is it, and is it still supported? Odoo gives each major version three years of standard support, so 18, 19 and 20 are covered. Odoo 17's standard support was planned to end in September 2026, and older versions need paid extended support, which Odoo Online does not offer. Who owns the hosting account? If you are changing partners at the same time, secure that first, as our guide to switching Odoo partners mid-project explains.
Then the backups. Odoo Online and Odoo.sh make automatic backups of production, but download a copy of your own and check that you can restore it. On-premise, backups are whatever someone set up: check that they include the filestore as well as the PostgreSQL database, that they are stored off the server, and that one has been restored recently. When screens are slow, check the custom code before adding hardware.
Symptoms, where to look, and the usual fix
These are the patterns we meet when we are called in to restructure projects other vendors started, with where the audit looks and the usual fix direction. The evidence decides the actual fix.
| Symptom | Where to look | Typical fix direction |
|---|---|---|
| Teams keep spreadsheets beside Odoo | Last logins, records created per user, the exports people run | Fix the report or step that drove them out, then retrain by role |
| A standard feature stopped working after a module went in | Overrides of that method that skip super() | Repair the override so it extends instead of replacing |
| Works on the test copy, fails in production | Hard-coded record ids in code and data files | Replace them with XML ids |
| A sync stopped and nobody noticed | Inactive scheduled actions, the server log, counts on both sides | Repair the error handling and add alerts |
| On-hand quantities below zero | Receipts recorded late, picking under the wrong product | Fix the process, then correct stock with an inventory adjustment |
| Stock value disagrees with the balance sheet | Manual entries to the valuation account | Reconcile, correct, and stop manual posting to that account |
| Bank lines pile up unreconciled | Payments recorded in Odoo against the bank, invoice accuracy | Clear the backlog, then set up reconciliation models |
| Duplicate customers or products | Matching names, tax ids and internal references | Merge with care for stock and history, then add rules |
| The upgrade estimate is enormous | Deprecated APIs, legacy widgets, core edits, abandoned apps | Retire, replace with standard, or rewrite |
How findings become keep, repair or rebuild
Each module, app and major configuration area gets one verdict. Keep means it works, people use it, and it will survive the next upgrade; it gets documentation and tests if missing. Repair means the idea is right and the implementation is not: an override that needs to call super(), hard-coded ids swapped for XML ids, a sync that needs proper error handling. Rebuild means the design itself is wrong, such as a core edit or a data model that fights Odoo's own, and patching it would cost more than writing it again. Sometimes the rebuild is not code at all: the module is retired and the process moves to standard Odoo.
The default is to keep what can be kept. Starting over throws away working code and trusted data, and the evidence rarely supports it.
What the written recovery plan contains
The diagnosis ends in writing. Our recovery plan sets out:
- the root cause of the trouble, named plainly, with the evidence behind it
- the keep, repair or rebuild verdict for every module, app and area
- the stabilize list: what stops daily work, to be fixed first
- the repair plan, with dates and exit criteria for each stage
- data clean-up and reconciliation, and training by role with a super-user in each team
- the one internal owner who makes decisions on your side
- support after go-live: hypercare, then a support tier with response targets in writing
Ask for the evidence. A finding without evidence is an opinion. Every verdict in the plan should point at the code, the records or the log entries behind it.
Why the quote comes after the diagnosis
Nobody can price the repair of code they have not read. A fixed price given before the diagnosis is either padded for unseen risk or renegotiated when the risk appears. The diagnosis also answers a bigger question: whether Odoo is the problem at all. Usually it is the implementation, and when requirements sit outside what Odoo handles well, you should hear that early, not six months in.
After the diagnosis, we quote the recovery at a fixed price wherever the scope can be pinned down. Where undocumented custom code makes that impossible, we say so and propose time and materials for that part. For a quick self-check first, see the warning signs in our guide to preventing Odoo implementation failure. Our pricing page explains how engagements and support tiers are priced.
Frequently asked questions
What is the difference between an Odoo health check and a recovery audit?
A health check is usually a lighter review of configuration and performance. A recovery audit goes further: it reads every custom module, tests the data against the books, traces the integrations and looks at how people use the system, because its job is to produce a plan and a price.
What do you need from us to start the audit?
Admin access to the database and hosting, the source code of every custom module, whatever scope documents exist, and one internal owner who can make decisions. If code or documents are missing, the diagnosis says what that changes.
Does the audit mean we have to start over?
Not by default. Each module and area is sorted into keep, repair or rebuild, and the plan rebuilds only what cannot be repaired.
Can the audit run without disrupting the live system?
It should. Code review and data checks can run on a recent copy of the production database, and the usage questions only read from the live system. Changes to production wait for the plan, unless something is stopping daily work.
Project stalled?
30 minutes: tell us what is live and what hurts, and we will tell you whether a diagnosis is the right next step.
Book a discovery callKeep going
Related services and articles
Get the diagnosis done
Diagnose, stabilize, repair, stay: the four-phase plan for projects other partners started.
Odoo rescueRepair the custom code
Upgrade-safe modules and integrations with tests, built by our engineers in Ahmedabad.
Odoo customization and integration ImplementationHow to switch Odoo partners mid-project without losing work
What to secure before notice, the contract points to read, and a handover checklist.
Odoo UpdatesUpgrading custom Odoo modules from 16 to 19: what changes
The API changes that break custom modules, with old and new code side by side.
Find out what is really wrong with your Odoo project
The first call takes 30 minutes.
Or email sales@octagotech.com- USA +1 917 254 9416
- India +91 8153897751