Odoo deployment fails after update check dependencies

The update broke my Odoo. What just happened?

You pressed the update button in Odoo and suddenly the screen shows a red error banner that reads ValueError: Missing required field 'depends'. The interface is sluggish or completely unresponsive. Sales orders, invoices, and inventory data are still there, but users cannot log in. This is the classic symptom of a module that depends on another module that is either missing, disabled, or incompatible after the update.

These dependency failures usually surface during the Odoo server restart after an upgrade. The server tries to load every installed module, but one module cannot start because it relies on features or tables provided by another module that is no longer available. The result is a partial or total system freeze, not a data loss, but a service outage that blocks all users.

This failure pattern is common when:

You update Odoo from one major version to another (e.g., 15.0 → 16.0)
A custom addon or third-party module is added without checking its dependencies
A module update removes or renames a dependency that another module still expects

The root cause is simple: Odoo is strict about dependencies. If module A says it depends on module B, Odoo will not load module A unless module B is present, enabled, and compatible. When that condition fails, the entire server startup fails.

Next steps below focus on identifying which module is failing and why, then fixing the dependency chain before restarting the server.

Quick checks before you touch the server

What to look at first

Start with the error message in the Odoo log file. Open the file odoo-server.log located in the /var/log/odoo/ directory (common on Linux) or the folder you configured for logs. Search for the first occurrence of depends or Missing required field. You will typically see a line like:

2024-06-12 10:15:42,123 12345 ERROR odoo odoo.modules.loading: Module 'website_sale_delivery' depends on 'delivery', but that module is not installed

This tells you two things:

Failing module: website_sale_delivery
Missing dependency: delivery

Next, open the Odoo Apps list in the web interface (Apps → Installed). Look for the failing module and note its status. If it is marked as Installed but the server will not start, the module is likely broken. If it is not installed at all, you may have an orphaned dependency reference.

Another quick check is to run the Odoo shell command to list all installed modules and their dependencies. This avoids opening the web interface when the server is down:

./odoo-bin --db_user=odoo --db_password=odoo --db_name=prod -i base --stop-after-init --log-level=error

This command starts Odoo in initialization mode, loads the base module only, and stops. If the log shows ModuleNotFoundError, you know the dependency chain is broken before you even try to load all modules.

Build the dependency tree for the failing module

How to map the dependency chain

Each Odoo module declares its dependencies in a Python file named __manifest__.py. The key field is depends, a list of module names that must be present and enabled. For example:

{
    'name': 'Website Sale Delivery',
    'depends': ['website_sale', 'delivery'],
}

If delivery is missing, website_sale_delivery will not load. To see all dependencies for every installed module, run:

./odoo-bin --db_user=odoo --db_password=odoo --db_name=prod -i all --stop-after-init --log-level=error | grep -i depends

This prints lines like:

Module 'account_invoice_refund_link' depends on ['account']

Collect all these lines into a simple text file. You now have a dependency tree. The next step is to verify whether each dependency is installed and enabled in your database.

If you find a dependency that is not installed, you have three options:

Install the missing module via Apps → Update Apps List → Search → Install
Enable the module if it is installed but disabled (Apps → Installed → Enable)
Remove or update the failing module if the dependency is obsolete or incompatible

Always install modules in the correct order: base modules first, then technical modules, then functional modules. If you install a module that depends on another that is not yet installed, the dependency error will reappear.

Repair the dependency chain step by step

Step-by-step recovery guide

Follow these steps in order. Each step includes a verification command so you can confirm progress before moving to the next step.

Step 1 – Confirm the failing module

Run the server in init mode again and capture the exact error:

./odoo-bin --db_user=odoo --db_password=odoo --db_name=prod -i all --stop-after-init --log-level=info 2>&1 | grep -i "depends on" | head -1

Note the module name and its dependency. Example output:

Module 'l10n_de' depends on 'account', but that module is not installed

Step 2 – Install or enable the missing module

If the missing module is part of Odoo’s standard apps, install it via the web interface or command line:

./odoo-bin --db_user=odoo --db_password=odoo --db_name=prod -u l10n_de --stop-after-init

What this does: The -u flag upgrades the module l10n_de and all its dependencies. If account is missing, this command will fail again. In that case, install account first:

./odoo-bin --db_user=odoo --db_password=odoo --db_name=prod -u account --stop-after-init

Step 3 – Reinstall the failing module

Once the missing dependency is installed, reinstall the failing module:

./odoo-bin --db_user=odoo --db_password=odoo --db_name=prod -i website_sale_delivery --stop-after-init

What this does: The -i flag installs the module and all its dependencies. If the module was previously installed, this refreshes it. If the module is a custom addon, ensure its folder is in the addons_path configured in your Odoo config file.

Step 4 – Verify the chain

Run the init command once more. If no dependency errors appear, the chain is fixed. You should see a clean startup message:

Modules loaded.

Step 5 – Restart the production server

Once the init mode works, restart the Odoo service in production mode:

sudo systemctl restart odoo

What this does: Restarts the Odoo process with all modules loaded. If the server starts without errors, users can log in again.

What if the dependency is a custom addon or third party?

Handling non-standard modules

If the failing module is a custom addon or a third-party module from the Odoo Apps store, the dependency may be another custom addon or a third-party module that is not part of the standard Odoo distribution. The same steps apply, but you need to ensure the module’s folder is in the addons_path setting in your Odoo configuration file.

Common symptoms for custom addons:

Error: ImportError: No module named 'my_custom_module'
Warning: Module not found: my_custom_module in the log
Module appears in Apps list but cannot be enabled

To fix:

Open your Odoo configuration file (usually /etc/odoo/odoo.conf or ~/odoo.conf).
Locate the addons_path line. It may look like:

addons_path = /odoo/odoo/addons,/odoo/custom-addons,/odoo/third-party

If your custom module is not in one of these folders, add the correct path:

addons_path = /odoo/odoo/addons,/odoo/custom-addons,/odoo/third-party,/opt/my-modules

Restart the Odoo service:

sudo systemctl restart odoo

If the module still fails, check the module’s own __manifest__.py file. Look for the depends field. If it lists a module that does not exist in your installation, either:

Install the missing dependency from the Odoo Apps store or your custom repository
Remove the dependency from the depends list if it is no longer needed (advanced, requires code review)
Update the module to a newer version that removes the obsolete dependency

For third-party modules, check the module’s documentation for a list of required dependencies and installation order. Some modules require specific versions of Odoo or other modules. Always read the README.md or CHANGELOG.rst in the module’s folder before installing.

If you are unsure which module to trust, disable the custom module temporarily and restart Odoo. If the server starts, the issue is isolated to that module. You can then decide whether to fix it or remove it.

How to prevent dependency failures in the future

Proactive checklist before any Odoo update

Use this checklist before you update Odoo, install a new module, or migrate to a new server. Completing it reduces the risk of dependency failures and saves time during incident response.

Step	Action	Tool or command	Success indicator
1	List all installed modules and their dependencies	`./odoo-bin --db_name=prod -i all --stop-after-init --log-level=error \| grep depends`	No missing dependencies in the log
2	Check for disabled but required modules	Apps → Installed → filter by Disabled	No disabled modules that are required by installed modules
3	Verify custom addon paths	Open config file, check `addons_path`	All custom module folders are listed
4	Test module upgrade in a staging environment	Clone production DB to staging, run `-u module_name`	Staging server starts without errors
5	Document module dependencies	Export `depends` lists from `__manifest__.py` files	Dependency map is saved in a shared file
6	Schedule updates during low-traffic hours	Use your operations calendar	Change window is approved and communicated

When to update Odoo and its modules:

Only when a new feature or bug fix justifies the risk
After verifying the compatibility matrix on Odoo’s pricing page for your current version and the target version
After running the dependency checklist above

If you are running a heavily customized Odoo installation, consider engaging an Odoo implementation partner for a formal dependency audit before any major update. Custom integrations and complex workflows can hide subtle dependency chains that are hard to detect manually.

When to seek help and who to call

Recognize the limits of self-service

Not every dependency problem can be solved with the steps above. If any of the following occur, stop and escalate:

The same dependency error persists after three attempts and three restarts
The error message changes but the server still crashes (e.g., KeyError: 'account_move' after fixing account)
Data corruption symptoms appear: duplicate records, missing fields, or failed invoice generation
The failing module is a core Odoo module (e.g., account, sale, purchase) and the error suggests a schema mismatch
You are unsure whether a custom addon is safe to disable or remove

Who to contact:

Internal Odoo admin or DevOps: If you have one, they can run deeper diagnostics and access server logs.
Odoo partner: If you purchased Odoo from a partner, open a ticket with them. They have access to module compatibility matrices and can suggest safe upgrade paths.
Odoo Enterprise support: If you have an Enterprise subscription, use the Odoo implementation portal to log a ticket. Include the full error log and the list of installed modules.
Custom addon developer: If the failing module is a custom addon, contact the developer who built it. They may need to update the module for the new Odoo version or fix a broken dependency chain.

When escalating, include the following in your message:

The Odoo version you are running (check Settings → About)
The full error log from odoo-server.log
The list of installed modules (Apps → Installed → Export)
The custom addon paths from your config file
Any recent changes: new modules installed, config changes, or server upgrades

This information allows the support team to reproduce the issue quickly and propose a safe fix.

Final checklist: Get back online today

Immediate actions to restore service

If your Odoo is down now, run through this checklist in order. Each step takes less than two minutes.

Capture the error

Open odoo-server.log and find the first depends or Missing required field line. Copy the exact module names. This is your incident snapshot.

Check the dependency chain

Run the init command to see if the error repeats:

./odoo-bin --db_user=odoo --db_password=odoo --db_name=prod -i all --stop-after-init --log-level=error 2>&1 | grep -i "depends on"

If the error is the same, proceed to step 3.

Install or enable the missing module

Use the module name from the error to install it:
```
./odoo-bin --db_user=odoo --db_password=odoo --db_name=prod -u delivery --stop-after-init
```
Replace delivery with the missing module. If the command fails, note the new error and repeat step 2.
Reinstall the failing module

Once the dependency is installed, reinstall the failing module:
```
./odoo-bin --db_user=odoo --db_password=odoo --db_name=prod -i website_sale_delivery --stop-after-init
```
Replace website_sale_delivery with the module from your error.
Restart the service

Start the Odoo service in production mode:
```
sudo systemctl restart odoo
```
Check the service status:
```
sudo systemctl status odoo
```
If the status shows active (running), your service is restored.

If the service still crashes after step 5:

Do not restart the service again
Collect the full log file and the list of installed modules
Escalate using the contact list in the previous section

Prevent the next outage:

Save the dependency checklist above as a runbook in your operations folder
Schedule a 30-minute review of all installed modules and their dependencies at least once per quarter
If you use custom addons, add their depends lists to your documentation

Remember: Dependency failures are preventable. The time you spend checking dependencies before an update is always shorter than the time spent restoring service after a crash. Use the checklist above before every Odoo update or module installation, and you will avoid most outages.

Practical Next Step

Run the dependency checker now

Discuss Your Odoo Scope

FAQ

What is the difference between 'depends' and 'required' in a module manifest?

The depends field in a module’s __manifest__.py file lists modules that must be installed and enabled for the module to work. If any module in this list is missing or disabled, Odoo will refuse to load the module and the server startup will fail.

The required field (less common) is used in some third-party modules to indicate modules that should be installed but are not strictly required for the module to load. If a required module is missing, the module may still load, but with reduced functionality or warnings. The server will not crash.

In practice, always treat depends as mandatory. If you see a module with a depends list, ensure every module in that list is installed and enabled before installing the module itself.

How do I know if a module is a custom addon or a standard Odoo module?

Standard Odoo modules are included in the Odoo installation folder, usually in a subfolder named addons or odoo/addons. Their names are short and follow Odoo’s naming conventions (e.g., account, sale, website).

Custom addons are modules you or a developer created. They are typically stored in a separate folder, often named custom-addons, local-addons, or a custom path like /opt/my-modules. Their names are often more descriptive or prefixed with your company name (e.g., mycompany_sale_custom).

You can also check the Apps list in Odoo. Standard modules have a small Odoo logo next to their name. Custom addons do not have this logo. If you are unsure, open the module folder and look for a file named __manifest__.py. If it exists, it is a custom addon.

Why does Odoo sometimes show 'Module not found' for a module I know is installed?

This usually happens when the module’s folder is not in the addons_path setting in your Odoo configuration file. Odoo only loads modules that are in the folders listed in addons_path.

To fix this, open your Odoo configuration file and add the folder containing the module to the addons_path line. For example, if your custom modules are in /opt/my-modules, add it like this:

addons_path = /odoo/odoo/addons,/opt/my-modules

Save the file and restart Odoo. The module should now appear in the Apps list.

What should I do if updating a module breaks existing data or workflows?

If updating a module causes data corruption or breaks workflows, do not proceed with the update in production. Instead, restore the production database from a backup taken before the update, then try the update in a staging environment first.

In staging, test the updated module thoroughly: create invoices, sales orders, and records that use the module’s features. If everything works, repeat the update in production during a scheduled maintenance window. Always communicate the change to users in advance and have a rollback plan ready.

If the module is a third-party module from the Odoo Apps store, check the module’s documentation or release notes for known issues after updates. Some modules require a specific Odoo version or have upgrade scripts that must be run manually.

Can I safely skip updating a module if it is not critical to my operations?

Yes, you can skip updating non-critical modules if the update does not provide features or fixes that your business needs. However, always check the module’s release notes for security fixes. If a module has a security patch, it is safer to update it even if it is not critical to your workflows.

To skip an update, simply do not install the new version of the module. Your current version will continue to work, but you will miss bug fixes and new features. Keep in mind that skipping updates may cause compatibility issues when you eventually upgrade Odoo to a new major version.

If you are unsure whether an update is safe to skip, consult your Odoo implementation partner or check the Odoo integration guidelines for compatibility matrices.

Odoo deployment fails after update check the module dependencies first