Skip to main content
Manufacturing BOM Structure — A build-to-order Odoo module that renders the complete multi-level BOM hierarchy — sub-assembli — 1/1Illustrative preview

A build-to-order Odoo module that renders the complete multi-level BOM hierarchy

— sub-assemblies, phantom kits, operations and quantities — directly inside manufacturing orders and bills of materials.

ECOSIRE builds, installs, and supports it for your Odoo 17/18/19 database.

What is Manufacturing BOM Structure?

A build-to-order Odoo module that renders the complete multi-level BOM hierarchy — sub-assemblies, phantom kits, operations and quantities — directly inside manufacturing orders and bills of materials. ECOSIRE builds, installs, and supports it for your Odoo 17/18/19 database. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Recursive multi-level BOM explosion rendered as a collapsible OWL tree embedded in both `mrp.bom` and `mrp.production` views
Server-side traversal built on Odoo's `mrp.bom.explode()` with a `@api.depends`-driven compute layer that stays in sync as BOM lines change
Phantom/kit BOM expansion inline — kit components are shown at their true consumption level, not as an opaque single line
Per-node rolled-up quantities scaled to the parent manufacturing order quantity, so each row shows the real demand
Routing operations from `mrp.routing.workcenter` surfaced against the BOM node that consumes them
Live per-node stock context: on-hand (`qty_available`) and forecasted (`virtual_available`) pulled from `stock.quant`/product fields at render time
Optional rolled-up cost roll (unit cost × exploded qty) aggregated up the tree for a quick standard-cost view
Expand/collapse, level-depth filter, and text search across component names and internal references within the tree
Smart-button on the MO and BOM forms with a badge showing total distinct components and max depth
Multi-company and per-team visibility enforced via `ir.model.access.csv` and record rules, not hardcoded field hiding
Optional printable QWeb report variant of the exploded structure for shop-floor travelers or auditor handover
Exploded structure exposed over XML-RPC/JSON-RPC for external MES/PLM/costing consumers via a documented read method
Clean `__manifest__.py` module with zero core-model patching, so it survives minor and major Odoo upgrades
Built and tested against Odoo 17.0, 18.0 and 19.0, Community or Enterprise, with any Enterprise-only dependency called out before build

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

  1. 1

    You order

    Start with a one-time build price. We scope it with you at kickoff.

  2. 2

    We build & install

    ECOSIRE builds, configures and installs it on your Odoo.

  3. 3

    Go live + support

    You go live in about one working week, with two weeks of go-live support. Defects in the code we deliver are fixed free of charge.

Technical Specifications

Odoo Compatibility
Odoo 17, Odoo 18, Odoo 19
Editions
Enterprise & Community
License
Licence confirmation required
Python Requirement
Python 3.10+
Database
PostgreSQL 12+

About this Product

Anyone who runs discrete or process manufacturing in Odoo knows the pain: a finished good is built from sub-assemblies, which are built from further sub-assemblies, phantom kits and purchased components — but Odoo's native mrp.bom form only shows you one level at a time. To understand what a manufacturing order truly consumes, planners open the BOM, click into a sub-BOM component, click again, and lose the thread. The native "BOM Structure & Cost" report (mrp.report_mrp_bom) does render an indented explosion, but it lives outside the manufacturing order, is print-oriented, and gives you no interactive drill-down, no per-node stock/availability context, and no way to see the exploded tree next to the mrp.production record you are actually working on. When BOMs are 4-6 levels deep with shared sub-assemblies, native Odoo runs out of road for day-to-day shop-floor and engineering use.

Manufacturing BOM Structure is a made-to-order module ECOSIRE designs, builds and installs to close that gap. We add a smart-button and an embedded tree view to both mrp.bom and mrp.production that renders the entire recursive explosion — every level, every phantom/kit expansion, operations from the routing, and rolled-up component quantities scaled to the parent quantity — in a single collapsible OWL component. Technically, we implement a compute layer (@api.depends on bom_line_ids, product_qty, and the recursion of child BOMs) that walks mrp.bom.explode() server-side, materializes each node into a lightweight transient/models.Model structure, and streams it to a client-side OWL tree that supports expand/collapse, search, and level filtering. Each node can surface the fields your team needs — on-hand quantity, forecasted availability, unit and rolled-up cost, supplier lead time, or an ECO/version flag — pulled live so the tree reflects the real database, not a static snapshot.

Because it is your module, we tailor it to how you actually manufacture. We wire the correct security with ir.model.access.csv and record rules so the tree respects multi-company boundaries and per-team visibility; we add QWeb report variants if you need a printable exploded BOM for the shop floor or for customer/auditor handover; and we expose the exploded structure over the standard XML-RPC/JSON-RPC API when an external MES, PLM, or costing tool needs to read it. Everything is delivered in a clean __manifest__.py-declared module with no core patching, so it upgrades cleanly and coexists with your other customizations. We build for Community and Enterprise alike, calling out any Enterprise-only dependency (such as MRP workorder/PLM links) up front so there are no surprises.

Delivery is build-to-order and starts with a short scoping call. Once we agree the exact fields, drill-down behavior, security model and target Odoo version, we develop on a staging copy of your database, run UAT with your team, and deploy to production with a documented rollback plan. Typical delivery is one working week from confirmed scope. This is not an instant download — we hand you installable source, docs, a training session, and a support window at the end. Pricing starts from $999 (indicative, single-company base scope); multi-company visibility rules, deep costing/availability roll-ups, printable QWeb variants, external API/PLM integrations, and larger data-migration volume increase the quoted scope.

What you get

  • Installable, version-pinned source code for your Odoo edition (17.0 / 18.0 / 19.0, Community or Enterprise)
  • Installation and configuration on your staging environment, then production, by an ECOSIRE Odoo engineer
  • Technical documentation: model/field reference, security rules, compute logic, and the XML-RPC/JSON-RPC read method
  • End-user guide plus a live training session for planners and engineering staff on using the tree and filters
  • Post-go-live support window for bug fixes and configuration questions after deployment
  • UAT sign-off on a staging copy of your database with a documented, tested rollback plan
  • Git repository handover with full commit history so your team owns and can extend the module
  • Odoo `.zip`/module package ready for redeployment across your other databases within the agreed scope

Who this is for

Manufacturing Planner / Production Scheduler

Runs `mrp.production` orders daily and needs to see, at a glance, every sub-assembly and component a build consumes across all levels — without clicking through nested BOMs — to spot shortages before releasing an order.

Manufacturing / Industrial Engineer

Owns the bills of materials and routings. Wants an interactive, versioned view of deep BOM structures with phantom expansion and operations, to validate engineering changes and keep 4-6 level product structures maintainable.

Operations / Plant Manager

Needs a printable, auditable exploded BOM for the shop floor and for customer or quality handovers, plus a costing roll-up view to sanity-check standard cost across the full product tree.

Odoo Administrator / Systems Integrator

Maintains the Odoo instance and any MES/PLM integrations. Wants a clean, upgrade-safe module with proper access rules and an API method to read the exploded structure from external systems.

How Manufacturing BOM Structure Compares

CriterionECOSIRECustom BuildCompetitorOdoo Native
Multi-level view inside the MO/BOMInteractive collapsible tree embedded directly in `mrp.production` and `mrp.bom`Possible, but you design and build the recursion and OWL view from scratchOften a separate menu or a static explosion, not embedded in the live orderOne level at a time on the form; the exploded report lives outside the MO
Phantom/kit expansionKits expanded to their true consumption level inside the treeOnly if you explicitly implement `explode()` handlingVaries; many flatten or ignore phantom nestingExplosion report handles it, but not interactively within the MO
Per-node context (stock, cost, lead time)Configurable live fields — on-hand, forecast, rolled-up cost, ECO flagsWhatever you build and maintain yourselfFixed field set decided by the vendor, rarely tailoredCost roll-up in the report only; no interactive availability per node
Fit to your processScoped to your exact fields, security and versionsFully bespoke, but the full cost and risk sit with youGeneric; you adapt your process to the moduleStandard behavior only, no tailoring
Security & multi-company`ir.model.access.csv` + record rules matched to your orgYou author and test all access rulesBaseline rules; multi-company handling inconsistentStandard Odoo access model applies
External API accessDocumented XML-RPC/JSON-RPC read method for MES/PLMYou expose and document your own endpointUsually none specific to the exploded structureGeneric ORM API; no purpose-built explosion method
Support & ownershipSupport window, training, git repo and source handoverDepends entirely on your in-house or contractor teamVendor ticket queue; source often obfuscated or lockedCovered only by your Odoo/partner support contract
Upgrade safetyInheritance-only addon, tested on staging per versionOnly as upgrade-safe as your team makes itDepends on vendor's release cadence for your versionMaintained by Odoo, but lacks the capability you need

Frequently Asked Questions about Manufacturing BOM Structure

Is this an existing app I can download and install right now?

No. Manufacturing BOM Structure is built-to-order. ECOSIRE develops it against your specific Odoo version and requirements, then installs and supports it. You receive installable source code and a git repository at handover — not a self-service marketplace download.

How long does delivery take?

Typical delivery is one working week from confirmed scope. The clock starts once we've completed the scoping call and agreed the exact fields, drill-down behavior, security model and target Odoo version. Deeper costing roll-ups, multi-company rules, or external integrations can extend that timeline, which we confirm in the quote.

How does pricing and scoping work?

Pricing starts from $999 as an indicative single-company base-scope figure. It is not a fixed price. After a short scoping call we send a fixed written quote reflecting your Odoo edition, number of companies, required per-node fields, printable/API needs, and any data-migration volume. You approve the quote before we build.

Which Odoo versions and editions do you support?

We build and test against Odoo 17.0, 18.0 and 19.0, on both Community and Enterprise. Some capabilities (for example links to Enterprise MRP workorder or PLM/ECO features) depend on Enterprise; we identify any such dependency during scoping so there are no surprises after build.

What support and updates are included after go-live?

Every engagement includes a post-go-live support window for bug fixes and configuration questions. Because you own the source and git repo, your team can extend it freely. Version upgrades (for example moving the module to a newer Odoo release) or new features beyond the original scope are handled as a follow-on quote.

Will it break when we upgrade Odoo or interfere with our other customizations?

The module is delivered as a standalone, `__manifest__.py`-declared addon with no patching of Odoo core models — it extends `mrp.bom` and `mrp.production` through inheritance. That keeps it upgrade-safe and lets it coexist with your existing customizations. We test on a staging copy before touching production.

How is data security and multi-company visibility handled?

Access is enforced through `ir.model.access.csv` and record rules so the exploded tree respects Odoo's standard multi-company boundaries and per-team permissions. The tree reads live data using each user's existing rights — it never exposes records a user could not already see.

Request a quote

Manufacturing BOM Structure

A build-to-order Odoo module that renders the complete multi-level BOM hierarchy — sub-assemblies, phantom kits, operations and quantities — directly inside manufacturing orders and bills of materials. ECOSIRE builds, installs, and supports it for your Odoo 17/18/19 database.

  • Recursive multi-level BOM explosion rendered as a collapsible OWL tree embedded in both `mrp.bom` and `mrp.production` views
  • Server-side traversal built on Odoo's `mrp.bom.explode()` with a `@api.depends`-driven compute layer that stays in sync as BOM lines change
  • Phantom/kit BOM expansion inline — kit components are shown at their true consumption level, not as an opaque single line
  • Per-node rolled-up quantities scaled to the parent manufacturing order quantity, so each row shows the real demand

Request a Quotation

Tell us about your Manufacturing BOM Structure requirements and we'll send pricing, licensing options and a tailored proposal — usually within one business day.

No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.