Achievements
Enterprise ERP migration from Odoo 16 to Odoo 19
Achievement summary
This summary provides the essential reading points. It does not replace the complete case study: scroll down to review the detailed context, steps, limitations, and critical review.
- Context
- In summer 2025, 1UP Distribution's Odoo 16 ERP, used by 20 internal users, needed to move beyond its support period with 16 custom modules and third-party extensions.
- Challenge
- Upgrade a central ERP without losing the data, business rules, and integrations that daily operations depended on.
- My role
- I led the three upgrades, technical checks and cutover. I coordinated acceptance testing with the business teams and addressed issues they reported after release.
- Key decision
- Proceed through three successive migrations, inventory customizations, and stabilize each business workflow after cutover.
- Result
- The ERP and required modules were migrated to Odoo 19 while preserving data, useful business functions, and the intended service continuity.
- Evidence
- Migration screenshots and the linked experience provide verifiable material, within the company's confidentiality constraints.View the detailed evidence
Visual proof
Screenshots and demos from real projects.
Media 1 of 16
Odoo 17 migration validation
Intermediate Odoo.sh migration step used to isolate incompatibilities before the final upgrade.
01
Presentation
At 1UP Distribution, twenty employees relied on Odoo 16 every day for accounting, sales, purchasing and inventory. The B2B website and several external services also exchanged data with the ERP. With this version approaching the end of support, I prepared the upgrade to Odoo 19, including sixteen in-house modules, third-party extensions and customizations made directly in the ERP with Odoo Studio.
ERP dependencies. The B2B site exchanged customer, product, order and stock data with Odoo. An integration hub also connected the ERP to marketplaces and ShippingBo, which centralizes orders and their preparation in the warehouse. Reporting tools used Odoo data for operational dashboards. Acceptance testing therefore needed to cover the application and the exchanges that helped staff and sales channels resume work.
Odoo Studio is a visual tool that lets users create data fields, modify ERP screens—known as views—or add automated actions without developing a complete module. These customizations are useful for responding quickly to a need, but they are primarily stored in the database rather than in the code repository. A code repository is a versioned space that stores the software files and the history of their changes. When Studio customizations become numerous, it is therefore more difficult for a developer to inventory them, track their evolution, and adapt them during a migration.
I handled the technical preparation, intermediate upgrades and cutover on Odoo.sh. The business teams checked their day-to-day workflows, and my manager helped make decisions about scope and release readiness.
02
Objectives, context and stakes
Accounting was the most sensitive area. The ERP notably records invoices received from suppliers as evidence of company purchases. In Odoo, not all information is stored solely in the PostgreSQL database — files associated with records are kept in a separate area called the filestore. This storage directory contains attachments and other binary data, meaning files such as PDF invoices, images, or imported documents. A migration could therefore leave the accounting entry for a purchase visible while making its attached invoice unavailable if the filestore was incomplete or incorrectly linked to the migrated database. Such a loss would reduce accounting traceability and make it more difficult to substantiate the transaction during an accounting or tax audit. This was especially important because customer and supplier invoices are supporting accounting documents that a company must retain for ten years from the end of the relevant financial year under French rules.
System availability was another major objective. Because the ERP supports the daily work of most employees, an interruption lasting several days was not acceptable. Migrations and fixes therefore had to be tested in advance in the Odoo.sh environments so that the production release would focus on applying a process that had already been validated. During the cutover, Odoo.sh had to rebuild the production environment, meaning recreate the application from the migrated database and the validated code version, before making it available to users again with the shortest possible interruption. Temporary unavailability of the B2B website was acceptable because its own code also needed to be adapted to the new ERP version. The priority, however, remained the rapid restart of Odoo, on which a greater number of internal processes depended.
03
Risks and mitigation measures
Loss or alteration of structured data. A database migration must do more than preserve the overall number of records. It must also retain their values, relationships, and history. An invoice still present but linked to the wrong supplier, an order with missing lines, or a payment that had lost its accounting link would have constituted functional data loss even if the database started successfully. Risk control consisted of working on realistic production copies, examining errors produced by each version change, and prioritizing checks on essential objects — customers, products, orders, invoices, payments, purchases, and stock movements.
Failed cutover and rollback. If Odoo became unavailable or a critical anomaly prevented business from resuming, the contingency plan was a rollback. This operation abandons the newly deployed version and restores the last known stable state. In this project, the recovery point was the complete backup taken immediately before production migration. Returning to that state would have limited data loss because the period between the backup and the attempted cutover had to remain as short as possible. Orders potentially left pending on external channels would then need to be checked and synchronized again to avoid duplicates or omissions.
04
The steps — what I did
Initial inventory and strategy for each module. I began by recording the version of every installed module in order to decide how each one should be handled. Extensions whose latest available release predated Odoo 16 were considered legacy modules, meaning old code that was no longer maintained for recent ERP versions. Migrating them did not mean preserving them at all costs — I had to prepare their clean removal, removing their code and dependencies without leaving inconsistent references in the database or breaking data that was still useful. For the other third-party modules, I looked for releases compatible with later Odoo versions. I downloaded free extensions and purchased new releases of paid extensions, then integrated them one at a time into migration tests. The existence of a recent release did not guarantee that it worked — some modules still contained errors that I had to fix. In other cases, the new code worked but no longer included customizations that had been added on top of the previous release. I then reintroduced those business adaptations into the new codebase.
Three upgrade stages. I adapted the code for each move, from version 16 to 17, then 18 and 19. At each stage, Odoo.sh rebuilt the environment using the converted database and the relevant branch. I reran checks after making fixes. That sequence helped me tie each failure to a specific release change and check the modules before proceeding to the next stage.
Finding the actual cause of an error. Most tracebacks identified the module, file, or method to examine clearly enough. When they were not explicit, I had to reconstruct the exact triggering conditions. I then analyzed four elements together — the code executing the operation, the specific data present in the database, changes introduced by the new Odoo code, and transformations performed by the migration script. This correlation was necessary because an error apparently located in standard code could be triggered only by old data, a customization, or a field that had not been transformed as expected. I therefore looked for the root cause, meaning the first defect that genuinely explained the chain of errors, instead of correcting only the final message displayed. This method avoided superficial fixes that would merely move the problem to the next rebuild.
Technical and functional acceptance testing. Once a build could start, validation did not stop at the absence of errors in the logs. I performed acceptance testing, meaning a series of checks that compare the resulting behavior with what the company expects. It covered sales, purchasing, accounting, inventory, and sales administration flows, as well as exchanges with the B2B website and other connected systems. I also reviewed the inventoried views, a view being a screen used to display or enter information in Odoo, along with automations, scheduled actions, and configuration settings. I had to verify not only that a screen loaded, but also that the displayed data was correct and that each action produced the expected outcome. Tests using different user profiles finally helped reveal a feature that worked for an administrator but was inaccessible to the person who actually needed to use it.
Production cutover on February 6, 2026. Once the successive migrations and acceptance tests gave us sufficient confidence, we created several production backups before launching the final operation on Odoo.sh. These backups were the available recovery points if the new version prevented business from resuming. The platform then ran the migration and rebuilt the production environment using the Odoo 19-compatible code. The operation temporarily made the ERP unavailable. As soon as it restarted, we ran another series of tests on the most critical processes to make a go/no-go decision — keep the new version if work could resume without a critical anomaly, or trigger a rollback to the backup if a sufficiently serious problem threatened data or blocked operations. No issue detected at that stage required such a rollback, so production remained on Odoo 19 and the stabilization phase began.
05
The stakeholders — interactions
Technical responsibility and functional responsibility. I handled the entire technical scope on my own — code analysis, module adaptation, successive migrations, error diagnosis, production preparation, and fixes after the cutover. The executive assistant was my main functional counterpart. Her broad knowledge enabled her to validate business processes, confirm which customizations were still required, and decide which ones could be removed because they no longer served a useful purpose.
Testing guided by user experience. I did not ask the teams merely to check whether the application opened. I asked them to reproduce everything they did daily and report differences, blockers, and unexpected behavior. This approach is exploratory business testing — users rely on their knowledge of real work to cover the situations they consider important instead of following only a technical scenario written by the developer. Users understood their own processes better than anyone else and could identify details that were invisible to me, such as a missing field, a step that had become longer, a changed calculation, or information that no longer appeared in the correct place.
06
The results
The ERP and essential workflows resumed on Odoo 19, with no reported permanent data loss. There is no publishable measurement of the cutover downtime. The gallery shows intermediate validations and extracts from the history of fixes.
Customizations we kept. All sixteen in-house modules were adapted to Odoo 19. Four third-party modules that were no longer needed were retired. We kept around 15% of the Studio customizations, including search filters that staff used daily. The others were reviewed against current needs and the features available in the new version. By the end of the stabilization period described here, no business requirement affected by these removals had been identified as needing to be restored.
Restoring integrations after cutover. The ERP came back first. I then updated the calls I maintained, including those for the B2B website, and checked exchanges in both directions. Most of the integrations we restored moved from JSON-RPC to JSON-2, which required updating calls and their API-key authentication. The main data exchanges resumed over the following days. One update still depended on the provider that maintained the integration.
More responsive bank reconciliation. Accounting staff observed that matching screens loaded faster. They use those screens throughout the day to match bank transactions to invoices and payments. This is a qualitative observation from use, with no comparable timing series across the two versions. Bank reconciliation still took longer to load than most ERP screens, making it a worthwhile candidate for targeted measurement.
07
After the project
After release, migration issues moved into the normal ERP backlog. Some integrations could be updated in-house. One still depended on the provider who controlled its code. User feedback also helped distinguish defects that needed fixes from older customizations that no longer needed to be restored.
An architecture less dependent on Studio and external extensions. In the medium term, I want to continue limiting Studio customizations and third-party modules when they make behavior difficult to trace or create dependence on an unresponsive vendor. The objective is not to redevelop everything internally — a maintained and well-documented external extension may remain the best choice. However, company-specific adaptations benefit from being placed in version-controlled internal modules. Their code and change history are then visible in the GitHub repository, testable in staging, and easier to review during a future migration. This direction increases control over the system without rejecting external components that provide genuine value.
08
My critical review
I started inventorying Studio customizations too late. As a result, some rules invisible in the repository were discovered during the upgrade. I also spent too much time resolving failures one by one before formalizing the recurring checks. Once the inventory had a clear structure, it became easier to decide what to port, replace or retire.
Automation errors that could have been detected before production. Some minor anomalies discovered after the cutover involved automated actions. They were not necessarily visible simply by opening a view or running a business flow once. An automation must be tested with its triggering event, input conditions, data changes, and effects that must not occur. My acceptance testing covered many uses, but it did not systematically formalize all these dimensions for every action. A test matrix associating each automation with a normal case, a case in which it must not run, and a result check would have detected more of these errors before production release.
I would keep the intermediate upgrades and business acceptance testing. From the start, I would add an automation inventory, repeatable checks for scheduled actions and recorded rehearsal durations. That would give stakeholders better evidence for choosing a cutover window.
09


