Blog
Technical Debt in a Customized Odoo: An Audit Checklist
Is your customized Odoo getting harder to upgrade? Use this practical audit checklist to find technical debt, rank the risks and decide what to fix first.
- bottom
- odoo
Short answer: technical debt in a customized Odoo is the gap between what your custom code does and what it would cost to keep it working through the next upgrade. You audit it by inventorying every custom module, checking how much of it duplicates standard features, testing how it behaves against a newer version, and ranking each item by business risk. The checklist below takes a small team a few days, not months.
Why this matters now
Odoo’s own documentation is blunt about it. Its guide to upgrading a customized database defines a custom module as any module that extends standard Odoo code and was not built with Studio. It says that removing redundancy between your developments and the standard version of Odoo makes upgrades easier. In other words, Odoo itself treats custom code as the main drag on upgrading.
The upgrade documentation adds a hard constraint. A database with custom modules cannot be upgraded until a version of those modules exists for the target version. Each major version is supported for three years, and the documentation recommends staying on a supported version. So custom code you cannot migrate eventually becomes a security and support problem, not just an inconvenience.
The audit, step by step
1. Inventory everything that is not standard
You cannot size a problem you have not listed. Build a table with one row per item:
| Item | What to record |
|---|---|
| Custom modules | Name, purpose, author, last change date, Odoo version it targets |
| Third-party apps | Vendor or OCA source, version, whether it is still maintained |
| Studio customizations | Fields, views, automations and who owns them |
| Server actions and automated actions | Code stored in the database, not in a repository |
| Reports and QWeb templates | Overrides of standard documents (invoices, delivery slips) |
| External integrations | APIs, webhooks, scheduled scripts that read or write Odoo |
The easy items to miss are code stored in the database (server actions, Studio automations) and integrations built by someone who has since left. These are the usual source of upgrade surprises.
2. Check that the code is in version control
Ask three questions. Is every custom module in a Git repository? Does the deployed code match the repository? Can someone rebuild a working server from the repository alone? If the answer to any is no, fix that before anything else. Code that exists only on a production server is the highest-risk item in the whole audit.
3. Find redundancy with standard Odoo
This is the step Odoo’s documentation emphasizes. For each custom module, ask: does standard Odoo now do this? Odoo ships new features every release, and a customization written for version 14 may now be a configuration setting.
For each module, mark it one of:
- Retire: standard Odoo or a maintained app covers it.
- Replace: a maintained OCA or vendor module covers most of it.
- Keep: it encodes something specific to how you operate.
- Unknown: nobody can explain why it exists. Treat this as a risk until proven otherwise.
Be honest about the “Keep” pile. Customization that reflects a real competitive process is worth keeping. Customization that only reproduces how the old system worked usually is not.
4. Look at how the code is written
You do not need to read every line. Sample the largest or most-used modules for these warning signs:
- Direct SQL against Odoo tables, which bypasses the ORM and often breaks when the schema changes between versions.
- Overriding core methods by copying the whole method instead of calling
super(). Copied methods silently miss upstream fixes. - Editing Odoo core or enterprise files directly. This makes upgrades close to impossible.
- Hard-coded IDs for records, companies, taxes or accounts.
- No tests. If a module has no automated tests, every upgrade means manual checking of everything it touches.
- Deprecated APIs and old view syntax, which the release notes for each version list.
A quick way to measure override risk is to list which standard models your modules inherit and how many methods they replace. The more standard behavior you override, the more each upgrade can break.
5. Test against a newer version
The most reliable measure of technical debt is an actual upgrade attempt. Odoo’s process is to request an upgraded test database, update your custom module source for the target version, and test thoroughly. The documentation says the test database is for verifying the standard upgrade, and notes that it is sent without the filestore, so merge it with your production filestore before judging results.
Run this on a copy, never on production. Record how many modules fail to install, how many fail tests, and how long each fix takes. That gives you an evidence-based estimate instead of a guess.
6. Check data quality and performance
Debt is not only code. Look for duplicate partners, abandoned products, unreconciled entries, and custom fields nobody fills in. Also check for slow reports or scheduled jobs that have grown with data volume. Cleaning data before an upgrade is cheaper than carrying problems into a new version.
7. Review ownership and documentation
For each custom module, can you name an owner on your side and a developer who can change it? Is there a short document describing what it does and why? Bus-factor risk, where one freelancer holds all the knowledge, is technical debt even if the code is clean.
Scoring: what to fix first
Give each module two scores from 1 to 3: business criticality (what breaks if it fails) and upgrade risk (how much it overrides, how untested it is). Then act in this order:
- High criticality, high risk: fix first. Add tests, move to version control, refactor overrides.
- Low criticality, high risk: retire or replace if possible.
- High criticality, low risk: document and monitor.
- Low criticality, low risk: leave alone.
What the audit usually shows
Typical results, from our experience and not a universal statistic, are that a handful of modules carry most of the risk, a surprising share of customizations are now redundant, and a small number of undocumented integrations deserve immediate attention. Your own numbers will vary with how long the system has run and who built it.
Refactoring is not free, and it competes with feature work. The honest trade-off is that a cleanup pass costs money now to avoid larger, less predictable costs at upgrade time. If your system is small, stable and on a supported version, a lighter audit may be enough. If you are two or more major versions behind, or tied to a Studio-and-custom-code mix nobody understands, a full audit is usually worth it. The OpenUpgrade project maintained by the OCA is an option for Community databases, but it does not remove the need to migrate your own custom modules.
Next step
If you want a second pair of eyes, we are happy to talk it through with you. Teknologia Solutions offers a no-charge conversation where we can review your module list, point out the likely risks and tell you plainly whether an audit is worth doing. No obligation, and no pressure to hire us for the work.
Sources: Odoo: Upgrade a customized database, Odoo: Upgrade documentation, OCA OpenUpgrade. Odoo’s policies and tooling change between releases, so please verify details against the primary sources and the documentation for your own version before acting.