Last updated: 16 November 2026
The short answer
Git-driven Odoo deployment means a git push is the only way code reaches your Odoo. The push builds the code, updates the right modules, restarts Odoo and checks it came back. For that to be safe, a push has to do seven things, in order. Most home-made pipelines do three.
What git-driven deployment means for Odoo
Your git repository is the only way code gets to a server. You push a branch. That push builds the code, updates the Odoo modules that need it, restarts Odoo and checks that it works. Each branch is its own running Odoo. So development, staging and production are branches you merge between, not servers you copy files to. Nobody logs in over SSH to deploy.
For most web apps, this is a solved problem. For Odoo it's harder, because of the database.
Why Odoo is harder to deploy than most apps
For most web apps, a deploy is just code. Pull the new code and restart. If it breaks, pull the old code and restart.
Odoo is code plus a database that the code changes. Each time you update a module, Odoo changes tables, fields and records in PostgreSQL. Once the update has run, the old code no longer fits the database. So you can't roll back by going back one commit. That one fact shapes everything below.
The seven things a push has to do
1. A fresh checkout, not a pull into a live folder
Many scripts run git pull in the addons folder of the live server. That folder is in use. A pull that fails half way, a merge conflict, or a file someone changed on the server by hand can all leave Odoo running code that exists nowhere in git.
The safe way is a fresh clone for each build, in its own folder. Submodules and requirements.txt are installed there. The live Odoo keeps the old checkout until the new one is ready.
2. The right addons path
Odoo only sees modules on its addons path. A build has to put four things on it, in the right order: your own modules, your OCA or other submodules, Enterprise if you have it, and any platform modules. If your modules sit in a subfolder, that subfolder goes on the path, not the repo root. Get this wrong, and step 3 updates nothing but still says it worked.
3. The right list of modules to update
This is the step most guides get wrong. odoo -u all updates every module in the database, core ones too. On a big database that can take an hour. Updating only the modules in the last commit is faster, but it misses modules that depend on the one that changed.
The right list is simple to say. Update the modules that are installed in the database and also in the new checkout. Installed but gone from the repo? Leave it. In the repo but never installed? Leave it. Installing a module is your choice, not a side effect of a push. So the list comes from the database, not from the diff.
4. A rollback point before the update runs
Because of the database, the only real rollback is a copy of the database. Take it after Odoo stops and before -u runs. Not a snapshot of the whole server. A dump of that one database, so one branch can go back without touching anything else.
If the copy fails, the update must not run. A failed build is better than a half-updated database with no way back.
5. The update, with Odoo stopped
Run the module update with --stop-after-init while Odoo isn't serving users. An update under live traffic can leave modules half done. Two updates at once will. One update at a time per branch, in order.
odoo -c /etc/odoo/odoo.conf -d yourdb -u module_a,module_b --stop-after-init
6. A health check, and a rollback if it fails
Start the new Odoo. Check that it answers on its domain. If it doesn't, restore the copy from step 4 and bring the old Odoo back, without a person reading logs at 2am. If it does, the old checkout can go.
This step is what makes push-to-deploy safe for production. Without it, each push is a bet.
7. Every branch is an environment
A branch you push should become an Odoo you can open. Feature branches get a short-lived one. Staging gets a copy of production, with private data like customer emails scrubbed out. Production gets the full update flow above. Merge from one to the next, and the same pipeline runs each time.
Where home-made pipelines stop
Most Odoo deploy guides give you a GitHub Actions or GitLab CI file that does this: SSH into the server, git pull, run -u on the modules in the diff, restart, and load the login page. Some add a pg_dump first.
That covers steps 1, 3 and 6, each only in part. And it leaves you with:
- SSH keys to your production server, stored as CI secrets
- A CI runner you have to keep patched
- An update list built from the diff, which misses modules that depend on it
- A rollback that is a script you wrote once and never tried under pressure
- No staging, unless you build the data scrub yourself
None of this is hard to write. It's hard to keep working for three years while you also ship features.
How it works on Skysize
Skysize connects to your repository on GitHub, GitLab or Bitbucket. Then, for each push:
- A fresh clone per build. Each build gets its own checkout, with submodules pulled, public or private, and
requirements.txtinstalled. No two Odoo containers share a folder. - The addons path, built for you. Your modules, submodules, Enterprise if you use it, and platform modules go on the path in the right order. If your modules sit in a subfolder, you set that path once per branch.
- The update list, from the database. The update runs on modules that are installed and in the new checkout. Never
-u all. Modules you haven't installed are left alone. - A copy, the update, a check, a rollback. Before the update, your database is copied. After it, the new Odoo is checked on its domain. If the check fails, the copy comes back, and so does the old Odoo, on its own.
- Branch types. Development branches are short-lived. They are removed on their own after a while with no new build. Staging branches can start from a copy of production, with private data scrubbed. Production gets the full update flow.
- Build logs. Each build logs its install, update, tests and requirements steps. When a build fails, you see which step it was.
- No SSH into your server. If Odoo runs on your own server, our software connects out to Skysize. We keep no SSH login, we add no SSH key to your server, and you open no port.
See every step on the deployments page. The same pipeline runs on managed Odoo hosting, on your own server and inside your own network, for Community and Enterprise.
For the staging part, read copying production Odoo to staging without emailing your customers.
See it run on your own repo
Bring a repository, and we'll push a branch through the pipeline with you on screen. Or connect it yourself with the 7-day free trial. No card needed.
Skysize is built by ex-Odoo engineers and is ISO 27001 certified.
Talk to an Odoo hosting expert
FAQ
What is git-driven deployment for Odoo? It means a git push is the only way code reaches an Odoo server. The push builds the code, updates the right modules, restarts Odoo and checks that it's up. Each branch is its own running Odoo, and nobody deploys over SSH.
Is git-driven deployment the same as CI/CD? Almost. CI/CD means building, testing and deploying on every commit. Git-driven deployment is that idea for Odoo, where the hard part is the database that changes with the code.
Can I deploy Odoo from GitLab or Bitbucket, not only GitHub? Yes. Skysize works with GitHub, GitLab and Bitbucket. The pipeline is the same for all three.
Does a push install new modules? No. A push updates modules that are already installed. Installing a module is a choice you make in Odoo.
What happens if the update fails? The database copy taken before the update comes back, and so does the old Odoo. You end up where you were before the push.
Do submodules and Python requirements work? Yes. Submodules are pulled on every build, public or private. Each private one gets its own deploy key. requirements.txt is installed in the build.
Can I get Odoo.sh-style CI/CD on Odoo Community? Yes. Branch environments, staging from production, push to deploy and rollback all work on Community, which Odoo.sh doesn't host. They work on Enterprise too.