---
title: "Migrate to Odoo ERP: ERP Migration Guide & Service"
description: "Migrating to Odoo ERP? Import limits, the full migration checklist and every source FlitStack AI moves into Odoo ERP, with history and rollback."
url: "https://flitstack.ai/migrations/erp/odoo-erp"
---

# Migrate to Odoo ERP

Odoo ERP is a module-based, open-source business suite whose migration path rewards teams that pre-stage the chart of accounts, model inventory locations and BOMs against existing modules, and respect platform throughput limits before the first opening balance is posted.

Short answer

FlitStack AI migrates financial, supply chain, and operational data into Odoo ERP from 200+ ERPs, including NetSuite, Atlas ERP, ERPNext, Sage Intacct. Every field is mapped to Odoo ERP's objects, history and associations come across, the Odoo ERP setup is configured alongside, and the whole migration stays reversible in one click.

![](https://flitstack.ai/images/authors/aditya-kumar.webp)By [Aditya Kumar](https://flitstack.ai/about/aditya-kumar) Updated November 5, 2026

[Get a quote ](https://flitstack.ai/contact) [Odoo implementation service →](https://flitstack.ai/services/odoo-implementation)

![](https://flitstack.ai/images/illustrations/pair-stage.webp)

From Any source ![](https://flitstack.ai/platforms-trim/netsuite.webp) ![](https://flitstack.ai/platforms-trim/atlas-erp.webp) ![](https://flitstack.ai/platforms-trim/erpnext.webp)

Destination Odoo ERP ![](https://flitstack.ai/platforms-trim/odoo-erp.webp)

NetSuite Atlas ERP ERPNext Sage Intacct Odoo Enterprise

200+ sources mapped into Odoo ERP

## Systems we move into Odoo ERP

The ERPs teams most often move from. Each page shows what moves, the field mapping and what to watch for.

[NetSuite to Odoo ERP](https://flitstack.ai/migrations/erp/netsuite/to/odoo-erp) [Atlas ERP to Odoo ERP](https://flitstack.ai/migrations/erp/atlas-erp/to/odoo-erp) [ERPNext to Odoo ERP](https://flitstack.ai/migrations/erp/erpnext/to/odoo-erp) [Sage Intacct to Odoo ERP](https://flitstack.ai/migrations/erp/sage-intacct/to/odoo-erp) [Odoo Enterprise to Odoo ERP](https://flitstack.ai/migrations/erp/odoo-enterprise/to/odoo-erp)

## What Odoo ERP supports, and where its import tools stop

- Modular pay-as-you-grow model with 80+ apps under one database — teams start with CRM and add Accounting, Inventory, or Manufacturing without switching platforms.
- Free Community edition lets businesses validate Odoo fit before committing to Enterprise licensing costs that scale with user count.
- Lowest per-user pricing among mid-market ERPs, with a published free tier for one app and Standard plans starting around $24.90 per user per month.
- Native integration between modules — a confirmed Sales Order automatically updates inventory, invoicing, and accounting without manual re-entry.

**REST only** API key (Odoo 13+) or username/password via XML-RPC

**Rate limits** Not publicly documented by Odoo

| Object                          | Support | Note                                                                                                                                                                                                                                                                                        |
| ------------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Partners (Contacts/Companies)   | full    | Partners is Odoo's primary contact object. It uses External IDs (e.g. base.us) for cross-reference in imports. We preserve partner categories, addresses, and bank details and map them to the destination CRM's contact schema.                                                            |
| Products (Items)                | full    | Products include name, type (stockable/consumable/service), list price, standard cost, and variants via attribute combinations. We handle the product.supplierinfo relation for vendor pricing and preserve images via public URL during import.                                            |
| Inventory (Stock Moves/Quants)  | mapped  | Stock quants track on-hand quantities per location. We map warehouse locations to destination inventory locations, but lot/serial number traceability may require manual verification post-import due to destination schema differences.                                                    |
| Sales Orders                    | full    | Sales Orders link to Partners and Products with order lines. We preserve the full order lifecycle (draft → confirmed → done) and map fiscal positions that affect tax computation on the destination system.                                                                                |
| Invoices (Account Moves)        | mapped  | Odoo 17+ unified invoices into account.move with move\_type (out\_invoice, out\_refund, etc.). We map to destination invoice records but flag posted invoices as non-editable — they require credit notes for corrections rather than in-place edits.                                       |
| Chart of Accounts               | mapped  | Accounts are tied to fiscal positions and taxes by country. We map the account codes and names, but country-specific tax groups and fiscal position rules require explicit configuration in the destination ERP post-migration.                                                             |
| Projects                        | full    | Projects in Odoo have a task hierarchy and can belong to multiple stages. We preserve project stage pipelines and map task assignees using Odoo's many2one user reference format.                                                                                                           |
| Tasks                           | full    | Tasks link to Projects, include sub-tasks (parent\_id), and track stage, assignee, and deadline. We preserve the task hierarchy and map custom stage names to destination stage pipelines.                                                                                                  |
| Manufacturing Orders (MO)       | mapped  | MOs reference Bills of Materials (BoM) with component lines and workorder sequences. We map the BoM structure and MO states, but workorder routing dependencies may require re-sequencing in the destination system.                                                                        |
| Bills of Materials (BoM)        | mapped  | BoMs define product components and quantities. We preserve the product structure and type (kit, manufactured, phantom), but variant-specific BoMs require mapping to destination product variant IDs.                                                                                       |
| Employees                       | mapped  | Employees are in the hr.employee model and linked to Users. We map employee records but note that Employee categories, emergency contacts, and HR-specific fields are Odoo-specific and may not have a direct destination equivalent.                                                       |
| Custom Fields (ir.model.fields) | mapped  | Odoo allows custom fields via Settings → Technical or ir.model.fields. Custom fields added by Odoo Studio are stored with ttype and may have selection options. We preserve custom field definitions and values, but field types not supported by the destination system fall back to text. |
| Attachments                     | mapped  | Attachments (ir.attachment) store files in binary or as URLs. Large binary attachments should be provided as public URLs for Odoo to download at import time rather than uploaded directly via CSV.                                                                                         |
| Taxes                           | mapped  | Odoo defines taxes with scope (sale/purchase), tax\_type (percent, fixed, group), and country-specific fiscal positions. We map tax names and rates, but fiscal position automation requires destination-side configuration.                                                                |

## The Odoo ERP migration guide

## Why teams migrate to Odoo ERP

*The four shapes an Odoo ERP migration takes, and what makes the platform easier — or harder — than the category average.*

Odoo S.A. was founded by Fabien Pinckaers in 2005 as TinyERP, rebranded to OpenERP in 2009, then to Odoo in 2014, and is headquartered in Ramillies-Brabant-Wallon, Belgium[1](https://flitstack.ai/migrations/erp/odoo-erp#source-1). Odoo ERP is the integrated finance, inventory, manufacturing and procurement layer of a suite of around 80 official modules — Accounting, Inventory, Manufacturing, Purchase, Sales, Project, HR — all sharing the same PostgreSQL database and ORM.

The typical Odoo ERP customer is a small-to-mid-market manufacturer, distributor or services business — 25 to 500 users — that wants general ledger plus inventory plus production plus AP/AR under one schema, and is willing to absorb the open-source learning curve for the integration depth[2](https://flitstack.ai/migrations/erp/odoo-erp#source-2). Compared with SAP Business One or Dynamics 365 Business Central, Odoo positions on per-user cost; compared with NetSuite, on module breadth and a unified data model[3](https://flitstack.ai/migrations/erp/odoo-erp#source-3).

The shapes of migration that actually land on Odoo ERP tend to fall into four patterns. First, suite consolidation projects: a company replacing a stack of QuickBooks plus a separate WMS plus a spreadsheet-based MRP with the Odoo all-in-one suite. Second, vendor-cost exits from SAP, NetSuite or Oracle where total cost of ownership at 50–400 users no longer justifies the enterprise contract[5](https://flitstack.ai/migrations/erp/odoo-erp#source-5).

Third, legacy ERP replacements — older OpenERP/TinyERP installs, Sage 50, JD Edwards on-prem, JTL-Wawi, or country-specific country-by-country systems — where the source schema is loose and the project is really a re-architecture against `account.move` and `stock.move` [6](https://flitstack.ai/migrations/erp/odoo-erp#source-6). Fourth, Odoo-to-Odoo version migrations, where a team running Community 15 jumps to 18 or 19, or moves from Odoo.sh Enterprise back to self-hosted Community, with OpenUpgrade carrying the schema[7](https://flitstack.ai/migrations/erp/odoo-erp#source-7).

Each shape has a different difficulty profile: a QuickBooks-to-Odoo move usually has clean GL parity but messy chart-of-accounts numbering, while a SAP-to-Odoo migration carries rich automation that does not move across at all.

What makes migrating to Odoo ERP easier than the category average is the import tool itself — it accepts CSV and Excel files, auto-detects column types, supports relational fields via XML external IDs, and ships built into every model's list view through Actions → Import records[8](https://flitstack.ai/migrations/erp/odoo-erp#source-8). Pre-built templates exist for Contacts, Products, Chart of Accounts, Journal Entries and Bills of Materials.

What makes it harder than the average is the Community-vs-Enterprise gap — full Accounting (audit trail, follow-up letters, online bill scanning), Studio, Documents, Marketing Automation and several connector modules are Enterprise-only, and silently disappear if you restore an Enterprise database into a Community container[7](https://flitstack.ai/migrations/erp/odoo-erp#source-7). The second hard edge is the annual major-version cadence: every 12 months a breaking release ships, which means migration is not a one-time event but a recurring workstream every team plans around[11](https://flitstack.ai/migrations/erp/odoo-erp#source-11).

Studio customisations, Automated Actions, custom Python modules and country-specific localisations do not move with a CSV import — they are rebuilt as modules and configured in the destination. Teams that scope for that work up front finish on time; teams that assume parity do not.

> Studio customisations, localisations and Automated Actions do not move with a CSV import — they are rebuilt in the destination.

## The Odoo ERP data model you need to map into

*Models, ondelete semantics, and the external IDs you'll wire on every relational column — the destination schema decoded.*

Odoo's ERP is built around a small set of Python models, each declared as a class extending `models.Model` with attributes that the ORM persists into PostgreSQL[12](https://flitstack.ai/migrations/erp/odoo-erp#source-12). Finance, inventory and manufacturing sit on top of the same shared `res.partner` master record and `account.account` chart of accounts used by every other Odoo app.

Before you can map a field on the source side, you need to know exactly which destination model the row belongs on, what fields it requires, and which value will serve as its external ID for upsert. The table below summarises the models you will touch in an Odoo ERP migration[13](https://flitstack.ai/migrations/erp/odoo-erp#source-13).

| Object                               | What it stores                                                       | Required                                                              | Tier                                                        |
| ------------------------------------ | -------------------------------------------------------------------- | --------------------------------------------------------------------- | ----------------------------------------------------------- |
| res.partner                          | Master record for customers, vendors and employees                   | name; is\_company; customer\_rank / supplier\_rank                    | All editions                                                |
| account.account                      | Chart of Accounts — every GL account                                 | code; name; account\_type (income, expense, asset, liability, equity) | Full Accounting in Enterprise; basic Invoicing in Community |
| account.move / account.move.line     | Journal entries — invoices, bills, opening balances, all GL postings | journal\_id; date; line\_ids (debit/credit balanced)                  | All editions                                                |
| account.journal                      | Journals — Sales, Purchase, Bank, Cash, Miscellaneous                | name; type; code                                                      | All editions                                                |
| product.template / product.product   | Product master and per-variant SKUs                                  | name; type (consu / service / product); list\_price                   | All editions                                                |
| uom.uom / uom.category               | Units of Measure (kg, m, box of 6) and their conversion categories   | name; category\_id; factor                                            | Inventory module                                            |
| stock.location / stock.warehouse     | Physical and logical inventory locations                             | name; usage (internal, customer, supplier, inventory)                 | Inventory module                                            |
| stock.quant / stock.move / stock.lot | On-hand quantities, stock movements, and lot/serial numbers          | product\_id; location\_id; quantity                                   | Inventory module                                            |
| mrp.bom / mrp.bom.line               | Bills of Materials and their components                              | product\_tmpl\_id; product\_qty; bom\_line\_ids                       | Manufacturing module                                        |
| purchase.order / sale.order          | Purchase and sales orders with their order lines                     | partner\_id; date\_order; order\_line                                 | Purchase / Sales modules                                    |
| res.currency / res.currency.rate     | Currencies and dated exchange rates                                  | name (ISO code); rate; date                                           | All editions                                                |
| res.company                          | Legal entity — drives multi-company isolation                        | name; currency\_id; country\_id                                       | All editions; Enterprise required for inter-company rules   |

`res.partner` is the unifying record — a single row represents a customer, a vendor, an employee, or a contact at any of those, distinguished by the `customer_rank` and `supplier_rank` integer counters and linked through `parent_id` for company-and-contact hierarchies[14](https://flitstack.ai/migrations/erp/odoo-erp#source-14).

Odoo does not have a single canonical natural-key field on most models. Instead, the import tool uses an XML external ID — a string of the form `__import__.123` or `your_module.account_4000` — stored in the `id` column on the import spreadsheet. The external ID is the upsert key: re-importing the same row with the same external ID updates; a new external ID creates.

If you do not supply external IDs, Odoo generates them automatically and you lose the ability to deterministically re-import. For native dedup on `res.partner`, install the Data Cleaning app and configure dedup rules on email, phone, or VAT number. Custom field types determine validation and storage; the catalogue below covers what you can model and the limits you need to plan around[12](https://flitstack.ai/migrations/erp/odoo-erp#source-12).

| Field type               | Limit                                             | Notes                                                                                                                                   |
| ------------------------ | ------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| Char (single-line text)  | Default size=64, configurable                     | Maps to PostgreSQL varchar; trim before import                                                                                          |
| Text (multi-line text)   | Unlimited (PostgreSQL TEXT)                       | Used for descriptions, internal notes                                                                                                   |
| Integer / Float          | INT4 / NUMERIC in PostgreSQL                      | Float defaults to digits=(16,2); override per field for GL precision                                                                    |
| Monetary                 | Tied to res.currency precision                    | Use for amounts; system handles rounding by currency decimals                                                                           |
| Date / Datetime          | YYYY-MM-DD / YYYY-MM-DD HH:MM:SS in UTC           | Datetime stored UTC; ISO-8601 strongly recommended                                                                                      |
| Selection (picklist)     | Defined as Python tuple list                      | Internal key vs label; import expects the key[12](https://flitstack.ai/migrations/erp/odoo-erp#source-12)                               |
| Many2one (foreign key)   | Single related record                             | Resolves by name OR external ID OR database ID — pick one and be consistent[17](https://flitstack.ai/migrations/erp/odoo-erp#source-17) |
| One2many / Many2many     | Inverse / junction relations                      | Many2many uses comma-separated names on import[18](https://flitstack.ai/migrations/erp/odoo-erp#source-18)                              |
| Binary (attachments)     | 64 MiB default on Odoo.sh; 128 MiB on self-hosted | Stored as ir.attachment records[19](https://flitstack.ai/migrations/erp/odoo-erp#source-19)                                             |
| Custom fields via Studio | 21 field-type variants, Enterprise-only UI        | Community: edit via Developer Mode → Settings → Technical → Fields[20](https://flitstack.ai/migrations/erp/odoo-erp#source-20)          |

Relationships in Odoo are modelled by relational fields with explicit ondelete semantics: `cascade` deletes children when the parent is deleted, `restrict` blocks the parent delete, `set null` clears the foreign key[21](https://flitstack.ai/migrations/erp/odoo-erp#source-21). This is configured in `fields.py` per field, not at the database level you can flip from the UI — and it drives several of the pitfalls in Section 6.

**2–3 / sec / worker** Sales order throughput on Enterprise Practitioner-observed ceiling on Odoo 14–15 Enterprise — around 2–3 sales orders per second per worker[22](https://flitstack.ai/migrations/erp/odoo-erp#source-22). Odoo Online enforces tighter throttling; self-hosted scales with worker count.

Custom Objects in Odoo are not a separate concept — they are simply new Python models, declared in a custom module's `models/` folder, or created via Studio (Enterprise) which writes the same metadata into `ir.model` and `ir.model.fields` [20](https://flitstack.ai/migrations/erp/odoo-erp#source-20). Either way, the model must exist in the database before records of that type can be imported, and the module must be installed before the model is reachable.

## Pre-migration prep — the work before you touch Odoo ERP

*What must be true on the source, the destination, and across the team before the first row hits the import wizard.*

The single best predictor of a clean Odoo ERP migration is how much work you do on the source side before the first import button is pressed. Odoo's own implementation partners warn that data preparation — not the upload itself — is where most projects lose weeks, and the fix is almost always pre-processing rather than post-cleanup.

> The single best predictor of a clean migration is how much work you do before the first import button is pressed.

Treat the source export as raw material that needs to be shaped to Odoo's expected formats — dates rewritten to `YYYY-MM-DD` (ISO-8601), Selection values converted to their internal keys, Many2one relations resolved to either a name string or an external ID, currencies resolved to ISO codes that exist in `res.currency`, GL accounts mapped to the destination chart of accounts, and every row stamped with a stable `id` column.

### Source-side prep

- Audit and dedup the customer and vendor master in the source system before export. Odoo's Data Cleaning app handles post-import dedup on `res.partner` matching on email, phone and VAT, but it is much cheaper to dedup on the source than to merge after.
- Reconcile the source GL to its trial balance before extracting opening balances — every account that does not tie out on the source becomes a manual line item on the Odoo opening journal entry.
- Normalise dates to `YYYY-MM-DD` or `YYYY-MM-DD HH:MM:SS` in UTC. Odoo's importer auto-detects most formats but day/month inversions like `01-03-2016` are ambiguous; use ISO-8601 to remove the guesswork.
- Convert Selection field labels to internal keys — for account types, journal types, product types, every custom dropdown — Odoo expects the Python key (e.g. `asset_receivable`, `liability_payable`, `consu`, `product`), not the display label[12](https://flitstack.ai/migrations/erp/odoo-erp#source-12).
- Stamp a stable external ID in an `id` column on every export row — a UUID, the source platform's primary key, or a namespaced string like `legacy.account_4000`. This is what makes re-runs and reconciliation deterministic.
- Decide what is in scope for historical transactions. Open AP/AR invoices and the opening trial balance must move; closed prior-year journal entries usually stay in the source as a read-only archive.

### Destination-side prep

- Install the country localisation under Apps → search `l10n_` (for example `l10n_us`, `l10n_fr`, `l10n_de`) on a fresh database before any other Accounting setup — the localisation seeds the chart of accounts, taxes, and fiscal positions, and cannot be cleanly applied after journal entries exist[27](https://flitstack.ai/migrations/erp/odoo-erp#source-27).
- Create a staging database on Odoo.sh (staging branches are first-class) or duplicate the database on Odoo Online or on-prem to dry-run the import end-to-end. Restore a sanitised copy of production into staging weekly during the project.
- Provision users first under Settings → Users & Companies → Users, assigning each to Accounting, Inventory, Manufacturing and Purchase groups. Owner assignment fails silently if the referenced user does not exist.
- Pre-create every custom field on the right model via Studio (Enterprise) or Developer Mode → Settings → Technical → Fields (Community). Selection fields must have their full key list defined before any value is imported[20](https://flitstack.ai/migrations/erp/odoo-erp#source-20).
- Build the chart of accounts, journals, fiscal years, and tax codes in Accounting → Configuration before importing any journal entries — entries targeting a non-existent account or a closed period are rejected.
- Install required modules first — Accounting, Inventory, Manufacturing, Purchase, Sales, plus any OCA modules (OCA Audit Log, fs\_attachment, OpenUpgrade) you intend to depend on. Trying to import to a model whose module is not installed throws `Model not found`.

### People prep

Cutover only works if humans cooperate. Lock down a source-system freeze window — typically 24 to 72 hours for finance, longer for inventory if you are recounting — and communicate it to every department that touches the ERP. Train AP clerks on the Odoo vendor bill workflow, warehouse staff on the kanban barcode flow, and accountants on the journal-entry and reconciliation widgets before go-live, not after.

A typical 50-user professional-services Odoo migration runs four to eight weeks of elapsed time end-to-end; a 200-user multi-company manufacturing migration with Studio rebuilds, multi-currency consolidation and historical inventory loads runs three to six months[30](https://flitstack.ai/migrations/erp/odoo-erp#source-30). Build the human runway accordingly.

## Import mechanisms: UI wizard, base\_import, and scripted loads

*Multiple paths in, each with different limits and shapes. Picking the wrong one is how mid-migrations stall at the throughput ceiling.*

Odoo exposes several load paths and the right one depends on dataset size, model mix, and whether you need to re-run idempotently. The UI Import wizard (powered by the `base_import` module) covers most one-shot migrations under a few hundred thousand records. Scripted loads via the Odoo ORM handle programmatic, repeatable and very large loads. Third-party tools sit on top of both and add staging, transformation and dedup layers.

### UI Import wizard (base\_import)

The native import lives on every model's list view: open the model (Contacts, Accounting → Chart of Accounts, Inventory → Products, etc.), click the gear or Actions icon, then Import records → Upload File[8](https://flitstack.ai/migrations/erp/odoo-erp#source-8). The wizard accepts CSV and Excel (XLSX) files, auto-detects column-to-field mapping by name, exposes a Show fields of relation fields (advanced) toggle to see related model fields, and offers a Test mode that validates the file without writing rows.

There is no hard daily row cap in `base_import`, but practitioner reports suggest CSV-via-UI is reliable up to roughly 10,000 records per file and starts to hit worker timeouts above 50,000 on Odoo.sh and Online. The right call: UI for one-shot loads under 100k records on standard models, or any time you want a visual mapping review and a Test pass before commit.

For Excel files, save as `.xlsx` (not `.xls`) — older formats are less reliable. Re-imports against the same external ID in the `id` column update existing rows; new external IDs create. Warning: imports are permanent and cannot be undone from the UI — use the `created on` or `last modified` filter to locate import-batch rows for archival[17](https://flitstack.ai/migrations/erp/odoo-erp#source-17).

### Scripted loads through the Odoo ORM

Odoo's ORM exposes the same methods as the UI — `create`, `write`, `search_read`, and the bulk-friendly `load` — and can be driven by scripts running against an Odoo instance. The `load()` method is what `base_import` calls internally; it accepts a list of field names and a list of value rows and applies the same external-ID upsert semantics as the UI wizard. For bulk loads, batch records into chunks of 100 to 500 per `create` or `load` call; smaller batches add round-trip overhead, larger batches risk timeouts on Odoo.sh. `Model.create()` accepts a list of dictionaries — bulk-insert in a single call rather than a loop[33](https://flitstack.ai/migrations/erp/odoo-erp#source-33).

Choose the scripted path when the load is over 100k records, when custom models are involved, when the migration needs to be repeatable and audit-logged from your side, or when you are syncing from an external warehouse. Wrap calls in a back-off loop on throttling and connection-reset errors.

### Third-party staging tools and OpenUpgrade

Tools like Fivetran, Airbyte and Stacksync ship Odoo connectors that sit between the source and the destination. They are commonly used in two ways: (a) reverse-ETL where the source database is loaded into a warehouse, transformed in SQL, then synced into Odoo; and (b) staging-and-validate, where the tool generates the import CSV, runs type coercion, and feeds the result to the wizard.

For Odoo-version migrations specifically (Community 15 → 18, etc.), the Odoo Community Association's OpenUpgrade project provides the only working open-source upgrade scripts for Community editions[7](https://flitstack.ai/migrations/erp/odoo-erp#source-7). For Odoo Enterprise upgrades, Odoo S.A.'s paid upgrade service handles the schema transformation but is not available to Community users — and the annual major release cadence makes this a recurring cost line rather than a one-time event[11](https://flitstack.ai/migrations/erp/odoo-erp#source-11).

Under 10,000 records on standard models → UI base\_import wizard. 10,000–100,000 → UI wizard in batched files. Over 100,000, any custom models, opening-balance journal entries, or any re-runnable load → scripted ORM load() calls in chunks with a back-off loop.

## Mapping your data into Odoo ERP

*The longest section — because field mapping is where almost every ERP migration that fails actually breaks.*

Mapping is where every ERP migration earns its scars. The schema decisions you make in your mapping spreadsheet determine whether the trial balance ties on day one, whether inventory valuation matches on day five, and whether the closing process works at the first month-end after go-live.

Work model by model, top to bottom of the dependency order: `res.company` and `res.currency` first, then `res.users`, then `account.account` (chart of accounts) and `account.journal`, then customers and vendors on `res.partner`, then `product.template` with `uom.uom`, then `stock.location` and on-hand inventory, then `mrp.bom`, then open AP/AR via `account.move`, and finally the opening trial balance.

### Chart of accounts (account.account)

Install the country localisation module (e.g. `l10n_us`, `l10n_fr`, `l10n_de`) before any chart-of-accounts work — the localisation seeds the legally required CoA structure, default taxes and fiscal positions[27](https://flitstack.ai/migrations/erp/odoo-erp#source-27). Then map the source CoA to the localised CoA: most projects keep the localised account codes and only add custom accounts for operational tracking (departments, projects, cost centres) that the source had as analytic dimensions.

| Source                  | Destination   | Note                                                                                                                                                                          |
| ----------------------- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| GL account number       | code          | Renumber to fit localised CoA ranges; document the cross-walk                                                                                                                 |
| account name            | name          | Required; keep source name as `legacy_name` Char if useful                                                                                                                    |
| account type / category | account\_type | Selection key: asset\_current, asset\_receivable, liability\_current, liability\_payable, income, expense, equity[27](https://flitstack.ai/migrations/erp/odoo-erp#source-27) |
| reconcilable flag       | reconcile     | Set True on AR/AP control accounts; required for invoice matching                                                                                                             |
| currency restriction    | currency\_id  | Only set if account is restricted to a single non-company currency                                                                                                            |

### GL opening balances (account.move)

Opening balances post as a single Miscellaneous journal entry on `account.move` dated the day before go-live (e.g. 2026-01-01 entry on a 2026-02-01 cutover), with one `account.move.line` per account, debits equal to credits[35](https://flitstack.ai/migrations/erp/odoo-erp#source-35). The exception is AR and AP control accounts — those balances post as individual open invoice and bill records (next subsection), not as a single line, so that future receipts and payments can match by document.

Recommended sequence on the opening entry: assets first (cash, inventory control, fixed assets net of accumulated depreciation), then liabilities (accrued expenses, taxes payable, loans), then equity (retained earnings as the balancing account). The journal must balance to the penny — Odoo rejects unbalanced entries with `The total of the debits is not equal to the total of the credits`.

### Open AP / AR invoices (account.move with move\_type)

Open customer invoices import as `account.move` records with `move_type='out_invoice'` and `state='posted'`; open vendor bills use `move_type='in_invoice'`. Each invoice carries its own due date, partner, lines, tax and amount-residual — and crucially, its own original invoice date so that aging reports work correctly from day one.

Build one row per invoice header plus one row per line item (One2many on `invoice_line_ids`), with the invoice's external ID repeating on each line. After import, run the Accounting → Reporting → Partner Ledger report and reconcile against the source AR/AP aging — any partner whose balance does not match within rounding tolerance flags a mapping defect to fix before go-live.

### Inventory: products, UoM, locations, on-hand quantities

Inventory mapping touches four models in sequence. First, `uom.uom` and `uom.category` — every UoM you reference must already exist, and conversions only work between UoMs in the same category (Units, Weight, Volume, Length, Time)[36](https://flitstack.ai/migrations/erp/odoo-erp#source-36). If you sell in meters and buy in centimetres, both must be in the Length category with the correct `factor`.

Second, `product.template` and `product.product` — the template is the catalogue item, the `product.product` is the variant (size, colour, configuration). Required fields: `name`, `type` (Selection key: `consu`, `service`, or `product` for storable), `list_price`, `uom_id`, `uom_po_id`, and `categ_id` (product category). Set `tracking` to `lot` or `serial` if the SKU needs lot/serial tracking — this must be decided before the first stock move exists for that product, because Odoo blocks the change once movements have posted[37](https://flitstack.ai/migrations/erp/odoo-erp#source-37).

Third, `stock.warehouse` and `stock.location` — warehouses contain a tree of locations (`Stock`, `Stock/Shelf A`, `Stock/Quality Control`, `Customers`, `Vendors`, `Inventory adjustment`). Each location has a `usage` (Selection key: `internal`, `customer`, `supplier`, `inventory`, `production`, `transit`).

Fourth, on-hand inventory — the recommended path is Inventory → Operations → Physical Inventory which creates an Inventory Adjustment that posts as a `stock.move` from the virtual `Inventory adjustment` location into the real internal location, with the per-product quantity and lot/serial number where applicable. The corresponding GL entry hits the inventory control account on the opening journal entry — do not double-count by posting both the stock.move and a manual GL line for the same value.

### Bills of materials (mrp.bom)

BOMs import as `mrp.bom` headers (one row per assembly) plus `mrp.bom.line` children (one row per component). The header carries `product_tmpl_id`, `product_qty`, `code`, and `type` (Selection key: `normal`, `phantom` for kit-bill, `subcontract`). The lines carry `product_id`, `product_qty`, and `product_uom_id` [39](https://flitstack.ai/migrations/erp/odoo-erp#source-39).

BOM imports are bottom-up: every component product must exist before the BOM that references it, and multi-level BOMs need the sub-assembly's BOM imported before the top-level BOM that includes the sub-assembly. Practitioners report BOM creation is one of the heavier operations because each BOM needs the header create, then one create per line — under Odoo Online's tighter throttling, even a few thousand BOMs becomes hours[22](https://flitstack.ai/migrations/erp/odoo-erp#source-22).

### Multi-currency and historical exchange rates

Multi-currency is enabled in Accounting → Configuration → Settings → Currencies → Multi-Currencies and configured per-company through `res.company.currency_id`. For historical transactions in foreign currency, you import the original amount and original date in `amount_currency` and `date`, and Odoo posts the company-currency equivalent using the rate from `res.currency.rate` for that date — so the rate table must be populated for every historical date that has a foreign-currency transaction.

Without dated rates, Odoo falls back to the current rate and posts the wrong company-currency value[41](https://flitstack.ai/migrations/erp/odoo-erp#source-41). Build the rate import as one row per (currency, date, rate) triple and import it before any multi-currency invoices or journal entries. For multi-company setups, each `res.company` can have its own functional currency, and inter-company transactions revalue automatically.

### Fiscal year and period close

Fiscal year is configured in Accounting → Configuration → Settings → Fiscal Periods (last day of fiscal year, lock dates). Set the Journal Entries Lock Date to the day before your opening-balance date so that nobody (including the import job) can post prior-period entries by accident[27](https://flitstack.ai/migrations/erp/odoo-erp#source-27). After opening balances and open invoices are loaded and reconciled, advance the lock date to the day before the new period — this is how Odoo enforces period close.

### Custom-field mapping strategy

Resist the urge to map every source custom field one-to-one. Migrate only the custom fields used by an active process, automated action, or report in the last 12 months. Excess fields slow down list views and make the model harder to upgrade between Odoo versions because every custom field has to round-trip through OpenUpgrade or the paid upgrade service[7](https://flitstack.ai/migrations/erp/odoo-erp#source-7).

For Selection fields whose source values do not match the destination, either: (1) extend the destination Selection with the missing internal keys via Studio or `fields.py`, (2) collapse adjacent values during transform, or (3) introduce a parallel `legacy_value` Char field that holds the source value verbatim. Computed fields do not import — Odoo recomputes them on save — so any source formula must be rebuilt as a computed field on the model or replicated via Server Actions.

### Files, attachments, and audit trail

Attachments in Odoo live on the `ir.attachment` model and link to any record via `res_model` and `res_id`. Default per-attachment cap is 64 MiB on Odoo.sh and Odoo Online (the public reverse proxy enforces this) and 128 MiB on self-hosted instances that override server config[19](https://flitstack.ai/migrations/erp/odoo-erp#source-19). Supported image formats include JPEG, PNG, GIF, BMP, TIFF, SVG, ICO, WEBP, PSD and EPS[42](https://flitstack.ai/migrations/erp/odoo-erp#source-42).

Bulk attachment import is not part of `base_import` — the supported path is either (a) the Documents app (Enterprise) which exposes a drag-and-drop bulk uploader, (b) the fs\_attachment OCA module which moves the filestore to S3 or an external filesystem[43](https://flitstack.ai/migrations/erp/odoo-erp#source-43), or (c) scripted upload through the ORM where you load `ir.attachment` records with `datas`, `name`, `res_model` and `res_id` set.

Odoo records `create_date`, `create_uid`, `write_date` and `write_uid` automatically and does not preserve the source record's original creation date during import — `create_date` stamps to upload time[44](https://flitstack.ai/migrations/erp/odoo-erp#source-44). If you need the original audit trail, create `legacy_create_date` (Datetime) and `legacy_create_uid` (Many2one to `res.users`) custom fields per model and populate from the source export. Field-change auditing is provided by the Enterprise Accounting Audit Trail feature, and the OCA Audit Log module fills the same role on Community[45](https://flitstack.ai/migrations/erp/odoo-erp#source-45).

## The pitfalls that derail Odoo ERP migrations

*Ten specific failure modes — ranked by impact, each tied to the exact Odoo mechanism that breaks.*

**high Localisation installed after journal entries already exist**

The `l10n_*` localisation modules seed the chart of accounts, default taxes and fiscal positions. They are designed to be installed on a fresh database; once journal entries reference accounts, applying or switching a localisation throws constraint errors and partially-loaded CoA rows that the UI cannot cleanly delete[27](https://flitstack.ai/migrations/erp/odoo-erp#source-27). The recommended path is: spin up a fresh database, install the country localisation first, then run every other migration step. Switching localisation mid-project usually means restoring from backup.

**high Enterprise modules silently disabled on a Community restore**

Restoring an Odoo.sh Enterprise database into a self-hosted Community container marks Enterprise-only modules — Accounting (full), Documents, Studio, Marketing Automation, Audit Trail — as 'installed' but 'not installable, skipped'. The UI crashes with errors like `View types not defined map found in act_window` and Studio customisations vanish from form views[7](https://flitstack.ai/migrations/erp/odoo-erp#source-7). Before you switch hosting tiers, list every installed module via Settings → Apps → Installed and confirm each has a Community equivalent or a replacement plan.

**high Opening journal entry does not balance to the penny**

Odoo rejects any `account.move` whose total debits do not equal total credits with `The total of the debits is not equal to the total of the credits` and refuses to post. Rounding differences from a foreign-currency source ledger, fractional cents in inventory valuation, or accumulated retained-earnings calculation off by 0.01 are the usual culprits. The fix is a single 'Rounding Adjustment' line posted to a designated rounding account on the opening entry — do not start chasing the penny across operational accounts.

**high Selection field label vs internal key mismatch**

Odoo Selection fields — `account.account.account_type`, `product.template.type`, `account.move.move_type`, every custom dropdown — store an internal Python key distinct from the UI label. The label is `Receivable`; the key is `asset_receivable`. The import wizard rejects label-only payloads with a vague `Unsupported format character` or silently coerces to a default. Build your transform layer against the model's `selection` tuple in code (Developer Mode → Settings → Technical → Fields), never against what an admin sees in the UI[12](https://flitstack.ai/migrations/erp/odoo-erp#source-12).

**high Throughput throttling on Odoo Online slows large loads**

Practitioners testing importers on Odoo 17 report the Odoo Online terms of use enforce tight throughput throttling[22](https://flitstack.ai/migrations/erp/odoo-erp#source-22). Combined with Odoo's standard 'creating more than 2-3 sales orders per second per worker is difficult' guidance even on Enterprise, a BOM-and-inventory load can take days instead of hours. Drop concurrency to a single worker on Odoo Online and rely on chunked `load()` calls of 100–500 rows; on Odoo.sh and self-hosted, scale parallelism against your server's worker count.

**high Product tracking changed after the first stock move exists**

Setting `product.product.tracking` to `lot` or `serial` is irreversible once stock has moved against that product. If you import inventory without tracking enabled and later need to enable lot tracking, Odoo blocks the change with `You can only change the tracking of a product on a product without quantities on hand` — and your remediation is to liquidate all stock to a virtual location, change tracking, then re-import with lots[37](https://flitstack.ai/migrations/erp/odoo-erp#source-37). Decide tracking model per product before the first stock.move posts.

**high Multi-currency without dated exchange rates loads wrong company-currency values**

When a multi-currency invoice imports with `currency_id` set to a foreign currency, Odoo uses the rate on `res.currency.rate` for the invoice's `date` to compute the company-currency equivalent. If the rate for that date does not exist, Odoo falls back to the most recent available rate and posts a materially wrong number — and the field-level error log gives no warning[41](https://flitstack.ai/migrations/erp/odoo-erp#source-41). Populate `res.currency.rate` for every distinct invoice date in the foreign-currency dataset before importing the invoices.

**medium create\_date cannot be overridden on import**

Odoo does not preserve the source record's creation date during import — `create_date`, `create_uid`, `write_date` and `write_uid` are ORM-managed and stamp to upload time and the import user[44](https://flitstack.ai/migrations/erp/odoo-erp#source-44). Teams discover this on day two when reports filtered by Created Date return everything stamped to import day. The mitigation is to create `legacy_create_date` and `legacy_write_date` custom Datetime fields on every imported model, populate them from the source export, and rewrite historical-period reports to use the legacy fields.

**medium Date format auto-detect inverts day and month**

Odoo's importer auto-detects date columns but warns that day-month inversions like `01-03-2016` are ambiguous and may be guessed wrong. Worse, error messages from XLSX imports surface as `Column activity_ids/date_deadline contains incorrect values. Error in line 1: unconverted data remains: 2019-12-16` with no field-level hint about what went wrong[46](https://flitstack.ai/migrations/erp/odoo-erp#source-46). Always set the Date Format explicitly in the wizard's Formatting Options to ISO-8601 (`YYYY-MM-DD`), or convert to ISO before export.

**medium ondelete=restrict blocks parent deletion across the dependency chain**

Relational fields in Odoo specify `ondelete='cascade'`, `'restrict'` or `'set null'` per field[21](https://flitstack.ai/migrations/erp/odoo-erp#source-21). If you import test data into a sandbox, then try to delete a parent record (a `res.partner` referenced by an `account.move`, a `product.template` referenced by a `stock.move`), Odoo blocks the delete with `The operation cannot be completed: Another model is using the record you are trying to delete` [47](https://flitstack.ai/migrations/erp/odoo-erp#source-47). Plan archival, not deletion, for parent records — use the `active=False` boolean to soft-delete.

**low Annual major-version cadence forces a recurring migration workstream**

Odoo ships a breaking major release every 12 months. Each release ages out community modules, deprecates ORM patterns and may shift schema in localisations[11](https://flitstack.ai/migrations/erp/odoo-erp#source-11). A migration in 2026 to Odoo 19 will face an OpenUpgrade or paid-upgrade event in 2027 to reach Odoo 20, in 2028 for 21, and so on. Treat migration as an ongoing capability rather than a one-time project; lock customisations into named modules with manifest version pins, and budget upgrade cycles into the operating cost from year one.

**low Data residency is fixed at signup on Odoo Online and Odoo.sh**

Odoo.sh has seven Google Cloud regions — Iowa, Toronto, Belgium, Dammam, Mumbai, Singapore, Sydney — and Odoo Online assigns customers based on region at signup. There is no bring-your-own-cloud option, no African data centre, and changing region after signup requires a support-managed migration that schedules in weeks. If your project requires EU residency under GDPR or India DPDP residency and the account was created in the wrong region, plan the regional move before the data migration, or move records twice.

## Validation and cutover

*What to verify after the import job, in what order — and how to fail safely when something is wrong.*

Validation is the bridge between the import finishing and users being allowed in. Odoo implementation partners recommend a three-stage validation: a test load of 10 percent of records with stakeholder spot-checks, the full load with real-time monitoring of GL balance and stock counts, and a 30-day post-migration data-quality audit. The most reliable signal is having finance, AP, AR and warehouse leads verify their own records against the source.

Build a reconciliation queries spreadsheet that compares source and destination on each of these counts. Anything outside a 0.5 percent variance — or any non-zero variance on the trial balance — gets investigated before users get login access.

- Trial balance match — run Accounting → Reporting → Trial Balance on Odoo dated the opening-balance date and reconcile every account to the source trial balance. Any non-zero variance is a defect, not a rounding issue.
- AR aging by partner vs source — run Accounting → Reporting → Partner Ledger filtered to receivable accounts and compare partner-by-partner totals against the source AR aging report.
- AP aging by vendor vs source — same as AR, against the source AP aging.
- Stock on hand by warehouse and location vs the source physical count — run Inventory → Reporting → Inventory Valuation and reconcile against the source warehouse management report.
- Inventory valuation vs the source GL inventory control account — these must tie within rounding; any larger variance indicates a unit-of-measure conversion error or a cost-method mismatch (FIFO/Average/Standard).
- Open purchase and sales orders vs source — count distinct `purchase.order` and `sale.order` in `draft` or `purchase`/`sale` state and verify against the source open-orders list.
- BOM count and component count — `GROUP BY product_tmpl_id` on `mrp.bom` and compare against the source manufacturing master.
- External-ID uniqueness — query `ir.model.data` for duplicate `(module, name)` combinations on your migration namespace; any duplicates indicate the dedup transform missed cases.
- Multi-company isolation — if multi-company is in scope, query each `res.company` and confirm `account.move` rows are scoped to the right `company_id`.

On top of reconciliation, run a manual spot-check protocol: pick 30 random records across models — five open invoices, five vendor bills, five products with inventory, five BOMs, five sales orders, five journal entries — and verify each field against the source UI. If a non-trivial discrepancy shows up in three or more of the 30, halt the load, fix the root cause, and re-import the affected rows by external ID.

Odoo does not ship a native bulk-undo for imports — the documentation is explicit that imports are permanent[17](https://flitstack.ai/migrations/erp/odoo-erp#source-17). The closest things are the OCA Audit Log module (when configured with the right rules in advance)[45](https://flitstack.ai/migrations/erp/odoo-erp#source-45), the Enterprise Accounting Audit Trail for journal entries, and Odoo.sh staging branches which let you fork production and roll back at the database level. None is a one-click reversal; all depend on having set them up before the import.

The real rollback strategy remains: take a full PostgreSQL backup via `/web/database/manager` (`pg_dump -Fc` plus the filestore directory) before the import starts, stamp every imported row with a custom `import_batch_id` Char field, and if catastrophe strikes, archive-by-batch and re-import from the cleaned source.

Cutover sequencing: (1) source goes read-only and the finance, AP, AR and warehouse teams are notified; (2) physical inventory count completes and loads as opening on-hand; (3) final delta export captures everything that changed during the test-import window; (4) delta imports with the same external-ID namespace; (5) trial-balance and AR/AP reconciliation runs; (6) lock dates advance to the day before go-live; (7) users get login access plus a 48-hour hyper-care window; (8) source decommission schedules 90 to 180 days out.

## Migration partners and tools

*Official partners, OCA modules, iPaaS connectors, specialist migration shops — what each is good for and how to choose.*

Odoo S.A. runs a tiered partner programme — Gold, Silver and Ready — based on certifications, customer count and recurring Enterprise revenue, and lists 5,000+ partners across 120+ countries on its public directory[52](https://flitstack.ai/migrations/erp/odoo-erp#source-52). For ERP migrations specifically, partners with explicit SAP-to-Odoo, NetSuite-to-Odoo, Sage-to-Odoo or QuickBooks-to-Odoo practices tend to ship cleaner than generalist shops[30](https://flitstack.ai/migrations/erp/odoo-erp#source-30). The Odoo Community Association (OCA) maintains modules — Audit Log, OpenUpgrade, fs\_attachment — that fill gaps left by Enterprise[7](https://flitstack.ai/migrations/erp/odoo-erp#source-7) [45](https://flitstack.ai/migrations/erp/odoo-erp#source-45).

Cybrosys Technologies, Open Technology Solutions, Synavos, Aspire Softserv, Silent Infotech, Iqra Technology, Softeko, Braincuber, Steersman and ECOSIRE are commonly named in the migration corner of the market and each offers fixed-scope or hourly-rate migration packages alongside ongoing managed services[30](https://flitstack.ai/migrations/erp/odoo-erp#source-30). Odoo S.A. also runs a paid upgrade service for Enterprise customers, which handles version-to-version schema migration but is not available to Community users — for Community, OpenUpgrade is the working alternative[7](https://flitstack.ai/migrations/erp/odoo-erp#source-7).

On the ETL and iPaaS side, Fivetran, Airbyte and Stacksync ship Odoo connectors, and several Odoo Apps Store extensions (Import Bridge by Axis, base\_import\_async by OCA) add async-job patterns on top of the wizard. Their role in an ERP migration is rarely the migration itself — it is the staging layer, the transformation layer that resolves Selection values and Many2one relations, and the ongoing-sync layer post-cutover.

Managed-migration cost ranges vary widely with user count and module scope. Practitioner pricing for Odoo ERP migrations runs roughly $3,000–$10,000 for small businesses (under 10 users, single-company, standard modules), $20,000–$50,000 for medium businesses (11–50 users, multiple modules with moderate customisation), and $50,000–$100,000+ for large enterprises (50+ users, multi-company, heavy customisation, multiple integrations)[30](https://flitstack.ai/migrations/erp/odoo-erp#source-30).

Hourly rates for Odoo professional services range $10–$150+ per hour depending on region and partner expertise. The upper end of the curve is driven by user count, the number of modules in scope (Accounting, Inventory, Manufacturing, Purchase, Sales, HR, Project — each adds elapsed time), the depth of historical data, multi-currency or multi-company complexity, and the number of third-party integrations that need rebuilding rather than re-pointed.

For teams that want to outsource the migration end-to-end, FlitStack specialises in Odoo ERP migrations and handles the localisation install, chart-of-accounts cross-walk, opening-balance journal preparation, inventory and BOM load, multi-currency rate population, and validation work described in Sections 5 and 7 of this guide. Pricing is fixed-fee, based on user count, module scope and source platform, with separate line items for multi-company, historical-data depth and custom modules so the scope is transparent before signature.

This is one of several legitimate paths — the right choice for any given team depends on whether they want an Odoo Gold Partner, the paid Odoo upgrade service, an iPaaS-first approach, an OCA-and-OpenUpgrade route, or a specialist migration vendor. \[Explore FlitStack →]\(/contact)

In this guide

## Odoo ERP migration checklist

An exhaustive 8-phase punch list for moving chart of accounts, opening balances, stock, BOMs, multi-currency, and AP/AR into Odoo ERP via base\_import.import, XML-RPC, and the ORM load() method. Typical timeline: 8–24 weeks.

0\. Decide & Plan 12 tasks

- **Decide and document the Odoo deployment target.** Choose Odoo Online (SaaS, no custom server-side code, throttled write throughput), Odoo.sh (managed PostgreSQL with staging branches and shell access), or on-premise (full control over filestore, workers, and ir.config\_parameter). Each path has different access to shell, database manager, and per-file caps.*If skipped: Picking Odoo Online and then discovering you need a custom localization module or server action forces a re-platform mid-project.*
- **Decide between Community and Enterprise edition.** Community is free but excludes the full Accounting app, Studio, the Documents app, OCR on bills, MRP master production schedule, and several l10n\_\* localization modules. Confirm which account.\*, mrp.\*, and stock.\* features the target workflow requires before purchase.*If skipped: Restoring an Enterprise database into a Community container marks Enterprise modules as 'not installable, skipped' and breaks the Accounting app entirely on Community.*
- **Pin the exact Odoo major version for the cutover.** Pin Odoo 17, 18, or 19 before mapping. View XML, model names, and Selection options shift between majors (e.g. \<tree> became \<list> in 18). For migrations between major versions of an existing Odoo database, plan for the OpenUpgrade tooling path rather than treating it as a fresh import.*If skipped: Mapping against the wrong major produces import files referencing fields that have been renamed or removed.*
- **Pick the l10n\_\* localization module per country of operation.** Each country has a dedicated chart-of-accounts and tax module (e.g. l10n\_us, l10n\_de, l10n\_fr, l10n\_in). Choose one per res.company before any account.account record is created — switching the localization after accounts exist is not supported.*If skipped: Switching localizations post-load forces a database rebuild because the chart-of-accounts template is one-shot.*
- **Define migration scope by Odoo model.** List in-scope models explicitly: res.company, res.partner, account.account, account.journal, account.move, account.payment, product.template, product.product, uom.uom, stock.location, stock.warehouse, stock.lot, stock.quant, mrp.bom, mrp.bom.line, res.currency, res.currency.rate. Mark each as in or out of scope.
- **Define the historical-data window for posted journals.** Decide how many fiscal years of posted account.move records migrate as posted documents versus collapse into a single opening-balance journal. The standard convention is: prior closed years collapse into one opening journal; the current open year migrates as posted documents.*If skipped: Migrating five years of posted journals when only opening balances are needed inflates database size by an order of magnitude and slows every report.*
- **Decide the multi-company structure.** Map source legal entities to res.company records. Decide whether each company gets its own chart-of-accounts (separate l10n\_\* installs) or shares one. Document the parent\_id hierarchy if companies consolidate.
- **Identify legal, residency, and retention constraints.** Confirm the Odoo.sh region matches data-residency obligations. As of 2026, Odoo.sh has seven data center regions: Iowa, Toronto, Saint-Ghislain, Dammam, Mumbai, Singapore, Sydney. Document GDPR data-subject access and erasure procedures against res.partner and account.move. Document audit-log retention for financial records.*If skipped: Discovering a residency conflict after go-live forces a database export, region re-provision, and re-import.*
- **Assign a single Directly Responsible Individual plus a finance approver.** Name one accountable owner with authority to cut scope and one finance approver who signs the opening trial balance and the post-load reconciliation in writing.
- **Set the cutover window and source-system freeze date.** Pick the cutover datetime in the destination timezone. Align it to a period close in the source so the opening balance has a clean cutoff. Communicate both to all source users at least four weeks in advance.
- **Document the migration success criteria.** Write the falsifiable conditions: opening trial balance ties to source to the cent, every open AR/AP invoice exists in Odoo with matching residual, stock-on-hand per stock.location matches source, BOMs explode to the same components, multi-currency unrealized gain/loss reconciles.*If skipped: Without explicit success criteria the project never formally closes and finance refuses sign-off.*
- **List explicit out-of-scope items.** Capture items intentionally excluded (e.g. closed work orders older than three years, deprecated stock locations, retired products with zero on-hand). Out-of-scope items become scope creep without this list.

1\. Pre-Migration Prep 28 tasks

- **Export baseline record counts per source object.** Capture row counts for customers, vendors, products, accounts, journal entries, open invoices, stock locations, stock on hand, BOMs, and currencies. Date-stamp the snapshot.*If skipped: Without a baseline count you cannot prove completeness at reconciliation.*
- **Run the source-system trial balance and freeze a copy.** Pull the trial balance as of the planned cutover date. Print to PDF and capture the CSV. This becomes the target the opening-balance journal in Odoo must tie to.*If skipped: Without a frozen source trial balance the reconciliation in Phase 6 has no anchor and finance cannot sign off.*
- **Deduplicate source customers and vendors using VAT/tax-ID plus email.** Resolve flagged duplicates manually; keep a merge audit log mapping merged-from IDs to surviving IDs. VAT / tax registration ID is more reliable than name for vendor dedup.*If skipped: Duplicate vendors in res.partner inflate AP aging and split payment history across two records.*
- **Standardize country and state values to ISO-3166 codes.** res.country expects an ISO code (e.g. 'US', 'DE') for import. Convert source 'United States', 'USA', 'us' to a single 'US' value before transform.*If skipped: Mismatched country strings either fail the import row or silently leave country blank.*
- **Standardize currency codes to ISO-4217 and phone numbers to E.164.** res.currency uses three-letter ISO codes (USD, EUR, INR, GBP). Convert source '$' or 'US Dollar' to 'USD'. Pre-normalize phone numbers to '+\<country>\<number>'.
- **Identify products missing required attributes.** product.template requires name, type (consumable, service, storable/product), and uom\_id. Surface and fix any source product missing these before transform.*If skipped: Products with missing required fields fail row-by-row and force a partial re-import.*
- **Reconcile source AR and AP aging to the trial balance.** Sum open AR invoices and confirm it equals the AR control account in the source trial balance. Same for AP. Resolve any drift before exporting — it does not get easier in Odoo.*If skipped: AR/AP that does not tie to the GL in the source will never tie in Odoo no matter how careful the load is.*
- **Inventory source custom fields with type and selection options.** List every non-standard field with its type, allowed values, required flag, and which records use it. This drives the Phase 1b destination field creation.
- **Archive obsolete and orphaned source records.** Products with zero on-hand and no transactions in three years, vendors with no activity in two years, accounts with zero balance and no movement in five years — archive on the source so they do not export.
- **Provision the production Odoo database.** On Odoo Online create the production database via the customer portal. On Odoo.sh create the production branch. On-premise install the matching Odoo version and create the production database via the database manager.
- **Provision a separate sandbox database as a duplicate of production config.** On Odoo.sh use a staging branch off production. On Odoo Online use 'Duplicate Database' in the database manager. On-premise restore a fresh blank database with the same module set.*If skipped: Skipping the sandbox forces every test against production and contaminates real financial data with test rows.*
- **Install the country localization module first.** Settings → Apps → install l10n\_\<country> before installing Accounting. The localization creates the country-specific chart-of-accounts template, tax records, and fiscal positions. Installing Accounting first and the localization later leaves you with the generic chart.*If skipped: An incorrect chart-of-accounts template at install time cannot be swapped without rebuilding the database.*
- **Install Accounting, Inventory, Manufacturing, and Sales/Purchase apps.** Settings → Apps → install the core ERP modules in the order: Accounting, Inventory, Purchase, Sales, Manufacturing. Dependencies resolve automatically; installing in this order avoids the 'module not installable' state.
- **Configure res.company and org-level settings before any transactional record.** Set legal name, VAT/tax-ID, currency\_id, country\_id, fiscal\_country\_id, chart\_template\_id (auto-set by l10n\_\*), timezone, language, and tax cash-basis flag on res.company. These propagate defaults across every model and affect how base\_import.import interprets dates and numbers.*If skipped: Changing res.company.currency\_id or timezone after data exists requires reposting every journal and shifts every imported datetime.*
- **Create res.users for every employee, salesperson, and accountant who needs access.** Settings → Users & Companies → Users. Create each user with the correct access rights (Accounting / Adviser, Inventory / Manager, etc.). Capture each user's login email — this becomes the lookup key during import.
- **Create account.journal records for sales, purchases, bank, cash, and miscellaneous.** Accounting → Configuration → Journals. Each journal needs type, code, default debit/credit account, and sequence. Posted account.move records require journal\_id.*If skipped: Importing posted journal entries without journals pre-created produces a hard foreign-key error on every row.*
- **Create the account.fiscal.year records (or set fiscal year range on res.company).** Accounting → Configuration → Fiscal Years. Create the closed prior year (for the opening journal) and the current open year. Periods must exist before journal entries can be posted into them.*If skipped: Posting journals without a fiscal year defined throws 'no open fiscal year' errors and blocks the opening-balance entry.*
- **Configure inventory valuation method per product.category.** Inventory → Configuration → Product Categories → Costing Method. Pick Standard Price, Average Cost (AVCO), or First In First Out (FIFO) per category. Switching after stock.quant rows exist requires recomputing valuation across history.*If skipped: FIFO retroactively applied to AVCO inventory produces non-deterministic valuation that finance cannot tie back.*
- **Create stock.warehouse and stock.location records used by source data.** Inventory → Configuration → Warehouses, then Locations. Each warehouse creates its own stock.location tree (Stock, Input, Output, Quality Control). Pre-create supplier, customer, inventory adjustment, scrap, and any custom sub-locations before stock.quant load — stock.quant references stock.location by external ID.*If skipped: Missing stock.location records cause every stock.quant row to fail and leave on-hand at zero.*
- **Create uom.category and uom.uom records used by source products.** Settings → Technical → Units of Measure. Each uom.uom belongs to one uom.category (Weight, Volume, Unit, Length, Time). Conversion ratios are within-category only. Pre-create all custom units before importing products.*If skipped: Importing a product against a uom that does not exist defaults it to 'Units' and silently corrupts every subsequent stock movement quantity.*
- **Create res.currency.rate seed rows for every currency in scope.** Accounting → Configuration → Currencies → Rates. Each foreign currency needs at least one res.currency.rate row dated on or before the earliest historical document. Without a dated rate, journal entries in that currency cannot post.*If skipped: Missing res.currency.rate rows block every multi-currency document and force a re-load after rates are seeded.*
- **Configure account.tax records via the localization or manually.** l10n\_\* installs the country's standard taxes. Verify rates and accounts, and add any custom taxes (city, state, withholding) before importing invoices that reference them.
- **Create custom fields on the target models before import.** Use Studio (Enterprise) or developer-mode → Settings → Technical → Fields (Community) to create each custom field with the correct ttype, selection options, and required flag. Importing into a field that does not yet exist silently drops the column.*If skipped: Discovering a missing custom field after a 100k-row load forces a transform rebuild and re-import.*
- **Set ir.attachment storage location and confirm per-file cap.** Odoo's default per-attachment cap is 64 MiB on Odoo Online and 128 MiB on on-prem/Odoo.sh. For larger files configure the attachment store on the filesystem and update the limit via ir.config\_parameter web.max\_file\_upload\_size.*If skipped: Files over the cap fail silently in batch imports and leave records with broken document references.*
- **Configure a dedicated migration user account.** Create a dedicated user (e.g. 'migration\_bot') with admin rights. All bulk-load operations run as this user so the audit trail attributes writes correctly.
- **Communicate the source-system freeze window to all users.** Send the freeze datetime, the cutover datetime, and the read-only date for the source. State explicitly what users can and cannot do during the freeze (no posting invoices, no stock moves, no PO receipts).
- **Schedule role-segmented training on Odoo basics.** Accounting (chart of accounts, journals, reconciliation), Inventory (transfers, scrap, lot tracking), Manufacturing (BOMs, work orders), Sales/Purchase (quotations, RFQs). Record each session.
- **Designate first-responder support for the first 72 hours post-cutover.** Name one finance, one inventory/ops, and one IT lead on call. Publish the escalation contact and the channel where users report issues.*If skipped: Without named responders the inevitable cutover-day questions land in random inboxes and lose audit trail.*

2\. Source Export 16 tasks

- **Export all source customers and vendors with every standard and custom field.** Include the source's primary key as a column — this becomes the Odoo external ID. Capture VAT/tax-ID, payment terms, and price list assignment.*If skipped: Forgetting the source ID column makes idempotent re-runs impossible and forces full re-imports.*
- **Export the source chart of accounts with account code, name, type, and parent.** This is the input to mapping into account.account. Capture currency\_id per foreign-currency account.
- **Export the closing trial balance as of the cutover cut date.** Per-account debit and credit totals for the closing of the period before cutover. This becomes the opening-balance journal entry in Phase 3.*If skipped: An unsigned or untimed trial balance produces an opening journal that finance cannot trace back to a source document.*
- **Export open AR invoices with line detail.** Include invoice number, date, due date, partner, currency, lines with account, tax, and amount, plus current residual. Closed invoices stay in the legacy system unless the historical window says otherwise.
- **Export open AP bills with line detail.** Same shape as AR. These become posted account.move records of type 'in\_invoice' in Odoo.
- **Export posted journal entries inside the historical window.** If the historical-data window in Phase 0 includes posted prior-year journals, export them as account.move plus account.move.line rows. Include journal code, date, partner\_id, account code per line, debit, credit, currency.
- **Export products with template, variant, BOM, and routing data.** Separate files for product.template, product.product (variants), product.attribute, mrp.bom, mrp.bom.line, and mrp.routing. Capture cost, list\_price, uom\_id, uom\_po\_id, and the responsible employee.
- **Export stock-on-hand per location, lot, and serial.** This becomes the stock.quant opening file. Each row needs product, location, quantity, lot/serial number (if tracked), reserved quantity, and valuation cost.*If skipped: Missing the lot/serial column on a serial-tracked product forces individual quant rows to be split manually post-load.*
- **Export bills of materials and BOM lines.** mrp.bom (header: product, qty, type) plus mrp.bom.line (component product, qty, uom). Multi-level BOMs export the full tree, not flattened — Odoo recomputes the flatten on demand.
- **Export multi-currency historical exchange rates.** Capture dated rate rows per currency for every date that has a transaction in scope. Without these, foreign-currency journal entries cannot post.*If skipped: Skipping historical rate export forces a fallback to today's rate and misstates every multi-currency open balance.*
- **Export pricelists, payment terms, and tax codes used by source documents.** product.pricelist + product.pricelist.item, account.payment.term + account.payment.term.line, account.tax. These are referenced by transactional records and must exist before load.
- **Export attachments as binaries plus a metadata manifest.** Download every bill, invoice, contract, and product spec sheet. Produce a manifest CSV with source attachment ID, original filename, MIME type, file size, related model, related record ID.*If skipped: Files without a manifest cannot be re-linked to their parent records and become orphaned uploads.*
- **Export the source user list with roles and reporting structure.** User → email mapping drives the salesperson lookup, the responsible-purchaser lookup, and the ownership assignment.
- **Capture screenshots and config exports of source automations and reports.** Source workflows, dashboards, and reports do not transfer. Document them so they can be rebuilt manually post-cutover.
- **Record the exact timestamp of every export.** The delta between export time and cutover time becomes the change set you must re-pull at cutover. Date-stamp every file in its filename.*If skipped: Without an export timestamp you cannot compute the delta and risk losing every change made between export and cutover.*
- **Hash each exported file and store the hash alongside the export.** SHA-256 of each CSV and binary. The hash proves you imported the exact bytes you exported during validation.

3\. Transform & Map 30 tasks

- **Build a master field-mapping spreadsheet keyed on Odoo model.** One sheet per Odoo model (res.partner, account.account, account.move, account.move.line, product.template, product.product, uom.uom, stock.location, stock.quant, mrp.bom, mrp.bom.line, res.currency.rate). For each row capture source field, destination field (Odoo's technical name, not the label), transform rule, required flag, default-when-null.*If skipped: A mapping kept in heads or chat threads cannot be audited and produces inconsistent transforms across re-runs.*
- **Pick the upsert/external-ID key per model.** External ID convention: '\_\_export\_\_.\<source\_system>\_\<record\_id>' (e.g. '\_\_export\_\_.netsuite\_12345'). Add an 'id' column to every CSV — Odoo's load() ORM method and base\_import.import use it to upsert.*If skipped: Without external IDs, re-running the importer creates duplicate records instead of updating the existing ones.*
- **Decide handling for source fields with no Odoo equivalent.** Per field decide: drop, concatenate into the chatter as an initial mail.message, or create a custom field via Studio (Enterprise) or developer mode (Community).
- **Decide handling for users present on the source but not in Odoo.** Map orphaned ownership to a single 'migration\_bot' res.users, to the user's manager, or leave user\_id blank. Document the rule and apply uniformly.
- **Convert dates and datetimes to ISO-8601 in the company timezone.** Odoo's import wizard parses ISO-8601 reliably; ambiguous DD/MM vs MM/DD is guessed and frequently wrong. Force every date to YYYY-MM-DD and every datetime to YYYY-MM-DD HH:MM:SS.*If skipped: Day-month inversion on dates misstates posting periods and shifts entire quarters of revenue.*
- **Normalize currency amounts to plain decimals with a period separator.** Strip thousand separators and currency symbols. Odoo's Float field accepts '1234.56' not '1,234.56 €'. Capture currency code in a separate currency\_id column.
- **Re-encode every text field as UTF-8 without BOM.** base\_import.import expects UTF-8. Latin-1 or Windows-1252 inputs corrupt accented characters in vendor names, addresses, and product descriptions.*If skipped: Encoding mismatches surface as mojibake on partner names that have to be reimported per row.*
- **Escape commas, quotes, and newlines in CSV text fields.** Wrap any field containing a comma, quote, or newline in double quotes and escape embedded quotes by doubling them. Verify by opening the CSV in a strict parser, not Excel.*If skipped: Unescaped newlines in invoice memo bodies split one row into two and shift every subsequent column.*
- **Convert booleans to True/False and use explicit blanks for nullable Many2one fields.** Odoo's CSV importer accepts True/False, 1/0, and explicit selection values — pick one form and apply uniformly. For nullable Many2one relations use the literal empty cell, not a quoted empty string, since Odoo treats them differently.
- **Truncate source text fields that exceed Odoo column lengths.** Most Char fields are sized; product internal reference, partner street, and journal code have practical limits. Truncate and flag with a sidecar column if content was lost.
- **Resolve Many2one references using external IDs, not raw IDs.** For every Many2one column (partner\_id, account\_id, journal\_id, currency\_id, product\_id, location\_id, etc.) populate the '\<field>/id' column with the target's external ID. This survives database rebuilds; raw IDs do not.*If skipped: Loading raw integer IDs into Many2one columns ties imports to a specific database instance and breaks if you ever rebuild.*
- **Resolve Many2many references using comma-separated external IDs.** For tag\_ids and similar Many2many fields, populate '\<field>/id' with comma-separated external IDs. Pre-create every referenced tag in Phase 1b.
- **Decide the historical-timestamp strategy for create\_date.** Odoo lets you set create\_date on import only via the ORM with elevated permissions and the Track history during import flag. Decide: preserve the original on the source-system field, or write to a custom field 'x\_legacy\_created\_date' and let Odoo stamp the migration date as create\_date.*If skipped: Failing to preserve historical timestamps makes age-based AR aging reports wrong for the first reporting period post-cutover.*
- **Decide the record-ownership strategy.** Map source owner email → res.users login. For unknown owners pick a single fallback: the migration\_bot user, the department manager, or blank. Apply uniformly and document.
- **Decide the file-attachment strategy.** Choose: re-upload binaries into ir.attachment (preserves offline access, hits the per-file cap and storage cost), or keep files in external storage and create ir.attachment rows with type='url' pointing to them.
- **Decide load order to satisfy foreign-key constraints.** Required order: res.users → res.company → res.currency → res.currency.rate → uom.category → uom.uom → account.account → account.journal → account.tax → account.payment.term → res.partner (parents first) → product.category → product.template → product.product → stock.warehouse → stock.location → stock.lot → stock.quant → mrp.bom → mrp.bom.line → account.move (opening journal) → account.move (open AR/AP) → ir.attachment.*If skipped: Violating load order causes ondelete='restrict' foreign-key errors and leaves every dependent record with a null reference.*
- **Map the source chart of accounts to account.account per localization.** For each source account map account code, name, account.account.type (e.g. asset\_current, liability\_current, equity, income, expense), reconcile flag, currency\_id (only for foreign-currency accounts). Internal account codes drive sorting and reporting — keep source codes only where they make sense in the destination chart.*If skipped: An off-by-one in account.account.type misclassifies expenses as assets and corrupts every report rolled up from account type.*
- **Prepare the opening-balance account.move as a balanced journal entry.** One account.move with state='draft' containing one account.move.line per chart-of-accounts row carrying a balance, with debit and credit columns populated. Sum of debits must equal sum of credits to the cent before posting. Exclude any current-year YTD net income line that Odoo derives from period close.*If skipped: Posting an unbalanced opening journal throws ValidationError and blocks every subsequent posted document.*
- **Build the stock.location and stock.quant opening file.** stock.quant rows seed opening on-hand per (product\_id, location\_id, lot\_id) tuple. Include quantity, reserved\_quantity (typically 0 at cutover), and inventory\_quantity for adjustment. Use the inventory adjustment journal pattern, not direct UPDATE on stock.quant.*If skipped: Direct writes to stock.quant without the inventory adjustment journal break Odoo's stock valuation reconciliation.*
- **Build mrp.bom and mrp.bom.line files with multi-level structure preserved.** mrp.bom holds the header (product\_tmpl\_id, product\_qty, type, code). mrp.bom.line holds each component (product\_id, product\_qty, product\_uom\_id, bom\_id). Phantom (kit) BOMs use type='phantom'; manufacturing BOMs use type='normal'. Do not flatten multi-level BOMs at transform — Odoo explodes them on demand.*If skipped: Flattening a multi-level BOM at transform breaks the master production schedule's component requirement calculations.*
- **Build the res.currency.rate dated-rows file.** One res.currency.rate row per (currency\_id, name=date, rate) tuple covering every historical date that has a transaction in that currency. Odoo treats the rate as effective from that date forward until the next dated rate.*If skipped: Gaps in dated rates cause Odoo to fall back to 1.0 and value foreign-currency invoices at parity, producing nonsensical residuals.*
- **Set fiscal year lock dates to seal closed periods.** Accounting → Settings → Lock Dates → Journal Entries Lock Date and Tax Lock Date. Set both to the day before the opening journal date so no one can backdate entries into closed periods. Also set the All Users Lock Date for the prior closed year.*If skipped: Without lock dates, a user can post a journal into a closed prior year and silently corrupt the opening balance.*
- **Build open AR invoice files as account.move with state='posted'.** Each row is one account.move with move\_type='out\_invoice', partner\_id, invoice\_date, invoice\_date\_due, currency\_id, plus account.move.line rows for each invoice line (account\_id, quantity, price\_unit, tax\_ids, product\_id where applicable). Residual at cutover equals invoice total minus any pre-cutover payments — typically open invoices migrate at full residual since payments before cutover stay in the source.*If skipped: Posting open AR with the wrong receivable account routes payments to the wrong GL and breaks AR aging.*
- **Build open AP bill files as account.move with state='posted', move\_type='in\_invoice'.** Same shape as AR but with the payable account on each move line. Include vendor bill reference (ref field) so the source bill number survives.
- **Resolve Selection field internal keys versus display labels.** Odoo Selection fields (account.account.type, move\_type, state) store the internal key but display the label. The importer accepts either, but mixing them within one column fails non-deterministically. Always export and import the internal key.*If skipped: Importing the human-readable label when the field's internal key differs causes the row to fail silently and leaves a null value.*
- **Map uom.uom conversion ratios within uom.category.** Each uom.uom belongs to one uom.category and has factor (smaller→reference) or factor\_inv (reference→larger). Verify that 'Box of 12' has the right factor against the reference 'Unit'. Cross-category conversion is not supported.*If skipped: Wrong uom factor multiplies or divides every stock movement quantity for that product by an order of magnitude.*
- **Map product.template versus product.product split.** product.template holds the abstract product (name, list\_price, type, category, taxes). product.product holds the variant (template\_id, attribute\_value\_ids, internal\_reference). A product with no variants still has one product.product row per template — load both.*If skipped: Loading only product.template leaves the catalog technically present but unusable because stock and BOM lines reference product.product.*
- **Map account.payment and reconciliation strategy for open invoices.** Decide whether partial payments before cutover collapse into the residual on the open invoice (simpler, recommended) or migrate as separate account.payment records reconciled against the invoice (preserves payment history but doubles complexity).
- **Resolve multi-company partitioning on every transactional model.** Set company\_id explicitly on every model that has it (account.move, product.template, stock.quant, mrp.bom). Leaving it blank assigns to the importing user's default company.*If skipped: Misallocated company\_id values make records invisible to users in the correct company and trigger record-rule access errors.*
- **Decide handling for stock.lot and serial numbers.** If products use lot or serial tracking (product.tracking='lot' or 'serial'), every stock.quant row must reference a stock.lot. Pre-create stock.lot records before stock.quant load.*If skipped: Missing stock.lot records on tracked products cause every stock.quant for that product to fail and leave on-hand at zero.*

4\. Sandbox Test Migration 16 tasks

- **Refresh the sandbox database from the latest production config.** Use 'Duplicate Database' or rebuild the Odoo.sh staging branch from production. Confirm modules, users, l10n\_\*, account.journal, and stock.warehouse records match.
- **Load a representative 1–5% sample of each model into the sandbox.** Use Settings → Apps → Import or the list view → Favorites → Import records. Upload the sample CSV and verify the matching screen recognizes every column.*If skipped: Loading the full file first burns hours debugging issues a 1% sample would have caught in minutes.*
- **Test the opening-balance journal entry in sandbox.** Post the full opening account.move, then run the trial balance report. Debits and credits must equal and tie to the source trial balance to the cent.*If skipped: An out-of-balance opening journal blocks every subsequent posted invoice from reconciling cleanly.*
- **Test stock.quant load and verify Inventory → Reporting → Stock Valuation.** Run the opening stock load, then check stock-by-location reports against the source. Confirm fractional quantities (e.g. 1.36 kg) survive the dot-decimal transform.*If skipped: Stock valuation that does not tie post-load forces every product category's costing method to be re-validated.*
- **Test BOM explosion against a known finished good.** Pick a multi-level BOM. Open Manufacturing → Products → BOM Structure. Expand the tree and compare component quantities to the source BOM.*If skipped: A flattened or partial BOM produces incorrect material requirements for every future manufacturing order.*
- **Test multi-currency posting against the dated rate.** Post a foreign-currency invoice with an invoice\_date matching a seeded res.currency.rate row. Confirm Odoo computes the amount\_company\_signed using the dated rate, not today's rate.*If skipped: Wrong rate selection misstates every foreign-currency residual and breaks AR reconciliation.*
- **Test field-by-field on 10 random sandbox records per model.** Open each in the form view and compare every field to the source. Pay extra attention to Selection fields, dates, Many2one references, and tax\_ids on invoice lines.*If skipped: Bulk count matches can mask field-level corruption that only field-by-field comparison surfaces.*
- **Test long-string, special-character, and emoji cases explicitly.** Include in the sample at least one record per model with a 4000-character body, embedded commas and quotes, an accented character in a partner name, and a CJK product description.
- **Test NULL handling for every nullable field.** Include sample rows where every nullable field is blank. Confirm Odoo accepts the blank without substituting a default or zero.
- **Test parent-child relationships (res.partner.parent\_id, product.product.product\_tmpl\_id).** Load companies first, then contacts. Open a contact and confirm the Company field is populated and clicking through opens the company record. Same for product variants under a template.
- **Test attachment download from imported ir.attachment records.** Open a sample of invoices and products with attachments. Click each file and confirm it downloads with correct content and filename.
- **Run a full-volume test if sandbox capacity permits.** If the sandbox can hold the full volume, run the entire import end-to-end. Time each model's load step and extrapolate to the production cutover budget.*If skipped: Skipping a full-volume rehearsal means cutover-day surprises around throttling, timeout behavior, and storage caps.*
- **Measure load throughput against the hosting tier.** Odoo Online throttles aggressively per session. Plan batch sizes (50–200 records per load() call) accordingly and add exponential backoff on throttle responses. Standard performance ceiling is 2–3 sales orders per second per worker.*If skipped: Aggressive parallel writes against Odoo Online trip throttling and stall the load mid-batch.*
- **Have a finance domain expert spot-check 25 sandbox journal entries.** Pick records they recognize. Ask them to flag anything that 'looks wrong' in account assignment, tax treatment, or currency. Their tacit knowledge surfaces issues no checklist catches.
- **Re-run the import idempotently to confirm upsert behavior.** Run the same file again. Row counts should remain identical, not double. If counts double, the external-ID column is missing or wrong.*If skipped: Non-idempotent imports compound every retry into duplicate journals and force a destructive cleanup.*
- **Capture sandbox sign-off in writing before proceeding to Phase 5.** Migration sponsor, finance approver, and IT confirm the sandbox passes. Without this gate the production cutover cannot start.

5\. Production Cutover 17 tasks

- **Confirm freeze on the source system.** Verify with the source system audit log that no writes have occurred in the last 60 minutes. Lock down user permissions on the source if possible.*If skipped: Late source writes that arrive after the final export become silent data loss.*
- **Take the final delta export from the source.** Re-export every in-scope object, capturing only records modified since the Phase 2 baseline timestamp. Re-pull the trial balance as of the freeze instant.
- **Disable Odoo automated actions and outgoing mail during the load.** Settings → Technical → Automation → Automated Actions: pause every rule on the models being loaded. Disable the outgoing mail server temporarily to avoid notification storms.*If skipped: Active automations during bulk load fire thousands of redundant notifications and corrupt computed-field state.*
- **Take a pre-load backup of the destination database.** Database manager → backup, or on Odoo.sh use the auto-snapshot before deploy. Confirm the backup downloads and is restorable to a scratch database.
- **Load res.users first.** Upsert users by login email. Confirm row counts match the user export.
- **Load configuration records: res.currency.rate, uom.uom, account.account, account.journal, account.tax, account.payment.term.** These should already exist from Phase 1b; this step idempotently confirms and adds any new rate rows captured in the delta. Verify journal codes and tax rates against the source one more time before any account.move loads.
- **Load res.partner companies first, then contacts.** Companies (is\_company=True) before contacts (is\_company=False with parent\_id). Confirm post-load counts before continuing.
- **Load product.category, product.template, product.product, then stock.warehouse, stock.location, stock.lot.** Templates before variants; warehouse and location tree before stock.quant. Pre-create every lot/serial number a tracked product will reference. Use external-ID upsert mode and capture import job IDs.
- **Load mrp.bom and mrp.bom.line.** BOM headers before BOM lines. Multi-level BOMs load in topological order: leaf components first, then assemblies that reference them.*If skipped: Loading mrp.bom.line before its parent mrp.bom triggers ondelete='cascade' foreign-key violations and discards the line.*
- **Post the opening-balance journal entry.** Load the opening account.move as draft, run the trial-balance sanity check inside Odoo, then post the entry (write state='posted' or call action\_post). Lock the fiscal year for the prior period immediately after posting.*If skipped: Posting the opening journal before BOMs and products exist leaves the GL balanced but disconnected from inventory valuation, producing reconciliation drift.*
- **Load stock.quant opening on-hand via the inventory adjustment journal.** Create one stock.inventory record (or stock.quant inventory\_quantity field in 18+) per location-product, then apply to seed on-hand. Do not write directly to stock.quant in production.*If skipped: Direct writes break Odoo's stock valuation accounting entries and cause the inventory account to drift from physical on-hand.*
- **Load open AR invoices and AP bills as posted account.move records.** AR uses move\_type='out\_invoice' with state='posted' and the receivable account on each line. AP uses move\_type='in\_invoice' with the payable account. Verify partner\_id, account\_id, and invoice\_date match. Cross-check residual sum against open-AR and open-AP aging from the source.
- **Load posted prior-year journal entries if in scope.** If the historical-data window includes posted prior-year journals, load them after the opening journal and against the locked prior fiscal year. Unlock the lock date temporarily for this load, then re-lock.*If skipped: Loading prior-year journals without re-locking afterward leaves the prior period writable and exposes the opening balance to drift.*
- **Load ir.attachment binaries last.** Stream binaries via create() with base64-encoded datas, res\_model, and res\_id. Throttle to the hosting tier's throughput ceiling. Confirm one sampled file downloads correctly mid-load.*If skipped: Pushing attachments above the per-file cap or beyond the hosting throughput ceiling causes silent failures that orphan the parent record.*
- **Cross-check destination row counts and totals against source at each step.** After every model, run search\_count and compare to the export's row count. After the opening journal, run the trial-balance report and tie to source. Investigate any delta before proceeding.*If skipped: Cascading row-count and total drift across models compounds and becomes unprovable later.*
- **On any partial-load failure, stop, diagnose, and re-run idempotently.** Do not push through with partial data. The external-ID upsert key makes safe re-runs possible — use it.
- **Re-enable automated actions and outgoing mail after all loads complete.** Restore automation rules and the outgoing mail server. Run one end-to-end test (create vendor bill, post, register payment) to confirm automations fire as expected.

6\. Validate 20 tasks

- **Reconcile the post-load trial balance to the source trial balance.** Accounting → Reporting → Trial Balance for the period ending on the cutover date. Every account balance must tie to the source frozen trial balance to the cent. Investigate any delta of more than rounding.*If skipped: Trial balance that does not tie is a hard fail — finance cannot sign off, and the migration is not complete.*
- **Compare total record count per model between source and Odoo.** Pull search\_count from Odoo for res.partner, account.account, account.move, product.template, product.product, stock.quant, mrp.bom, ir.attachment. Compare each to the export row count.*If skipped: Skipping count reconciliation lets multi-thousand-row drops go unnoticed until users complain.*
- **Reconcile open AR and AP aging source vs Odoo.** Accounting → Reporting → Partner Ledger → Receivable and Payable. Compare aging buckets (0–30, 31–60, 61–90, 90+) per partner to the source AR/AP aging.*If skipped: AR/AP aging mismatch is the single most-noticed cutover defect by finance and collections.*
- **Reconcile stock-on-hand per location to the source.** Inventory → Reporting → Stock Valuation and Inventory → Reporting → Stock at Date. Sum stock.quant by product and location, compare to source. Tolerate only fractional-rounding drift on weight/volume UoMs.*If skipped: Stock-on-hand mismatch breaks every future picking, MRP run, and inventory-valuation period close.*
- **Cross-check 30–50 randomly sampled documents field-by-field.** Random sample across account.move (invoices and bills), product.template, stock.quant, and mrp.bom. Compare every field including custom fields between source and Odoo.
- **Verify every custom field value migrated on a 25-record sample.** Custom fields are the most common silent-drop category. Confirm Selection internal keys map to the right labels in the UI.
- **Verify parent-child relationships on a 25-contact sample.** Confirm each sampled contact's parent\_id points to the right company, and clicking through opens that company.
- **Verify product variant linkage on a 25-product sample.** Open a sampled product.product, confirm product\_tmpl\_id points to the right template, and attribute\_value\_ids match the source variant definition.
- **Verify BOM linkage and explosion on a 10-BOM sample.** Open Manufacturing → Products → BOM Structure for each sampled finished good. Expand the multi-level tree and verify component quantities match the source BOM.*If skipped: Broken BOM linkage produces wrong material requirements on the first manufacturing order and ripples through every PO suggestion.*
- **Verify attachment-to-record linkage on a 25-file sample.** Open a sampled invoice or product, click each attachment, confirm the file downloads with the right content and is the right size.
- **Verify multi-currency exchange rate selection on a sample of foreign invoices.** Open a sampled foreign-currency account.move. Confirm amount\_company\_signed equals amount\_total × dated rate from res.currency.rate, not today's rate.
- **Confirm the historical-timestamp strategy worked.** If you preserved create\_date during import, confirm a sample shows the legacy timestamp. If you used a custom field, confirm that field is populated.
- **Confirm fiscal year lock dates are set as planned.** Accounting → Settings → Lock Dates. Verify Journal Entries Lock Date, Tax Lock Date, and All Users Lock Date are set to the agreed period boundaries.*If skipped: Forgotten lock dates leave closed periods writable and let a user backdate entries that corrupt the opening balance.*
- **Run a GDPR / data-residency spot-check.** Confirm the Odoo.sh region (or Odoo Online region, or on-prem host country) matches the documented residency requirement from Phase 0. Capture the region as evidence in the migration record.
- **Confirm record-rule access works for each role.** Log in as an Accounting / User, an Inventory / User, and a Sales / User and confirm each sees only the records permitted by their access group and the multi-company record rule.
- **Run a SOX/SOC2 evidence capture if required.** Export the audit log of every user action during the load window. File alongside the sign-off as evidence of who did what.
- **Have 3–5 power users run their daily workflow against migrated data.** Accountants reconcile a bank statement against migrated AP. Inventory clerks process a transfer between locations. Manufacturing schedules a work order from a migrated BOM. Sales create a quotation against a migrated product and customer.*If skipped: Without UAT, the first day post-cutover surfaces issues that should have been caught before users got the keys.*
- **Document every UAT issue and triage to fix-before-go-live or fix-after.** Decide which issues block go-live and which can ship after. Capture in a tracked list with named owners and target dates.
- **Re-validate the issues fixed before go-live.** Do not take 'we fixed it' on trust. Have the original UAT user re-test each must-fix issue.
- **Capture written sign-off from the finance approver and migration sponsor.** Sign-off names the date, the validated trial-balance reconciliation, the open-AR and open-AP totals, the stock-on-hand totals, and the known-issue list ship-ready for Phase 7. File it with the migration record.*If skipped: Verbal sign-off creates downstream disputes about what 'done' meant when finance has to defend the cutover at year-end audit.*

7\. Post-Migration Cleanup 13 tasks

- **Send go-live communication to all end users.** Include Odoo login URL, password-reset instructions, the first-responder contact for issues, and a one-page 'how the new modules map to the old workflow' cheat sheet.
- **Run role-segmented training sessions.** Accounting (journals, reconciliation, period close), Inventory (transfers, scrap, valuation), Manufacturing (work orders, MPS), Sales/Purchase (quotations, vendor bills), admins (Settings, Studio if Enterprise, user provisioning). Record each session.
- **Set the source system to read-only.** Strip write permissions for all users. Communicate the read-only date in writing. Keep read access during the post-migration safety window.
- **Rebuild reports and dashboards inside Odoo.** Source reports do not transfer. Use Odoo's pivot, graph, and list views with saved Favorites. Enterprise users can also build dashboards via the Spreadsheet app.*If skipped: Finance leadership without their reports stops trusting the migrated data even when it is correct.*
- **Rebuild source automations as Odoo automated actions.** Settings → Technical → Automation → Automated Actions for trigger-based rules. Settings → Technical → Server Actions for code-based logic. Test each rule before enabling.
- **Schedule scheduled actions for the recurring jobs.** Settings → Technical → Scheduled Actions for cron jobs (invoice reminders, stock reordering, currency rate refresh from a service). Confirm each runs on the planned cadence.
- **Re-establish integrations to other systems.** Banking feeds, payment gateways, EDI partners, shipping carriers, BI tools. Use a dedicated service-account user for access.
- **Disable the migration\_bot user.** The bulk-load credentials are no longer needed and represent an oversized access surface. Disable the user to lock it out of routine use.*If skipped: Active migration-tier credentials become the path of least resistance for accidental or malicious bulk writes to the GL.*
- **Confirm the period-close workflow for the first cutover-month close.** Walk finance through the first end-of-month close in Odoo: lock dates advance, recurring journals post, bank reconciliation completes, financial reports run. Capture issues for the next month.*If skipped: An untested first period close becomes a fire drill at month-end and undermines confidence in the migration.*
- **Schedule the 30-day post-migration retrospective.** Capture what went well, what did not, what would change. File the notes with the migration record so the next migration starts ahead.
- **Document the source-system decommission date.** Typically 90 days after cutover and at least one full period-close cycle. Capture in the migration record with the named approver. Retain the source database as a read-only archive for the documented audit window (often seven years for financial records).
- **Archive the source-system exports and the migration files to long-term storage.** Encrypted cold storage retains the Phase 2 baseline, Phase 5 delta, mapping spreadsheet, and post-load sign-off for the documented retention window. Capture storage location and access process.
- **Close the migration project formally.** Final status report, lessons-learned document, project closure note. Reassign the DRI back to their regular role.

Questions, answered

## Migrating to Odoo ERP: questions

How long does migration to Odoo ERP take?

A small-business migration with under 5,000 contacts, standard modules and a single company runs four to eight weeks end-to-end including localisation setup and validation. A 200-user multi-company manufacturing migration with Studio rebuilds, multi-currency consolidation and historical inventory loads typically runs three to six months of elapsed time.

Can I migrate from SAP or NetSuite to Odoo ERP?

Yes — SAP-to-Odoo and NetSuite-to-Odoo are common ERP migration shapes. Master data, chart of accounts, products, customers, vendors, open AP/AR and on-hand inventory map cleanly; but SAP ABAP code, NetSuite SuiteScript, workflows and saved searches do not transfer and need to be rebuilt as Odoo Automated Actions, Server Actions and Studio reports.

Can I migrate from QuickBooks or Sage to Odoo ERP?

Yes, and these are usually cleaner shapes because the accounting object model aligns with account.account, account.move and res.partner one-to-one. Watch chart-of-accounts numbering against the country localisation, populate res.currency.rate for every historical foreign-currency date, and import open AP/AR as individual invoices, not as a single opening journal line.

Does Odoo ERP preserve original timestamps on import?

No. create\_date, write\_date, create\_uid and write\_uid are ORM-managed and stamp to upload time, not the source record's date. To preserve audit history, add custom legacy\_create\_date and legacy\_write\_date Datetime fields to each imported model, populate from the source export, and point all historical reports at the legacy fields.

What's the difference between the UI wizard and a scripted ORM load for Odoo ERP?

The base\_import UI wizard accepts CSV and XLSX, auto-maps columns, and is best for one-shot loads under 100,000 records with a visual Test pass before commit. Scripted ORM loads via load() handle larger volumes, custom models and repeatable loads but respect tighter throughput throttling on Odoo Online.

How do I handle opening balances and open AP/AR invoices in Odoo?

Post opening balances as a single Miscellaneous journal entry on account.move dated the day before go-live, with debits equal to credits. Import each open customer invoice and vendor bill individually as account.move with move\_type='out\_invoice' or 'in\_invoice' so future receipts and payments can match by document and aging reports work correctly.

What happens to inventory, BOMs and lot/serial tracking during migration?

Inventory loads as a physical inventory adjustment that posts as a stock.move into each internal location, with lots or serial numbers attached for tracked products. BOMs import as mrp.bom headers plus mrp.bom.line components bottom-up. Decide tracking per product before the first stock.move posts — Odoo blocks the change once movements exist.

Is there an undo or rollback for Odoo imports?

There is no native bulk-undo — Odoo's documentation states imports are permanent. The OCA Audit Log module captures old/new values per change when configured in advance; Odoo.sh staging branches let you fork and restore. The standard fallback is a full PostgreSQL backup plus an import\_batch\_id stamp on every row.

### [Odoo implementation](https://flitstack.ai/services/odoo-implementation)

[Set up Odoo ERP (pipelines, properties, automation, permissions) and migrate into it as one engagement.](https://flitstack.ai/services/odoo-implementation)

[See the service →](https://flitstack.ai/services/odoo-implementation)

### [All erp migrations](https://flitstack.ai/migrations/erp)

[Every destination we migrate financial, supply chain, and operational data into.](https://flitstack.ai/migrations/erp)

[Back to ERP →](https://flitstack.ai/migrations/erp)

## Sources

1. [Odoo — Wikipedia](https://en.wikipedia.org/wiki/Odoo)
2. [Is Odoo the right ERP for my company? — r/Odoo (50M USD / 400 user evaluation)](https://www.reddit.com/r/Odoo/comments/1t7mlpv/is_odoo_the_right_erp_for_my_company_looking_for/)
3. [SAP wants a 20% price increase — r/NoStupidQuestions (vendor-cost exit)](https://www.reddit.com/r/NoStupidQuestions/comments/1t8weih/sap_wants_a_20_price_increase_when_im_only_using/)
4. [Replacing our legacy ERP with Odoo Enterprise — r/Odoo (brick-and-mortar SME)](https://www.reddit.com/r/Odoo/comments/1ru3uea/replacing_our_legacy_erp_with_odoo_enterprise/)
5. [JTL-Wawi to Odoo migration war story — r/Odoo](https://www.reddit.com/r/Odoo/comments/1sx1gn0/odoo_war_nicht_das_problem_unsere_infrastruktur/)
6. [Migrating from Odoo.sh (Enterprise) to Self hosted (Community) — r/Odoo](https://www.reddit.com/r/Odoo/comments/1pzdnpo/migrating_from_odoosh_enterprise_to_self_hosted/)
7. [Export and import data — Odoo 19.0 documentation](https://www.odoo.com/documentation/19.0/applications/essentials/export_import_data.html)
8. [Odoo's annual major releases — r/Odoo (yearly breaking version cadence)](https://www.reddit.com/r/Odoo/comments/1tg5yug/odoos_annual_major_releases_genuine_product/)
9. [ORM reference — Odoo 19.0 documentation](https://www.odoo.com/documentation/19.0/developer/reference/backend/orm.html)
10. [Get started — Odoo 19.0 Accounting documentation (Chart of Accounts setup)](https://www.odoo.com/documentation/19.0/applications/finance/accounting/get_started.html)
11. [Managing Parent-Child Relationships Between Partners in Odoo — Odoo Forum](https://www.odoo.com/forum/help-1/managing-parent-child-relationships-between-partners-in-odoo-237999)
12. [Export and import data — Odoo 14.0 documentation (Country/Database ID/External ID resolution)](https://www.odoo.com/documentation/14.0/applications/general/export_import_data.html)
13. [Definitive foolproof steps for a successful import — Odoo Forum (Many2many comma-separated)](https://www.odoo.com/forum/help-1/is-there-a-definitive-foolproof-steps-for-a-successful-import-doc-39822)
14. [Upload size limit in Odoo — Odoo Forum (64 MiB Odoo.sh, 128 MiB self-hosted)](https://www.odoo.com/forum/help-1/upload-size-limit-in-odoo-221095)
15. [Fields and widgets — Odoo 19.0 documentation (Studio)](https://www.odoo.com/documentation/19.0/applications/studio/fields.html)
16. [what is ondelete='cascade' in OpenERP — Odoo Forum](https://www.odoo.com/forum/help-1/what-is-ondeletecascade-in-openerp-73895)
17. [Batch Import — Odoo Forum (Odoo Online throttling)](https://www.odoo.com/forum/help-1/batch-import-262164)
18. [Chart of Accounts and localisation — Odoo 19.0 Accounting documentation](https://www.odoo.com/documentation/19.0/applications/finance/accounting/get_started.html)
19. [What Does Odoo Migration Really Cost? Transparent Pricing Breakdown — Aspire Softserv](https://dev.to/aspire-softserv/what-does-odoo-migration-really-cost-a-transparent-pricing-breakdown-for-2025-48fj)
20. [How to bulk insert record in Odoo — Odoo Forum (Model.create with list)](https://www.odoo.com/forum/help-1/how-to-bulk-insert-record-in-odoo-137694)
21. [Error when importing Journal Entry — r/Odoo (unbalanced debits/credits)](https://www.reddit.com/r/Odoo/comments/17tirzp/error_when_importing_journal_entry/)
22. [Units of measure — Odoo 19.0 Inventory documentation](https://www.odoo.com/documentation/19.0/applications/inventory_and_mrp/inventory/product_management/configure/uom.html)
23. [Units of measure and BOM in Odoo version 18.2 — Odoo Forum (tracking change blocked)](https://www.odoo.com/forum/help-1/units-of-measure-in-odoo-version-18-2-275798)
24. [Manufacturing > Bill of Materials in Odoo — Odoo Forum (BOM structure)](https://www.odoo.com/forum/help-1/units-of-measure-in-odoo-version-18-2-275798)
25. [Record exchange rates at payments — Odoo Accounting multi-currency documentation](https://www.odoo.com/documentation/14.0/applications/finance/accounting/others/multicurrencies/exchange.html)
26. [Image file types supported in Odoo — Odoo Forum](https://www.odoo.com/forum/help-1/is-image-file-types-supported-in-odoo-if-yes-which-are-225605)
27. [Base Attachment Object Store (fs\_attachment) — Odoo Apps Store](https://apps.odoo.com/apps/modules/16.0/fs_attachment)
28. [Import file and retain file date — Odoo Forum (create\_date is upload time)](https://www.odoo.com/forum/help-1/import-file-and-retain-file-date-286676)
29. [OCA Audit Log — The Odoo Community Association](https://apps.odoo-community.org/shop/audit-log-533)
30. [Cannot import date field — Odoo Forum](https://www.odoo.com/forum/help-1/cannot-import-date-field-163065)
31. [Error when importing sample data — Odoo Forum (ondelete restrict)](https://www.odoo.com/forum/help-1/error-when-importing-sample-data-286075)
32. [Resellers and Implementation Partners — Odoo](https://www.odoo.com/partners)

Get a quote

## Moving to Odoo ERP?

Tell us where your data lives today and roughly how much there is. We scope the migration and the Odoo ERP setup with you, then send a quote.

[Get a quote](https://flitstack.ai/contact)
