We are an electronics manufacturing company that procures numerous components (e.g., resistors, capacitors, PCBs) from vendors and assembles them into finished products (e.g., circuit boards, electronic devices). We are implementing Odoo to manage our inventory, manufacturing, and procurement processes. We are using We are an electronics manufacturing company that procures numerous components (e.g., resistors, capacitors, PCBs) from vendors and assembles them into finished products (e.g., circuit boards, electronic devices). We are implementing Odoo to manage our inventory, manufacturing, and procurement processes. We are using Odoo
Odoo saas~18.2+e (Enterprise Edition) in a online environment.
Problem Description:
In Odoo, we cannot separate components (raw materials or parts purchased from vendors) from products (finished goods we manufacture and sell) in the Inventory and Manufacturing modules. Odoo requires all items, including components, to be defined as product records in the product.product model. This creates significant operational and usability issues for our workflow, as we do not want components listed as products in our system.
Detailed Issue:
- Current Odoo Behavior:
- To create a Bill of Materials (BoM) in the Manufacturing module, both the finished product and its components must be registered as products in Inventory > Products > Products.
- For example, to manufacture a “Circuit Board” (finished product), we must define components like “Resistor 10kΩ” or “Capacitor 100µF” as products with attributes like Product Type (Storable/Consumable), Unit of Measure, and Category.
- These components appear in the Products list alongside finished products, cluttering the interface and causing confusion for our team, who need to distinguish between raw materials (components) and sellable goods (products).
- Our Requirement:
- We want to manage components (purchased parts) separately from products (finished goods) without listing components as products.
- Components should be tracked in inventory (e.g., stock quantities, vendor purchases) but stored in a distinct entity or model, not the product.product model.
- For example, we’d like a “Components” menu or model to manage parts like “Resistor 10kΩ” independently, while BoMs reference these components for manufacturing “Circuit Boards” (products).
- This separation would streamline our inventory management, procurement, and manufacturing processes by keeping raw materials distinct from sellable products.
- Challenges Encountered:
- Cluttered Product List: With thousands of components (e.g., different resistors, capacitors, screws), the Products list becomes unmanageable, mixing components and finished products. Filtering by Product Category (e.g., “Raw Materials” vs. “Finished Goods”) is insufficient, as all items remain in the same model.
- Error During BoM Creation: When we tried to reference components not defined as products in a BoM, we received errors like “No matching records found for the following name in field Product.” This confirms Odoo’s dependency on product.product for components.
- Import Issues: Importing BoMs or inventory adjustments fails if component names don’t match existing product records, requiring us to create product records for every component, which is time-consuming and counterintuitive.
- Usability for Team: Our procurement and manufacturing teams need a clear distinction between components (purchased, non-sellable) and products (sellable). The current setup risks errors, such as accidentally selling components or misconfiguring BoMs.
- Previous Workarounds Tried:
- Generic Products: We tried creating generic product records (e.g., “Resistor - Generic”) to reduce the number of product entries, but this loses specificity (e.g., “Resistor 10kΩ” vs. “Resistor 20kΩ”) and requires manual tracking outside Odoo.
- Consumable Products: Setting components as Consumable (non-tracked) reduces inventory complexity but prevents accurate stock tracking, which we need for procurement and manufacturing.
- Product Variants: Using variants (e.g., “Resistor” with attributes “10kΩ,” “20kΩ”) still requires components to be products and doesn’t fully separate them from finished goods.
- These workarounds do not meet our need for a distinct component management system.
- Business Impact:
- Inefficiency: Creating and maintaining thousands of product records for components is labor-intensive and prone to errors.
- Confusion: Mixing components and products in the same list confuses our team, risking operational mistakes (e.g., incorrect BoM configurations or procurement orders).
- Scalability: As an electronics manufacturer, we handle a high volume of components with frequent updates (e.g., new part numbers). The current system is not scalable for our needs.
- Adoption Risk: The lack of component separation hinders our ability to fully adopt Odoo, potentially forcing us to seek alternative ERP solutions.
Expected Solution:
We request a solution to manage components separately from products in Odoo, without requiring components to be defined as product records. Possible approaches we’d like Odoo to explore:
- Custom Component Model:
- Introduce a new model (e.g., component.component) to store components with fields like Name, Part Number, Unit of Measure, Stock Quantity, and Vendor.
- Allow BoMs to reference components from this model instead of product.product.
- Provide a dedicated Components menu for managing these items, separate from Products.
- Enhanced BoM Flexibility:
- Modify the Manufacturing module to allow BoMs to reference non-product entities (e.g., a text-based component list or a custom table) for components.
- Enable inventory tracking for these non-product components without cluttering the Products list.
- UI Separation:
- Improve the Inventory module to visually and functionally separate components (raw materials) from products (finished goods) within the product.product model, e.g., through a dedicated “Components” tab or view.
- Standard Workaround:
- If a custom model is not feasible, provide a recommended configuration (e.g., specific Product Types, Categories, or filters) to simulate component separation while minimizing product record creation and ensuring scalability.
Additional Context:
- Workflow: We procure components via the Purchase module, store them in inventory, and use the Manufacturing module to assemble products. We may use the Accounting module for costing but are primarily focused on inventory and manufacturing.
- Scale: We manage thousands of components (e.g., resistors, capacitors, connectors) and hundreds of finished products, with frequent updates to part numbers and BoMs.
- Previous Issues: We encountered errors like “No matching records found” when trying to reference non-product components in BoMs or imports, confirming the product dependency.
- Environment: We are starting fresh after resetting our database to remove dummy data, so we’re open to new configurations or customizations.
- Customization Willingness: We are open to custom development (e.g., Odoo Studio or hired developers) if Odoo can provide guidance or a module template.
Request for Support:
Please provide a solution or workaround to manage components separately from products in Odoo, addressing the above requirements and challenges. Specifically:
- Confirm if Odoo supports a native way to separate components from products without using product.product.
- If not, recommend a scalable configuration or customization (e.g., custom model, module, or settings) to achieve this.
- Provide step-by-step guidance or documentation for implementing the solution.
- If custom development is required, suggest resources (e.g., Odoo Studio, partner developers, or API documentation) and estimated effort.
1. Does This Solve My Problem?
Answer: No, the Disassembly feature does not solve my core problem.
Problem: I need to manage components (e.g., resistors, capacitors) in a separate entity or model, not as products in product.product, to avoid cluttering the product list, simplify BoM creation, and streamline procurement and inventory processes.
Disassembly’s Purpose: The Disassembly feature is designed for reverse manufacturing (breaking down finished products into components), not for managing components independently throughout the system. It still requires all components to be defined as products in product.product, directly conflicting with your goal.
Dependency on product.product: In a Disassembly BoM, components (listed as By-Products) must be registered as products, just like in standard or Kit BoMs. This means you’d still need to create product records for every component (e.g., “Resistor 10kΩ,” “Capacitor 100µF”), perpetuating the clutter and management issues you’re trying to avoid.
Workflow Mismatch: Disassembly addresses a niche use case (e.g., handling returns or recycling), not your primary workflow of procuring components, storing them in inventory, and assembling them into finished products. It doesn’t provide a mechanism to manage components outside the product model or create a dedicated Components menu.
Why It Fails:
Disassembly doesn’t eliminate the need to define components as products, which is the root of my issue.
It doesn’t offer a separate model or UI for components, leaving the Products list cluttered with thousands of components.
It’s irrelevant to our procurement and standard manufacturing processes, as it focuses on deconstruction rather than assembly or inventory management.
2. Does It Help Me Distinguish Products and Components?
Answer: No, it does not help distinguish products and components effectively.
My Requirement: I want a clear distinction between components (non-sellable raw materials) and products (sellable finished goods) in the Inventory and Manufacturing modules, ideally with separate menus or models to reduce confusion and improve usability.
Disassembly’s Approach: Disassembly BoMs treat components as By-Products, but these are still products in product.product. There’s no structural or visual separation between components and finished products:
Components appear in the Products list alongside finished products.
Filtering by Product Category (e.g., “Components” vs. “Finished Goods”) is possible, but it’s a superficial organization within the same model, as I’ve already found insufficient.
UI Impact: The Disassembly feature doesn’t introduce a new menu (e.g., Components) or view for components. My team would still navigate the same Inventory > Products list, seeing thousands of components mixed with finished products, leading to the same usability issues (e.g., confusion, risk of errors like selecting a component in a sales order).
BoM Configuration: In a Disassembly BoM, the finished product (e.g., “Circuit Board”) and components (e.g., “Resistor 10kΩ”) are all products, with no mechanism to tag or manage components differently. The By-Product designation is only a role within the BoM, not a systemic separation.
Why It Fails:
Disassembly doesn’t provide a dedicated model or UI for components, maintaining the shared product.product model.
It doesn’t reduce clutter or confusion, as components remain indistinguishable from products in most views.
It doesn’t address your team’s need for a clear, separate workflow for managing raw materials.
3. Will Components Not Appear as Products in the Shop?
Answer: Components may still appear in the shop unless explicitly configured otherwise, and Disassembly doesn’t inherently prevent this.
My Concern: You want to ensure components (e.g., resistors, capacitors) do not appear in the product catalog or e-commerce shop (if using the Website or eCommerce module), as they are non-sellable raw materials.
Disassembly’s Impact: The Disassembly feature does not inherently control whether components appear in the shop, as this is governed by product settings, not the BoM type:
Product Settings: Components defined as products in product.product can appear in the shop unless you explicitly set Can be Sold to False (Inventory > Products > Product Form > Sales Tab) or exclude them from the Website module (e.g., unpublish or restrict via pricelists).
Disassembly BoM: Listing components as By-Products in a Disassembly BoM doesn’t affect their visibility in the shop. The product.product model doesn’t distinguish between components and finished products for sales purposes.
Risk: If you forget to configure components correctly (e.g., disable Can be Sold), they could appear in the shop or be selectable in Sales Orders, leading to errors (e.g., selling “Resistor 10kΩ” to a customer). This risk persists with Disassembly, as it doesn’t introduce a separate model or flag components as non-sellable.
Configuration Effort: To prevent components from appearing in the shop, you’d need to:
Set Can be Sold to False for each component product.
Use Product Categories or filters to exclude components from pricelists or website visibility.
This is manual and error-prone for thousands of components, especially with frequent updates to part numbers.
Why It Fails:
Disassembly doesn’t address shop visibility, as it’s unrelated to sales or e-commerce settings.
Components remain in product.product, requiring manual configuration to exclude them from the shop, which is inefficient and risky at scale.
It doesn’t provide a systemic way to mark components as non-sellable, leaving room for errors.
Why Disassembly Doesn’t Solve the Real Issue
The real issue is Odoo’s design limitation that requires all components to be defined as products in product.product, leading to:
Cluttered Product List: Thousands of components (e.g., resistors, capacitors) mixed with finished products, overwhelming the Inventory > Products interface.
Usability Challenges: Confusion for procurement and manufacturing teams, risking errors like incorrect BoM configurations or selling components.
Scalability Issues: Managing thousands of product records for components is labor-intensive and unsustainable with frequent part number updates.
Import Errors: BoM or inventory imports fail (e.g., “No matching records found”) if components aren’t predefined as products.
Shop Visibility Risks: Components may appear in the shop unless manually configured, increasing error potential.
Disassembly’s Shortcomings:
Irrelevant Functionality: Disassembly is for reverse manufacturing (e.g., breaking down a circuit board into resistors), not for managing components throughout the procurement, inventory, and assembly workflow. It doesn’t address your primary need to separate components from products system-wide.
No Model Separation: It still requires components to be products, perpetuating the core issue of a shared product.product model.
No UI Improvement: It doesn’t introduce a Components menu or distinct view, leaving the product list cluttered and confusing.
No Shop Protection: It doesn’t prevent components from appearing in the shop, requiring manual configuration.
Limited Scope: Disassembly is a niche feature for specific use cases (returns, recycling), not a solution for ongoing component management in electronics manufacturing.
Misalignment with my Needs:
Your workflow involves procuring components, storing them in inventory, and assembling them into finished products, with a need for clear separation to avoid confusion and errors.
Disassembly only applies to deconstructing finished products, which is a secondary or rare process in your operations (e.g., for defective returns). It doesn’t streamline procurement, inventory, or standard manufacturing.
Odoo’s support response seems to misunderstand your requirement, focusing on a feature that doesn’t address the systemic issue of component separation.
Industry Context:
This limitation is a known pain point for manufacturers, especially in electronics, where high component volumes and distinct workflows for raw materials versus sellable goods are standard. Odoo’s one-size-fits-all product model doesn’t align with industry needs, as seen in community discussions. A native solution (e.g., a component.component model) is needed, as Disassembly is a tangential feature.
Then we will not be able to use the inventory effectively. This is the fundamental feature every ERP has and i am surprised, Odoo has not found it.
Requested Solution:
We urgently request Odoo to address this limitation by introducing a native solution in the core product, such as:
Custom Component Model: A new model (e.g., component.component) for components, with fields like Name, Part Number, Unit of Measure, and Stock Quantity, accessible via a Components menu.
Flexible BoM Referencing: Allow BoMs to reference non-product entities (e.g., component.component) instead of mandating product.product.
UI Separation: Provide distinct views or menus for components and products within Inventory, even if using product.product.
Why a Native Fix is Essential:
This issue affects not just our company but a broad segment of Odoo’s manufacturing user base, particularly in electronics, automotive, and similar industries with complex component inventories. A native fix would:
Enhance Odoo’s competitiveness as a manufacturing ERP.
Reduce reliance on costly customizations, improving adoption.
Align Odoo with industry standards for component management.
Shiva, I do acknowledge that you're facing a limitation for your industry with the default behavior of Odoo. Since you do have an enterprise subscription, I would suggest you to carry over your inquiry to https://www.odoo.com/help-form and report a ticket such as "Unexpected behavior". I, for my part however, will not invest myself further into a User Story requiring deep understanding of your processes as I'm not an employee of Odoo but associated to a partner, doing this for a living.
By now, we've established that,
- Odoo does not support a native way to separate components from products without using product.product
- Options to deal with your scenario, based on the brief understanding we can have of your requirement, given the scope of a forum's post
About suggested resources let me share these links with you: Studio (https://www.odoo.com/documentation/18.0/de/applications/studio.html), API (https://www.odoo.com/documentation/18.0/developer/reference/external_api.html), List of Partners (https://www.odoo.com/partners).
I can not provide you with a step-by-step implementation in the forum.