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 $349.00 USD; request a quote for a scoped proposal.
App manifest
Built around your workflow
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.
No DIY setup — a working app, built, installed and supported by ECOSIRE.
Start with a one-time build price. We scope it with you at kickoff.
ECOSIRE builds, configures and installs it on your Odoo.
You go live in about 2–4 weeks, with a post-launch support window.
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 2-4 weeks 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 $349 (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.
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.
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.
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.
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.
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Multi-level view inside the MO/BOM | Interactive collapsible tree embedded directly in `mrp.production` and `mrp.bom` | Possible, but you design and build the recursion and OWL view from scratch | Often a separate menu or a static explosion, not embedded in the live order | |
| Phantom/kit expansion | Kits expanded to their true consumption level inside the tree | Only if you explicitly implement `explode()` handling | Varies; many flatten or ignore phantom nesting | |
| Per-node context (stock, cost, lead time) | Configurable live fields — on-hand, forecast, rolled-up cost, ECO flags | Whatever you build and maintain yourself | Fixed field set decided by the vendor, rarely tailored | |
| Fit to your process | Scoped to your exact fields, security and versions | Fully bespoke, but the full cost and risk sit with you | Generic; you adapt your process to the module | |
| Security & multi-company | `ir.model.access.csv` + record rules matched to your org | You author and test all access rules | Baseline rules; multi-company handling inconsistent | |
| External API access | Documented XML-RPC/JSON-RPC read method for MES/PLM | You expose and document your own endpoint | Usually none specific to the exploded structure | |
| Support & ownership | Support window, training, git repo and source handover | Depends entirely on your in-house or contractor team | Vendor ticket queue; source often obfuscated or locked | |
| Upgrade safety | Inheritance-only addon, tested on staging per version | Only as upgrade-safe as your team makes it | Depends on vendor's release cadence for your version |
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.
Typical delivery is 2-4 weeks 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.
Pricing starts from $349 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.
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.
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.
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.
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.
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.