Skip to Content

How do I take an AI-made change to production in Odoo.sh without breaking anything?

The 3 environments of your project and the 3 GitHub Actions buttons, explained without jargon
November 15, 2026 by
How do I take an AI-made change to production in Odoo.sh without breaking anything?
Wilfredo Fernando Pastor Avila
| No comments yet
 
 

The company shown in the video is a demo company: its data is sample data. The video is in Spanish and lasts 33 minutes.

What you will see in the video

  • 00:00 · Intro
  • 02:11 · The 3 environments of your Odoo.sh project
  • 03:08 · Production: the master branch
  • 03:31 · Staging: a neutralized copy of your data
  • 04:41 · Development: the main branch, your workshop
  • 06:07 · Production and staging, side by side
  • 07:34 · The GitHub repository behind Odoo.sh
  • 09:03 · Your folder and each maintainer's folder
  • 11:45 · README, AGENTS.md and CLAUDE.md
  • 13:13 · GitHub first, then your Odoo
  • 17:07 · Button 1: Update my environment
  • 18:43 · Button 2: Test on staging
  • 21:16 · Nothing goes to staging unless it's green
  • 23:01 · Button 3: Publish to production
  • 25:18 · When to publish to production
  • 26:55 · Don't drag one branch onto another
  • 28:01 · Who tests and who gets into Odoo.sh
  • 28:53 · The guardian
  • 29:21 · Summary
  • 30:09 · 6 words to ask for things properly
  • 31:40 · Confusing request, clear request
  • 32:22 · The golden rule
  • 32:49 · Next video

The 3 environments of your project in Odoo.sh

Odoo.sh is where you manage the environments your Odoo runs in. What follows applies if you have access to that platform. Each environment is called a branch, and the video explains it with a restaurant: the kitchen where dishes are invented (development), the tasting area where dishes are tried before they go on the menu (staging) and the dining room where customers eat (production).

Branch main

Development: your workshop

This is where you program with sample data, not your company's real information. You have permission to break anything and, if something fails, your operation is not affected.

Branch staging

Staging: the test

It is a copy of your production database: it has all the data, but it is separate from your operation and neutralized. No emails go out, scheduled tasks don't run and integrations are disconnected.

Branch master

Production: the dining room

It is the Odoo your company uses every day, with your real data. It is what you must protect like gold. Branch names can vary; these are the ones Ganemo keeps as its standard.

Every change goes through staging before it reaches production. In development you run technical tests with sample data; in staging you test your real flows with your real data, without touching the operation; and only then does it reach production.

Staging is a neutralized copy: what that means and what to check

Neutralized means Odoo holds back the emails that would go out, disables scheduled tasks so your tests don't reach your customers, and disconnects integrations. The example in the video is electronic invoicing: in production you send electronic invoices to the tax authority with legal and fiscal validity, and in staging that has to be switched off. Localizations usually disable it, but you should still check integrations with external systems before testing.

The copy reflects the moment it was generated. If you made it when production had invoices up to number 25 and you issued more afterwards, those new invoices exist only in production. Your tests use your real configuration and your real data, up to that cut-off.

The GitHub repository behind Odoo.sh

A repository is the central archive where all of the project's code is stored, with the history of every change: who made it, when and what it touched. It is the source of truth for each branch, and when a change enters a branch, Odoo.sh automatically updates the matching environment.

In GitHub you see the same three branches (main, staging and master). The Odoo.sh project's repository has to exist in GitHub for Odoo.sh to show everything above: if one doesn't exist, neither does the other.

Which folder is yours and which ones you must not touch

  • Your folder (customer addons): your modules go here and this is where you work, assisted by your AI. A module is a package that adds or changes something in Odoo, such as a new field or a document format. Custom formats and layouts are one of the main uses of AI among customers.
  • The Odoo Partners folder: it holds Ganemo's standard modules, such as the Peruvian localization, the advanced localization features for other countries (Colombia, Chile, Ecuador, United States) and payroll. Ganemo regenerates it on every deployment, so don't touch it.
  • Other partners' folders: each partner has its own folder and maintains it. If you change something in a folder that isn't yours, you lose those changes or create serious inconsistencies, because you are not the one maintaining it.
  • The devOps folder: Ganemo manages it. Among other things it holds the list of modules that are deployed automatically through continuous integration. It is technical: don't touch it.

At the root there are three instruction files. The README is for you: if you have access to the repository and you are going to develop on your own, reading it is mandatory because it contains basic rules. AGENTS.md and CLAUDE.md are for your AI: they tell it where it should write, where it should not and how to publish. As with a person, review what it does before publishing it.

GitHub first, then your Odoo

This is the rule the video asks you to remember: whatever you want to reach your Odoo has to reach its branch in GitHub first. And before you create anything in main, that branch has to be up to date.

The video's example: Odoo adds a new field to the invoice that identifies the invoice type. If you work on an outdated branch and you need that value in your printed format, you end up creating a field that already existed in the updated code. It happens more with third-party modules, which update constantly, and your AI agent won't have a correct reference for which module is the most recent one to base its proposed changes on.

Button 1: Update my environment

The three buttons are in the Actions tab of your repository in GitHub. Using them is mandatory.

Actualizar mi entorno (Update my environment) brings all the updated code into your development environment, not only Ganemo's but that of any maintainer or third-party module: everything that is up to date in staging and was deployed by another maintainer reaches you in main.

  1. Go to Actions and choose Actualizar mi entorno.
  2. Click Run workflow.
  3. Type “sí” (yes) when asked and click Run workflow again.

Always do it before creating anything in main and before using the AI tab, so you work on a solid, up-to-date base.

Button 2: Test on staging

Probar en staging (Test on staging) takes your modules from main to staging so you can test them against a copy of your data. If you want to test specific modules, you type them separated by commas; if you leave it blank, all of them are updated.

What gets deployed is what is already in your main branch in GitHub, and it is done without touching other maintainers' modules or folders: if other teams are testing things in staging, you don't affect their version of the code.

Rule: don't send anything to staging if the development tests are not green (success). According to the video, skipping the protocol piles up technical debt and makes maintenance more expensive: if a technician later has to review and fix your code, it takes almost as long as doing it from scratch, and the autonomy you wanted to gain is not gained.

When staging finishes building and shows success, run your tests with your data. It is not only the technical user creating with AI who tests, but also the end users: you share the staging URL with them. Don't give them access to Odoo.sh; they don't need it.

Button 3: Publish to production

When everything worked in staging and it is also green, you use Publicar a producción (Publish to production). It asks which modules you want to publish (always your own) and a reason, because running it brings changes to your end users and affects the production database.

When it runs, the changes of the modules you chose move to the master branch and reach your users. If a module was not installed in one of the instances, you have to install it: it is not installed automatically.

When to publish to production

Every time you run any of the three buttons, the Odoo service is rebuilt in the databases tied to that branch, and you are without Odoo while that build runs. In development and staging nothing serious happens: it is not your production database and nobody on your team loses work, they just have to wait. In production you do collide with your end users.

  • Run button 3 only at a time you have scheduled and when no user is affected.
  • Tell your team that a production release is coming and that they will be without Odoo for a few minutes; with Odoo.sh it is sometimes several.
  • Choose times outside your regular working hours, or a maintenance window announced in advance within the working day.

What you must not do

  • Don't drag one branch onto another in the Odoo.sh panel. It is not the correct protocol: it breaks the continuous integration processes, merges whole branches and can put production back on an older version. To move your work, always use the GitHub Actions buttons.
  • Don't give all your users access to Odoo.sh. They don't need it, it is a very sensitive matter and, as the account owner, you are the one who must control very carefully who gets into that platform.
  • Don't use the guardian. It is a specific Ganemo action with security functions that review the changes between stages and stop the run if they detect a risk. You only use buttons 1, 2 and 3.
  • Don't mix your path with Ganemo's. Ganemo's modules, third-party modules and other partners' modules arrive through their own continuous integration processes. They are separate paths, and that lets different teams work without stepping on each other.

6 words so your requests are understood the first time

They work the same whether you say them to your technical team, your consultant or an AI.

WordWhat it means
ProductionThe Odoo your company really uses, with your end users.
StagingThe copy where you test first, with your data.
DevelopmentThe workshop where code is written; that is where you have the integrated AI to program without leaving Odoo.sh.
ModuleA package that adds or changes something in Odoo.
RepositoryThe central code archive, with its full history.
Deploy or publishTake a change from one environment to another.

With these words, a request changes completely:

Confusing requestClear request
“I need more access.” “I can't do anything.” Nobody knows what you need and the ticket drags on for days.“I want the quotation to show the crop and the hectares of each project. I'm going to develop it with AI in my development environment and I need to be able to publish it to staging and then to production.”

The formula is short: what you want to achieve, where, and what you need to do it. Don't describe only the symptom, state the goal.

Frequently asked questions

No. Dragging one branch onto another merges whole branches, breaks continuous integration and can put production back on an older version. Always use the GitHub Actions buttons.

Don't click button 2. Nothing that hasn't passed the tests should reach staging: skipping that step creates technical debt and makes maintenance more expensive.

At a time you have scheduled and announced to your team, preferably outside the usual working day. Each button rebuilds the environment and leaves it without Odoo while the build runs, which is sometimes several minutes.

No. You share the staging URL so they can test with their daily flows. Access to Odoo.sh should be controlled carefully by the account owner.

Do you develop on your Odoo with AI and want to do it with this workflow?

Tell us about your case and we will go through it with you.

00:00 You ask for a small change in your Odoo, one more field on the invoice or a new report, and it takes weeks because everything depends on your provider. Or someone does it quickly straight in production and one Monday morning your team can't invoice. Now that AI can program in minutes, the question is a different one: how do you let your team, assisted by AI, make changes to your system without putting the operation at risk? At Ganemo we solved it with a workflow where your team develops with autonomy while we keep taking care of the platform. Every change goes first through a test environment with a copy of your data. Your code, ours and that of any outside developer or other partner live separately, each kept by its own maintainer, so one piece of work doesn't step on another.

01:07 Many times the problem is not technical, it is communication. We ask for access when what we want is to change the format of an invoice, or we say “it doesn't work” without saying where. With AI it happens more, especially with people who are just starting to venture into technical work: you can build things by asking the AI without knowing the underlying concepts, and then you can't understand each other with your technical team or your consultant. This video is for you: I explain without jargon how your project works inside, the three environments where your code lives and how a change travels, in an orderly way, from the idea to your end user. At the end I leave you the key words so your requests are understood the first time.

02:11 Odoo.sh is where you manage the environments your Odoo runs in; this applies only if you have access. There are three environments: a kitchen for testing, where dishes are invented; a tasting area, where they are tried before going on the menu; and the dining room, where customers eat. Each environment is called a branch.

03:08 Production is the master branch. Names can vary, but under our standard we usually keep these. It is the Odoo your company uses every day with real data, and it is what you must protect like gold.

03:31 Staging, with a branch of the same name, is a copy of your production database: it has all the data, but it is separate from your operation. Odoo holds back the emails that would go out and disables scheduled tasks so your tests don't reach your customers. Even so, it is worth checking integrations before testing. For example, in production you send electronic invoices to the tax authority with legal and fiscal validity, and all of that has to be switched off. Localizations usually disable it, but you always have to check. It is a copy of production, but neutralized: no emails go out, there are no scheduled tasks and integrations are disconnected.

04:41 Finally, the main branch in the development environment is your workshop. Here you program with sample data, not your company's real information, and any mistake doesn't affect your operation. You have permission here to break anything. And does staging affect the operation? Not directly: even though you work with your real data, because it is neutralized you can test flows with it. Every change goes through staging before reaching production. To recap: you create in development, where technical tests run with data that isn't real; then it moves to staging, where you test your real flows without affecting production; and finally it reaches master, where your users use it day to day.

06:07 To see it in practice: I open my production database and look at the invoices, which run, say, from 21 to 26. I close it and open staging, where a message says it is a neutralized database. There I see the same receipts, the same data and an almost identical configuration. There can be differences depending on when the copy was generated: if I generated it when production had invoices up to 25, staging will have up to 25, and the ones I issue afterwards I will only see in production. It is critical because, when I test, I do it with my real configuration and my real data.

07:34 Behind Odoo.sh there is a GitHub repository. A repository is the central archive where all the project's code is stored with the history of every change: who made it, when and what it touched. It is the source of truth for each branch, and when a change enters a branch, Odoo.sh automatically updates the environment. That is why it is a sensitive matter and why it is important to understand the relationship. In GitHub we see the same branches, main, staging and master, and we know which environment each belongs to. One doesn't exist without the other: the Odoo.sh project's repository has to exist in GitHub for us to see everything we see from Odoo.sh.

09:03 Look at how it is organized. The customer addons folder is your folder: your modules go here. A module is a package that adds or changes something in Odoo, like a new field or a format. This is where you work, assisted by your AI. There may be other folders depending on who the maintainers are. You will also see the Odoo Partners folder, with the modules of our whole standard: the Peruvian localization, the advanced localization features for Colombia, Chile, Ecuador and the United States, payroll. Ganemo regenerates it on every deployment, so you shouldn't touch it. We work with large companies that have several partners, and each partner has its own folder and is responsible for its changes. If you change something in a folder that isn't yours, you later lose those changes or create serious inconsistencies, because you are not the one maintaining it. There are also more technical folders, like devOps, which holds among other things a list of modules that are deployed automatically through continuous integration. I suggest you don't touch them: we manage them.

11:45 There are also three very important files. The README is for you to read: if you have access to the GitHub repository, because not every user does, it is mandatory, especially if you are going to develop on your own. They are very basic rules that you must understand. AGENTS.md and CLAUDE.md are meant for your AI: from the moment you create your project with Ganemo we already give you the instructions for the agents, to reduce any risk when developing. When your AI works in this repository, it finds the rules there: where it should write, where it should not and how it should publish. As with a person, it is worth reviewing what it does before publishing it.

13:13 Now, the workflow: in the workshop you create, in staging you test and finally it reaches your end users. There is a cycle you must always respect, and for that we already have dedicated actions you run with one click. First, if you are going to develop in main, we have to make sure all the updates have reached that branch. Branches live in GitHub and each one reflects the truth of the project, which is what every Odoo based on that branch is running. That is why there is an essential rule: what you want to reach your Odoo exists first in its branch and only then in your Odoo.

14:23 This is key because, when you create from main, you do it on a technical base that must be up to date, even more so when you work with several development teams, which constantly update their modules. A simple example: Odoo made a change to its invoice and now there is a new field that identifies the invoice type. You want to show it in your printed format, but your branch is not updated, and you are going to create that field when it wasn't necessary, because it already existed in the updated code. It applies above all to third-party modules, which constantly update their information. And your agent, which knows the Odoo schema and the fields that exist, won't have a correct reference for the most up-to-date module to propose changes on. That is why this branch has to be up to date: that is step number one.

17:07 Button 1, Actualizar mi entorno. It brings into your development environment all the updated code, not only Ganemo's but any maintainer's or third-party module's: everything that is up to date in staging and was deployed by any maintainer, you will have updated in main. Golden rule: before moving or creating anything in main, do it. You go to Actions, select it, click Run workflow, type “sí” and click Run workflow. It is a simple click, but mandatory before you start creating absolutely anything. You also have the AI tab here, which I have shown you in other videos; before using it, update your environment so you work on a solid, up-to-date base.

18:43 Button 2, Probar en staging. It takes your development modules to staging so you can test them against a copy of your data. In this video I skip the part where you develop in main, because we already have videos on how to use the AI integrated into Odoo.sh. Once you have created your modules, you take them to staging from the Actions section of your repository: you click Probar en staging and Run workflow. If there is a particular module you want to test, you add it separated by commas; if not, you leave it blank and all of them are updated. Remember: everything reaches GitHub first and then the buttons are run. What is already in main is deployed to staging safely, without moving changes to modules or folders that belong to other maintainers. If other teams are testing things in staging, you don't touch their work or affect the version of the code they have running.

21:16 Something very important: don't send anything to staging unless it is absolutely green, that is, in success. If the tests that run automatically in the development environment are not green, don't click button 2, because it would take the changes to staging and nothing that hasn't passed the tests should get there. Don't break the protocols, don't load yourself with technical debt, don't make your code more expensive to maintain in the future or make a technician have to review and fix it, because fixing it will take almost as long as doing it from scratch. The autonomy you wanted to gain, you are not really gaining. When it is green, you come to Actions, button 2, Run workflow. And when staging finishes building and shows success, you connect and test with your own data that everything works.

23:01 Now the last step: once you have tested everything in staging and everything came out green, we go to the third button, Publicar a producción. You click Run workflow and say which modules you want to publish, always your own modules and customizations, and a reason, because running this means bringing changes to your end users and affecting your production database. You click the green button and, at that moment, the changes of the modules you chose move to the master branch and finally reach your end users. If a module was not installed in one of the instances, you have to install it: it is not installed automatically.

24:11 Another critical point: every time you run any of the buttons, the Odoo service is rebuilt in the databases tied to those branches and you are without Odoo for as many minutes as the build lasts. While main is building there is no way to connect; the same in staging. But on those branches it is fine: it is not your production database and it affects no user, except those using staging, who will have to wait. With good communication nothing happens. But if you affect the production branch, you are colliding with your end users.

25:18 That is why button 3 is not run at just any time: only at a time scheduled by you when you know no user will be affected. This implies communication and coordination: telling your team that a production release is coming and that they won't have Odoo for a few minutes, which with Odoo.sh is sometimes several. I suggest using it above all outside your regular working hours, or at times you announce, within your working day, as planned maintenance.

26:16 With these three buttons you have taken everything all the way to production. I make this guide so it is useful for support staff and for customers: I encourage you to be autonomous when developing, but that means getting past a small learning curve, which is watching this video and understanding what each thing is and how they relate.

26:55 There are other ways to move changes from one branch to another, like dropping one branch onto another, but I don't show it because it is not the correct protocol: all you would do is break the continuous integration processes and spoil the working harness we designed to reduce risk when you develop with AI. Each button has its own safety measures to move information correctly without affecting any other maintainer. That way conflicts are avoided and your work doesn't modify Ganemo's code or other developers' code. What does depend on you is testing your modules well in staging before publishing them.

28:01 The people who should test are not only the technical user creating with AI, but the end users, the ones who use Odoo day to day. You share the URL with them; they won't have access to Odoo.sh and you shouldn't give them any, they don't need it. It is a very sensitive matter and only you, as the account owner, should control it, very carefully.

28:53 We have a guardian, a specific action that you are not going to use: you only use one, two and three. The guardian contains security functions so that changes between the different stages are reviewed properly, and if it detects any risk, the run stops right there.

29:21 In summary, modules go from development to staging and from staging to production, or, as Odoo.sh shows it, from bottom to top, with buttons 2 and 3. Ganemo's modules arrive by their own path: we have our own continuous integration processes that let us deploy our modules to your instance, and even the third-party and other partners' modules we have integrated into your project. They are separate paths, and that is what lets different teams work without stepping on each other.

30:09 Six words so your requests are understood the first time, whether you make them to your technical team, your consultant or an AI. Production: the Odoo your company really uses, your end users. Staging: the copy where you test first, with your data. Development: the workshop where code is written, where you have the AI integrated to program without leaving Odoo.sh. Module: a package that adds or changes something in Odoo. Repository: the central code archive with its full history. Deploy or publish: take a change from one environment to another.

31:04 Phrases you will hear often and that you should also use: “we are going to deploy to staging the changes I made in my main branch, which I already published to GitHub”; “those changes my users already tested in staging, I now want to deploy to production, to my master branch”. They are different ways of expressing the same idea: taking a change from one environment to another.

31:40 Look at the difference. A confusing request: “I need more access”, “I can't do anything”. Nobody knows what you need and the handling of that ticket drags on for days. A clear request: “I want the quotation to show the crop and the hectares of each project; I'm going to develop it with AI in my development environment and I need to be able to publish it to staging and then to production”. With that, your consultant knows what you need and how to guide you. The formula is simple: what do you want to achieve? where? and what do you need to do it? Don't describe only the symptom, state the goal.

32:22 A golden rule: don't use Odoo.sh's merge panel, the option of dragging one branch and dropping it onto another. You merge whole branches and you can put production back on an older version. To move your work, always use the Actions buttons inside GitHub.

32:49 In the next video we will use all of this for real: we will ask the AI for a new module for this same company and take it from the idea to production, going very fast because you will already have reinforced your knowledge with this video. If something wasn't clear, watch it again or leave your questions in the comments and we will answer them.

Edited transcript, translated from the Spanish original: filler words and repetitions were removed and speech-recognition errors were fixed. The ideas are the author's.

How do I take an AI-made change to production in Odoo.sh without breaking anything?
Wilfredo Fernando Pastor Avila November 15, 2026
Share this post
Archive
Sign in to leave a comment
Manage Odoo product variants without errors: learn to exclude unwanted combinations and optimize your attribute grid
Discover how to stop your team from selling product combinations you don't offer, and keep your catalog clean and up to date with practical examples and a key Ganemo tool.