CPQ Guide

Tag: BOM generation

  • 3D Visualization vs CAD Generation in CPQ

    3D visualization and CAD generation are related but different capabilities in manufacturing CPQ. A 3D visual shows what a configured product may look like and helps users understand options, dimensions and arrangement. CAD generation creates engineering data, such as a parametric model, assembly, drawing or manufacturing-related design output, based on the selected configuration.

    A visual CPQ system may provide an interactive model without creating a production-ready CAD file. Conversely, a CAD automation system may generate accurate engineering outputs without offering a sophisticated interactive 3D viewer. Some manufacturing CPQ platforms combine both, but buyers should evaluate them separately.

    The distinction matters when configuring industrial machinery, pumps, valves, electrical equipment, vehicles, material-handling systems or other products with dimensional, mechanical and engineering dependencies. A visualization can support sales and configuration validation; CAD generation can reduce engineering work and create downstream data for a configure-to-order or engineer-to-order process.

    For a broader explanation of how these capabilities fit into manufacturing software, see the guide to manufacturing CPQ and the detailed guide to CAD automation and engineering automation.

    What is the difference between 3D visualization and CAD generation?

    Capability Primary purpose Typical output Main users
    3D visualization Communicate, inspect and validate the selected configuration Interactive or rendered 3D model, preview image, exploded view or animation Salespeople, dealers, customers, application engineers and product managers
    CAD generation Create product-specific engineering geometry and design documentation Parametric part, assembly, drawing, neutral CAD file or design package Design engineers, application engineers, manufacturing engineers and suppliers
    Product configuration Determine whether selected options and values are valid Validated configuration, feature selections, parameters and rule results Sales, engineering, product management and CPQ administrators
    BOM generation Translate the configuration into components and quantities Configurable BOM, EBOM or manufacturing-ready BOM data Engineering, production planning, purchasing and ERP users

    A three-dimensional preview is therefore not automatically a CAD model. It may use simplified geometry, prebuilt assets, visibility states and material appearances. CAD generation normally requires more detailed product data, geometric parameters, templates, feature relationships, tolerances and engineering rules.

    How 3D visualization works in manufacturing CPQ

    In a manufacturing CPQ system, visualization is usually connected to the product model. The product model contains features, options, dimensions, materials and dependencies. When a user changes a selection, the visualization layer updates the relevant geometry or presentation state.

    For example, a configurable pump may include:

    • pump family and hydraulic performance range;
    • impeller diameter and material;
    • motor power and voltage;
    • connection size and orientation;
    • seal type and elastomer;
    • baseplate, coupling guard and enclosure options; and
    • overall length, height and service-clearance dimensions.

    A visual CPQ application may show the selected motor, rotate the discharge connection, change the baseplate length and display the appropriate guard. The representation may be driven by rules such as: if the motor exceeds a specified power, show a larger baseplate; if the selected connection is a particular standard, change the flange geometry; or if a vertical arrangement is chosen, suppress the horizontal support.

    The visual model can be assembled from reusable components. It may use configurable 3D assets, variant geometry, texture and color rules, camera positions, annotations or dimension overlays. Some systems display a lightweight model for browser performance rather than the full engineering geometry.

    What visualization can help users verify

    • Whether the selected options appear in the intended arrangement.
    • Relative size, orientation and access points.
    • Color, finish, enclosure and external accessories.
    • Clearance around doors, service panels, lifting points or connections.
    • Whether a selected option is visually compatible with the base product.
    • What the quoted product will look like in a proposal or customer review.

    Visualization can expose misunderstandings that a text-only configuration does not. A customer may recognize that a control panel is on the wrong side or that a pipe connection faces an inaccessible direction. However, a visual check does not replace engineering validation. A model can look plausible while still violating load, pressure, thermal, electrical, material or manufacturing constraints.

    How CAD generation works in manufacturing CPQ

    CAD generation uses configuration data to create or modify engineering design data. CAD means computer-aided design. In this context, CAD automation may drive a parametric template, select predefined parts, alter dimensions, create features, assemble components and produce drawings or export files.

    A typical CAD generation process includes the following stages:

    1. Capture configuration inputs. The CPQ application records selections, calculated values, dimensions, performance requirements and customer-specific parameters.
    2. Validate engineering rules. The system checks compatibility, operating limits, geometry constraints and required options.
    3. Map configuration data to CAD parameters. Values such as shaft diameter, frame length, tank volume or mounting-hole spacing are assigned to CAD variables or templates.
    4. Select or suppress components. The process adds, removes or replaces parts and subassemblies according to the configuration.
    5. Regenerate the design. A CAD engine or automation service rebuilds the model and resolves dependencies.
    6. Generate outputs. The system may create a part, assembly, drawing, neutral exchange file, PDF, image or engineering package.
    7. Store and distribute the result. The output may be associated with the quote, revision, item number, ERP record, product lifecycle management system or product data management system.

    Product lifecycle management, or PLM, manages product definitions and lifecycle information. Product data management, or PDM, typically manages engineering files, versions, relationships and access. CAD, PLM and PDM are not interchangeable with CPQ. CPQ may initiate or consume engineering processes, while PLM or PDM may remain the system of record for released design data.

    Example: configurable industrial enclosure

    Consider an electrical enclosure configured by width, height, depth, door arrangement, gland-plate location, material, coating, cooling method and internal mounting equipment. A visualization might update the cabinet appearance and show the door position. CAD generation could create a dimensioned enclosure model, place mounting rails, cut openings, generate a panel layout and produce a drawing for engineering review.

    The CAD output may still require approval. If the configuration is engineer-to-order, the generated model can be a starting point rather than an automatically released manufacturing design. Engineering may need to check thermal performance, structural strength, compliance requirements, wiring, supplier constraints and production methods.

    Where 3D visualization and CAD generation fit in the CPQ architecture

    Manufacturing CPQ normally sits between commercial users and several product-data and enterprise systems. The exact architecture differs by platform, but a common flow is:

    Customer or salesperson
            ↓
    CPQ user interface and product configuration
            ↓
    Rules, constraints, calculations and pricing
            ↓
    3D visualization ─────── CAD automation
            ↓                       ↓
    Quote and proposal       Engineering files and drawings
            ↓                       ↓
    ERP, CRM, PLM/PDM, MES and production processes

    CRM, or customer relationship management, may provide the opportunity and account context. CPQ manages configuration, pricing and quotation logic. ERP, or enterprise resource planning, may manage orders, inventory, purchasing and production transactions. PLM or PDM manages engineering definitions and files. MES, or manufacturing execution system, supports production execution. These systems can exchange data, but they have different responsibilities.

    The product configuration layer should normally remain the source of the selected commercial and technical intent. The visualization layer interprets that intent for users. CAD automation interprets it for engineering geometry. BOM generation interprets it for component and quantity structures. Pricing interprets it for cost and price calculations. These outputs should be linked to the same configuration identity and revision.

    Relationship between configuration, visualization, CAD and BOMs

    A valid product configuration is the foundation for both visualization and CAD generation. Configuration rules determine which combinations are allowed. Constraint-based configuration may evaluate relationships such as dimensions, capacities, loads, clearances and performance limits. Guided selling may ask users a sequence of questions and recommend options, but recommendations are not a substitute for formal engineering validation.

    A configured bill of materials, or BOM, translates the selected product into components and quantities. An engineering BOM, or EBOM, represents the product from an engineering perspective. A manufacturing BOM, or MBOM, represents how the product is assembled or produced. A CPQ system may generate one or more of these structures, but not every CPQ platform does so.

    For example, selecting a larger motor may trigger several outcomes:

    • the visualization displays a larger motor and base;
    • the CAD model changes mounting geometry and guard dimensions;
    • the EBOM includes the appropriate motor, coupling and fasteners;
    • the MBOM adds a different assembly operation or workstation requirement;
    • costing uses the larger motor and additional material;
    • pricing applies the configured commercial rules; and
    • the quote includes the correct description and customer-facing image.

    These outputs should not be assumed to update automatically. A buyer should verify whether the platform has native BOM, CAD and visualization functions, uses integrations, or requires custom development. The guide to BOM generation, pricing and quoting provides more detail on these downstream relationships.

    3D visualization versus CAD generation: practical comparison

    Evaluation area 3D visualization CAD generation
    Primary question What will the configured product look like? What engineering geometry and documentation are required?
    Geometric accuracy May be simplified or representative Usually requires controlled dimensions and design relationships
    Interaction Often interactive, browser-based and immediate May be asynchronous and dependent on a CAD engine
    Engineering validity Supports visual review but does not prove full validity Can encode engineering intent but still may require review and release
    Typical output 3D scene, image, animation or preview Part, assembly, drawing, neutral file or design package
    Performance requirement Fast rendering and responsive interaction Model regeneration, file processing and version control
    Data maintenance Visual assets, mappings and display rules CAD templates, parameters, features, assemblies and drawing rules
    Best-fit use Sales explanation, customer validation and proposal content Engineering automation, design reuse and downstream technical work

    Benefits of combining both capabilities

    Better customer and dealer understanding

    A 3D preview gives customers and distributors a clearer view of a complex product than a long option list. This is useful for equipment with multiple orientations, accessories, finishes and dimensional variants.

    Fewer configuration misunderstandings

    Visual feedback can reveal an incorrect arrangement before a quote becomes an order. It is particularly useful when options affect external geometry, access, serviceability or installation space.

    Less repetitive engineering work

    When CAD generation is properly parameterized, engineers do not need to recreate the same design manually for every valid configuration. The greatest benefit is usually found in products with stable design logic and repeated variation patterns.

    More consistent sales-to-engineering handoff

    The same configuration identifier can connect the quote, visual output, BOM, CAD files and engineering review. This reduces the risk that engineering receives a salesperson’s free-text interpretation rather than structured product data.

    Improved quote quality

    When visual, engineering, BOM and pricing outputs use consistent inputs, the quote can include more accurate descriptions, dimensions, images, accessories and commercial assumptions. This does not eliminate the need for review, especially for engineered products.

    Limitations and risks

    A visual model can create false confidence

    Customers may assume that a realistic model is an approved engineering design. The user interface should clearly distinguish a conceptual preview from a released or manufacture-ready design.

    CAD automation can be difficult to maintain

    CAD templates often contain feature dependencies, naming conventions, external references and version-specific behavior. A small change in a template or option structure can break regeneration or produce an incorrect result.

    Not every valid configuration is easy to visualize

    Some changes are primarily functional or internal. A new bearing specification, insulation class, firmware option or material grade may not have a visible effect. The system still needs non-visual rules and documentation.

    Large models can affect user experience

    Heavy assemblies, high-resolution textures and complex calculations can make browser-based visualization slow. Lightweight representations, progressive loading and simplified geometry may be needed.

    Engineering approval may remain necessary

    CAD generation does not automatically make a product suitable for manufacture. Structural analysis, safety review, compliance assessment, sourcing checks, tolerance review and design approval may still be required.

    Data ownership can become unclear

    If CPQ, CAD, PLM and ERP each contain different versions of product data, organizations can create duplicate sources of truth. Ownership of options, parameters, revisions, drawings and released parts should be defined before implementation.

    Implementation considerations

    Define the required output level

    Start by identifying whether the business needs a sales preview, a dimensionally credible visual, a CAD concept, an engineering-ready model, an approved drawing or a complete manufacturing package. These are different requirements with different costs and governance needs.

    Separate product rules from presentation rules

    Product rules determine whether a configuration is valid. Presentation rules determine how the configured product is displayed. For example, a rule may prohibit a motor because of a power limitation, while a presentation rule controls whether the motor is shown in a particular color or camera view. Keeping these concerns separate makes the model easier to test.

    Establish parameter ownership

    Decide where each value is mastered. Product management may own commercial options. Engineering may own design limits and CAD parameters. Manufacturing may own assembly structures. Finance or commercial operations may own pricing rules. CPQ should consume and coordinate this data without silently creating unmanaged duplicates.

    Use a stable configuration identity

    Every visual, CAD, BOM and quote output should be traceable to the same configuration, revision and date. The record should show the selected options, calculated values, rule results and output status. This is essential when a customer asks why a drawing or price changed after a product-model update.

    Test representative configurations

    Testing should include standard, boundary, invalid and unusual configurations. For a pump, this could include minimum and maximum flow, motor changes, material changes, connection orientations and combinations that affect baseplate dimensions. Test both the rules and the resulting visual, CAD and BOM outputs.

    Plan the engineering handoff

    Define what happens after a quote is accepted. A configure-to-order, or CTO, workflow may pass a validated configuration directly to order and production processes. An engineer-to-order, or ETO, workflow may create a design task and require engineering approval. Make-to-order, or MTO, produces to a specific order, while assemble-to-order, or ATO, assembles stocked or predefined components after the order. Visualization and CAD have different roles in each workflow.

    See the guide to configure-to-order, engineer-to-order and related manufacturing workflows for a fuller comparison.

    Integrate deliberately with enterprise systems

    Integration requirements may include sending opportunity information from CRM, checking materials or item masters in ERP, retrieving released designs from PLM or PDM, invoking a CAD service, returning files to a document repository and sending the approved configuration into order entry. The CPQ integration guide covers these system boundaries.

    Questions to ask when evaluating a CPQ platform

    • Does the platform provide native 3D visualization, or does it connect to a separate viewer?
    • Can it display configurable geometry, or only switch between static product images?
    • Can users inspect dimensions, orientations, accessories and clearances?
    • Does it support lightweight web models for large assemblies?
    • Can it generate CAD files, or does it only pass parameters to a CAD automation service?
    • Which CAD systems, file types and template strategies are supported?
    • Can the platform generate drawings and engineering documents?
    • Are CAD outputs preliminary, approved or manufacturing-ready?
    • How are configuration rules shared between CPQ, visualization and CAD?
    • Can the system generate a configurable BOM, EBOM or MBOM?
    • How are revisions and output failures recorded?
    • Can engineering approve or modify an automatically generated design?
    • How are PLM and PDM records linked to the quote and order?
    • What happens when a CAD template or product rule changes?
    • How are invalid, incomplete or unsupported configurations handled?

    These questions should be included in a manufacturing CPQ requirements document rather than treated as generic feature-checklist items. The CPQ implementation guide provides additional guidance on requirements, governance, testing and maintenance.

    Conclusion

    3D visualization and CAD generation support different stages of the manufacturing CPQ process. Visualization helps users understand and review a configured product. CAD generation creates engineering geometry and documentation from the same configuration data. Neither capability should be treated as a substitute for the other.

    The strongest architecture connects product rules, engineering calculations, visualization, CAD automation, BOM generation, pricing and enterprise workflows through a controlled configuration record. For simpler configure-to-order products, visualization may be the main requirement. For dimensional, engineered or engineer-to-order products, CAD generation and engineering governance may be more important. In both cases, buyers should verify the actual depth of the platform rather than assume that a CPQ label includes visual configuration, CAD automation or manufacturing outputs.

    Semantic map

    The article connects the following entities and relationships:

    • CPQ connects product configuration with pricing, quoting and engineering outputs.
    • 3D visualization represents a configured product for user review.
    • CAD generation creates product-specific engineering geometry.
    • Configuration rules prevent invalid option combinations.
    • Constraint-based configuration evaluates technical relationships and limits.
    • Configured products generate BOM structures when the CPQ system supports BOM generation.
    • CAD automation generates models, assemblies and drawings from parameters.
    • EBOM represents an engineering product structure.
    • MBOM represents a manufacturing assembly structure.
    • PLM and PDM manage engineering product data and design files.
    • ERP manages commercial, inventory, purchasing and production transactions.
    • CRM provides customer and opportunity context.
    • CTO uses validated configurations to support repeatable order execution.
    • ETO uses configuration data as an input to engineering design and approval.
    • Visual CPQ improves communication between customers, sales and engineering.

    Frequently asked questions

    1. Is 3D visualization the same as CAD generation in CPQ?

    No. 3D visualization displays a configured product for understanding and review. CAD generation creates engineering design data such as parametric models, assemblies or drawings. A platform may provide one, both or neither capability.

    2. What is visual CPQ?

    Visual CPQ is a configure, price, quote approach that uses images, interactive 2D views or 3D models to show the selected product. In manufacturing, it can show options, dimensions, orientations and accessories while the configuration is being created.

    3. Can a 3D viewer prove that a product is manufacturable?

    No. A viewer can show appearance and support visual inspection, but it does not necessarily validate loads, tolerances, materials, electrical requirements, manufacturing methods or compliance conditions.

    4. Does every manufacturing CPQ platform generate CAD files?

    No. CAD generation is a specialized capability. Some platforms integrate with CAD automation tools, while others provide only configuration, pricing, quoting or visualization.

    5. What CAD outputs can CPQ generate?

    Depending on the implementation, outputs may include parametric parts, assemblies, drawings, neutral exchange files, PDFs, images or engineering packages. The actual output depends on the CAD system, templates and vendor capabilities.

    6. Does CAD generation automatically create a manufacturing drawing?

    Not necessarily. A system may create a model without creating a fully dimensioned, toleranced or approved drawing. Drawing generation and engineering release should be verified separately.

    7. How does visualization use configuration rules?

    Rules can control which components appear, which geometry is suppressed, how dimensions change and which accessories are displayed. These presentation rules should complement, but not replace, formal configuration validation.

    8. Can visualization reduce configuration errors?

    It can reduce misunderstandings about visible options, arrangement and orientation. It cannot detect every technical incompatibility, especially when the issue concerns internal performance, materials, loads or manufacturing constraints.

    9. What is the role of CAD automation in engineer-to-order workflows?

    CAD automation can create a starting design from customer requirements and configuration parameters. Engineering may then review, modify, approve and release the result before production.

    10. How are CAD outputs linked to a quote?

    A CPQ implementation can associate generated files with a configuration identifier, quote revision and product or opportunity record. The exact linkage may use APIs, document management, PLM or PDM integration.

    11. Can a visual CPQ system generate a BOM?

    Not automatically. Visualization and BOM generation are separate functions. A CPQ system must have BOM capability or an integration that translates configuration selections into components and quantities.

    12. What is the difference between an EBOM and an MBOM?

    An EBOM is an engineering bill of materials organized around product design. An MBOM is organized around manufacturing and assembly processes. A CPQ system may generate or exchange one, both or neither.

    13. Should the CAD system or CPQ system own product rules?

    Ownership depends on the process, but it should be explicit. CPQ commonly owns commercial configuration and quoting rules, while engineering systems may own detailed design parameters. Shared or duplicated rules require governance and synchronization.

    14. Can CAD generation support configure-to-order products?

    Yes, when the product family has stable design logic and repeatable variations. The generated design may be used directly or passed through an approval process, depending on the organization’s release controls.

    15. What is the difference between a CAD model and a 3D visualization model?

    A CAD model contains design geometry and engineering relationships intended for design work. A visualization model may be simplified for fast display and may not contain editable parameters, manufacturing features or complete dimensions.

    16. Does a realistic 3D model mean the quote is technically complete?

    No. A realistic model may omit internal components, calculations, compliance requirements, service constraints and manufacturing data. Technical completeness depends on the product model and required engineering outputs.

    17. How should companies test 3D and CAD outputs?

    Test standard, boundary, invalid and unusual configurations. Verify geometry, dimensions, suppressed and included components, BOM quantities, file naming, revisions, failures and the relationship between the quote and generated outputs.

    18. What should manufacturers prioritize: visualization or CAD generation?

    Prioritize the capability that addresses the main operational problem. Choose visualization when customer understanding and configuration review are the priority. Choose CAD generation when repetitive engineering design work and technical output creation are the primary bottlenecks. Many complex manufacturers need both.

  • Using Simulation and Engineering Calculations During Configuration

    In manufacturing, simulation and engineering calculations allow a CPQ configurator to evaluate whether a proposed product will work before the quote reaches engineering or production. Instead of only selecting options and calculating a price, the system can calculate capacity, dimensions, performance, operating limits, material requirements and other technical results from the customer’s inputs.

    For example, a pump configurator may use flow rate, head, fluid properties, temperature and motor requirements to recommend a suitable pump size. An industrial machinery configurator may calculate frame dimensions, drive power, lifting capacity or guarding requirements. The result can include a validated configuration, an engineering summary, a configurable bill of materials (BOM), product-specific CAD outputs and a quote based on technically feasible requirements.

    This is a major distinction between manufacturing CPQ and generic sales CPQ. A sales-oriented system may configure commercial options and calculate a price. A manufacturing CPQ system may also execute engineering formulas, call simulation services, generate CAD data and pass validated product information to enterprise systems.

    What are engineering calculations during configuration?

    Engineering calculations during configuration are formulas, algorithms or external engineering services that transform configuration inputs into technical results. The results may determine whether a product is feasible, which components are required, how the product should be dimensioned or what performance it can deliver.

    The calculation normally runs after, or during, a user’s configuration choices. It can use selected options, numeric dimensions, environmental conditions, material properties, product standards and data from a product model. The output may be a warning, a required option, a calculated value, a recommendation, a component selection, a CAD parameter or an approval requirement.

    Calculation type Typical inputs Possible outputs
    Capacity calculation Load, flow, speed, volume or duty cycle Required motor, frame size or rated capacity
    Dimensional calculation Length, width, height, clearance or installation space Product dimensions, shaft length or enclosure size
    Thermal calculation Temperature, heat load, ambient conditions and materials Cooling requirement, insulation class or derating
    Hydraulic calculation Flow, pressure, fluid density, viscosity and pipe geometry Pipe diameter, pump selection or pressure loss
    Electrical calculation Voltage, current, power, phase and protection requirements Cable size, breaker rating or control-panel components
    Structural calculation Loads, spans, materials, supports and safety factors Section size, reinforcement or engineering review

    These calculations do not always constitute a full physical simulation. A simple algebraic formula may be sufficient for product selection. More advanced cases may use finite element analysis, computational fluid dynamics, kinematic simulation or an external engineering application.

    Where calculation fits in a manufacturing CPQ architecture

    A calculation-driven configurator usually sits between product data, engineering logic and commercial processes. The CPQ system manages the customer-facing configuration and often coordinates the data exchange, while specialized systems may perform calculations or generate design outputs.

    1. User inputs: The salesperson, dealer, engineer or customer enters requirements such as capacity, dimensions, material, operating environment and delivery constraints.
    2. Configuration model: The CPQ product model applies options, dependencies, exclusions and constraints. It determines which selections are permitted.
    3. Calculation engine: Formulas or an external service calculates technical values and evaluates performance or compliance.
    4. Selection and validation: The system selects components, reports warnings and requests additional information where needed.
    5. Engineering output: Parametric CAD, drawings, specifications, calculations or simulation results are generated when supported.
    6. Commercial output: The calculated configuration drives costing, pricing, a quote and potentially approval workflows.
    7. Manufacturing handoff: The validated configuration creates or updates a BOM, order structure and data sent to enterprise systems.

    The surrounding systems have different responsibilities. CAD means computer-aided design and contains geometric or design information. A product lifecycle management system (PLM) manages product definitions, revisions and lifecycle processes. A product data management system (PDM) generally manages CAD files and related engineering data. An enterprise resource planning system (ERP) manages operational data such as items, inventory, purchasing, orders and production. A manufacturing execution system (MES) supports execution on the shop floor.

    These systems are related but are not interchangeable. A CPQ system may orchestrate data between them through APIs, files, middleware or integration platforms. The appropriate architecture depends on where the authoritative version of each product and engineering record is maintained.

    Rules, calculations and simulation are different capabilities

    Product configuration rules, engineering calculations and simulation often work together, but they solve different problems.

    Capability Main question Example
    Rules-based configuration Is this selection allowed? A stainless-steel option requires a compatible seal material.
    Constraint-based configuration Which combinations satisfy multiple technical constraints? The selected motor, voltage and enclosure must be compatible with available space and power requirements.
    Guided selling Which product or option should be recommended based on user needs? Recommend a valve family based on media, pressure and temperature.
    Engineering calculation What technical value or component follows from the requirements? Calculate required pump head or structural section size.
    Simulation How will the proposed design behave under modeled conditions? Evaluate stress, airflow, motion or thermal performance.

    A rule may prevent an invalid combination without calculating anything. A formula may calculate a result without modeling physical behavior in detail. A simulation usually represents more complex behavior and may require more inputs, longer processing time and specialist validation.

    Manufacturing examples

    Pump and fluid equipment configuration

    A pump configurator can collect flow rate, total dynamic head, fluid type, temperature, viscosity, installation arrangement and power supply. Rules may prevent incompatible materials or seal combinations. Engineering calculations may estimate system resistance, pump duty point and motor power. A selection algorithm can identify suitable pump sizes from a controlled product catalog.

    The result may include a pump assembly, motor, coupling, baseplate, seals, instrumentation and a configurable BOM. A CAD system may use the selected pump, nozzle orientation and base dimensions to produce a model or drawing. The price can incorporate the selected materials, motor size and engineering options.

    HVAC and air-handling equipment

    An air-handling unit configurator may calculate airflow, heating or cooling capacity, coil dimensions, fan selection and pressure drop. Inputs can include air volume, entering and leaving temperatures, humidity, altitude, filtration requirements and available installation space.

    The calculation may identify a standard configuration, a non-standard design requiring engineering review or an infeasible request. It can also influence enclosure dimensions, access-panel positions, motor selection and the BOM. A quotation should make clear which results are calculated automatically and which remain subject to final engineering approval.

    Industrial machinery

    For a conveyor, hoist or packaging machine, configuration inputs may include product weight, throughput, travel distance, duty cycle, line speed and layout dimensions. Calculations can determine drive torque, motor power, belt width, roller spacing or frame requirements.

    If the requested combination exceeds the standard design envelope, the CPQ system may route the opportunity into an engineer-to-order (ETO) process. ETO means that substantial engineering work is performed for a particular order. By contrast, configure-to-order (CTO) uses predefined choices and generally produces a standard or modular product.

    Electrical equipment and enclosures

    An electrical equipment configurator may calculate enclosure size, heat dissipation, cable-entry requirements, protective-device ratings and available panel space. Rules can enforce voltage, phase, short-circuit rating and component compatibility.

    Where the design involves safety, regulatory compliance or high fault energy, automated results should be treated as decision support unless the organization has formally validated the calculation method and approval process.

    Using simulation during configuration

    Simulation is useful when a simple rule or formula cannot adequately predict product behavior. It may represent structural stress, airflow, fluid movement, heat transfer, motion, acoustics or energy consumption. In a CPQ workflow, simulation can be synchronous, asynchronous or performed after the initial configuration.

    Synchronous simulation

    A synchronous simulation runs while the user is configuring the product and returns a result before the workflow continues. This can provide immediate technical feedback, but it requires fast execution, a controlled model and reliable error handling. It is more appropriate for simplified calculations or reduced-order models than for computationally intensive analyses.

    Asynchronous simulation

    An asynchronous simulation runs as a background job. The CPQ system submits inputs, receives a job identifier and later retrieves the result. This approach supports more demanding analysis but requires status management, timeouts, notifications, version tracking and a clear user experience.

    Simulation after configuration

    Some companies allow a preliminary configuration and price to be created first, then run a detailed analysis before order acceptance. This is common when the analysis needs specialist software, licensed engineering tools or a controlled approval process. The commercial workflow should identify the quote as conditional if technical validation is incomplete.

    CAD and 3D outputs from calculated configurations

    Engineering calculations become more valuable when their outputs drive computer-aided design (CAD). A parametric CAD template can use calculated dimensions and selected options to create a product-specific model, drawing or visualization.

    For example, a configured material-handling system may calculate conveyor length, support spacing and drive position. Those values can populate CAD parameters. The resulting model may show the selected arrangement, while a drawing generator adds dimensions, hole patterns, connection details and notes.

    Possible outputs include:

    • 3D product models for review or customer approval;
    • 2D drawings with calculated dimensions;
    • installation layouts and clearance envelopes;
    • rendered images for a proposal;
    • neutral CAD exchange files;
    • engineering calculation reports;
    • manufacturing or assembly documentation.

    Not every CPQ platform generates CAD. Some integrate with CAD automation software, while others only store a reference to an externally generated file. Buyers should verify which CAD systems are supported, how templates are governed, how revisions are controlled and whether generated files can be reproduced from the saved configuration.

    For more detail, see the guide to CAD automation and engineering automation in manufacturing CPQ.

    How calculations affect BOMs, costing and quotes

    A bill of materials (BOM) lists the components, quantities and relationships required for a product or assembly. A calculated configuration can determine not only which options appear on a quote, but also which components are required for manufacturing.

    A configurable BOM may contain rules such as:

    • selecting a motor based on calculated power;
    • adding reinforcement when a load exceeds a threshold;
    • changing material grades based on temperature or fluid compatibility;
    • adding sensors when a control option is selected;
    • changing fasteners, seals or coatings for an environmental condition;
    • selecting different subassemblies for a calculated size range.

    An engineering BOM (EBOM) describes the product from an engineering and design perspective. A manufacturing BOM (MBOM) describes how the product is assembled or manufactured, including production structure and sometimes manufacturing-specific items. A CPQ process may generate or influence an EBOM, an MBOM, a configurable BOM or an order-specific structure, but the exact responsibility depends on the system architecture.

    Calculated values can also affect costing and pricing. A larger motor, thicker material, additional reinforcement or custom machining may increase cost. However, technical calculation and commercial pricing should remain conceptually separate. The calculation determines what is technically required; the pricing engine determines how that requirement is valued commercially.

    See BOM generation, costing and quote automation for the relationship between configuration outputs and commercial documents.

    Managing the sales-to-engineering handoff

    A strong configuration workflow reduces the amount of information engineering must reconstruct from a sales conversation. The handoff should include the customer requirements, selected options, calculated values, assumptions, warnings, approvals, revision identifiers and generated outputs.

    For example, a sales engineer handing over a configured pressure system should not send only a product code and price. Engineering may also need fluid properties, design pressure, temperature, corrosion allowance, selected materials, calculated wall thickness, instrumentation requirements and the version of the calculation method used.

    The handoff can be automatic for CTO products. For ETO products, the CPQ system may create an engineering request containing the preliminary design and identify the unresolved decisions. This preserves the work already performed while allowing an engineer to review non-standard requirements.

    Manufacturing workflow concepts such as CTO, ETO, make-to-order (MTO) and assemble-to-order (ATO) are explained in the guide to manufacturing CPQ workflows.

    Data required for reliable calculations

    Calculation quality depends on the quality and governance of the underlying data. A calculation is not reliable merely because the formula is mathematically correct.

    • Input definitions: Units, permitted ranges, precision, default values and required fields must be explicit.
    • Engineering constants: Material properties, efficiency factors, safety factors and performance curves require controlled ownership.
    • Product data: Component ratings, dimensions, compatibility information and lifecycle status must be current.
    • Versioning: The system must identify which formula, product revision and engineering data produced a result.
    • Assumptions: Ambient conditions, duty cycles, installation factors and user-provided estimates should be visible.
    • Units and conversions: The system must prevent errors between metric and imperial units or between related engineering measures.
    • Validation ranges: Inputs should be checked for missing, implausible or contradictory values.

    Product data may be maintained in the CPQ system, PLM, PDM, ERP or a specialist engineering database. The implementation should define which system is authoritative for each data category and how updates are published.

    Benefits and limitations

    Benefits

    • Fewer technically invalid quotes reach customers.
    • Sales engineers can evaluate standard configurations without repeating manual calculations.
    • Quotes can include more accurate dimensions, performance values and scope.
    • Calculated selections can drive BOMs, drawings and downstream order data.
    • Engineering effort can shift from repetitive selection work to genuinely non-standard designs.
    • Customers and dealers can receive faster feedback on feasibility and trade-offs.

    Limitations and risks

    • A calculation model may be valid only within a defined operating envelope.
    • Automated results may be wrong when inputs are incomplete or product data is outdated.
    • Detailed simulation can introduce long processing times and specialist software dependencies.
    • CAD automation can fail when templates, geometry or naming conventions are not maintained.
    • Complex rules may become difficult to test and explain if ownership is unclear.
    • Safety-critical or regulated products may require formal engineering sign-off.
    • A CPQ result does not automatically replace design verification, certification or professional engineering judgment.

    The system should distinguish between an automatically validated configuration, a configuration requiring review and a configuration that is outside the supported product model. A warning should explain the reason and the next action rather than merely displaying a generic error.

    Implementation approach

    1. Define the decision to automate

    Start with a specific engineering decision, such as motor selection, nozzle sizing, enclosure dimensioning or load validation. Avoid attempting to automate an entire engineering process before the inputs, outputs and acceptance criteria are understood.

    2. Document the existing method

    Capture spreadsheets, selection charts, CAD templates, manual calculations and approval practices. Identify hidden assumptions and exceptions. A formula that exists only in an experienced engineer’s personal worksheet is not yet a governed product rule.

    3. Separate inputs, rules and outputs

    Define which values are customer requirements, which are derived values, which are constraints and which are commercial decisions. This separation makes testing and future maintenance easier.

    4. Choose the calculation location

    The calculation may run inside the CPQ rules engine, in a dedicated calculation service, in CAD automation software or in an external simulation platform. Selection should consider performance, licensing, security, maintainability, auditability and integration requirements.

    5. Build test cases

    Test normal configurations, boundary values, invalid combinations, missing data, unit conversions, changed product revisions and failure responses. Include known engineering examples and independently verified results.

    6. Establish review and release governance

    Assign ownership for formulas, material data, component ratings, CAD templates and product rules. Changes should be versioned, reviewed and tested before being released to sales or dealers.

    7. Pilot a bounded product family

    A pump family, standard enclosure range or modular conveyor is often easier to pilot than a complete product portfolio. Measure calculation accuracy, engineering review time, quote rework, failed configurations and maintenance effort.

    Implementation planning should also cover migration, integrations, deployment, user adoption and long-term governance. The manufacturing CPQ implementation guide provides a broader framework.

    Integration considerations

    Calculation-driven CPQ commonly exchanges data with several enterprise systems. A customer relationship management (CRM) system may provide the opportunity and account context. CPQ manages configuration and quote logic. PLM or PDM may provide controlled engineering definitions. CAD generates geometry. ERP receives order, item, pricing or BOM data. A product information management (PIM) system may provide descriptions and commercial content. MES may consume production data later in the process.

    Integration design should specify the direction, timing, ownership and format of each data exchange. It should also define what happens when a calculation service is unavailable, a CAD job fails or an ERP item does not yet exist. APIs, event messages, files and middleware can all be valid approaches depending on the environment.

    Read more about CPQ integration with ERP, PLM, PDM, CAD and other systems.

    How to evaluate a CPQ configurator for engineering calculations

    When evaluating software, ask vendors to demonstrate a realistic product scenario rather than a generic option-selection screen. The demonstration should include numeric inputs, dependencies, calculations, a boundary condition, a generated BOM and a handoff to an engineering or ERP system if those capabilities are required.

    • Can the platform model formulas, constraints and calculated attributes?
    • Can users see why a configuration is invalid or requires review?
    • Can calculations be versioned and tested independently?
    • Can the platform call external calculation or simulation services?
    • Can calculated values drive component selection and BOM logic?
    • Can CAD parameters, drawings or 3D outputs be generated or exchanged?
    • How are engineering approvals and exceptions represented?
    • Can the system preserve the exact inputs, rules and revisions used for a quote?
    • What happens when a calculation, integration or CAD generation job fails?
    • Which capabilities are native, and which require custom development or partner software?

    Do not assume that a platform described as a CPQ configurator includes engineering simulation, CAD automation or manufacturing BOM generation. Verify each capability against the required product family and operating process. The manufacturing CPQ comparison and selection guidance can help structure this evaluation.

    Semantic map

    The article connects the following entities and concepts:

    • Manufacturing CPQ connects customer requirements with product configuration, engineering validation and quoting.
    • Configuration rules prevent invalid option combinations.
    • Engineering calculations transform requirements into technical values and component selections.
    • Simulation evaluates modeled product behavior under defined conditions.
    • Calculated values can drive CAD parameters and product-specific drawings.
    • Configured products can generate configurable BOMs and order structures.
    • Engineering BOMs describe design structure, while manufacturing BOMs support production structure.
    • CPQ exchanges configuration and commercial data with ERP, CRM, PLM, PDM, CAD, PIM and MES systems.
    • CTO uses predefined product choices, while ETO includes order-specific engineering.
    • Engineering governance controls formulas, product data, revisions, testing and approvals.

    Frequently asked questions

    What is simulation in a manufacturing CPQ system?

    Simulation in manufacturing CPQ evaluates how a proposed configurable product may behave under modeled operating conditions. It can cover structural, thermal, fluid, motion or other engineering behavior and may use an external specialist application.

    Are engineering calculations the same as configuration rules?

    No. Rules determine whether selections are allowed, while engineering calculations derive technical values or selections from inputs. A calculation can support a rule, but the two capabilities should be modeled and tested separately.

    Can a CPQ system calculate motor size?

    It can when the product model contains suitable inputs, formulas, performance data and validation limits. For example, load, speed, torque, duty cycle and efficiency may be used to recommend a motor, subject to engineering review where necessary.

    Can calculations generate a BOM?

    Yes, in systems that support calculated product structures or BOM logic. A calculated result may select components, quantities or subassemblies, but the resulting BOM should be reconciled with the organization’s engineering and manufacturing systems.

    Does every manufacturing CPQ platform include simulation?

    No. Some platforms provide rules and formulas only. Others integrate with CAD automation, calculation services or simulation software. The required capability must be verified for the specific product and engineering use case.

    What is the difference between a formula and a simulation?

    A formula usually calculates a result directly from defined variables. A simulation models behavior over conditions or time and may involve more complex numerical methods, larger data sets and longer execution times.

    Can sales representatives use engineering calculations?

    Yes, if the user interface exposes only the necessary inputs and the product model controls technical boundaries. Complex or safety-sensitive results may still require a sales engineer or engineering approval.

    How does CAD automation use calculated values?

    CAD automation can map calculated dimensions, selected options and component choices into parametric templates. It may then generate a 3D model, 2D drawing, installation layout or other product-specific output.

    What happens when a configuration is outside the calculation model?

    The system should identify the condition clearly and route it to engineering review, reject it as unsupported or initiate an ETO workflow. It should not silently produce a standard quote for an unvalidated design.

    How do calculations affect pricing?

    Calculations can determine required materials, components, capacity or processing, which then influence cost and price. The calculation engine determines technical requirements; the pricing engine applies commercial rates, margins, discounts and approvals.

    Can an engineering calculation be stored with the quote?

    A well-designed system should preserve inputs, outputs, assumptions, rule or formula versions and review status with the configuration or quote. This supports auditability and later reproduction of the result.

    What data is needed for a reliable engineering calculation?

    Typical data includes requirements, units, material properties, component ratings, performance curves, environmental conditions, safety factors and defined operating limits. The data must also be versioned and maintained.

    When should a simulation run synchronously?

    Synchronous execution is suitable when the calculation is fast and stable enough to provide immediate feedback. More demanding analyses are usually better handled asynchronously or after an initial configuration.

    How does CPQ support engineer-to-order products?

    CPQ can capture requirements, perform preliminary calculations, generate a preliminary structure and create an engineering request. Engineering then resolves non-standard design work before final approval and production release.

    What is the role of PLM in calculation-driven CPQ?

    Product lifecycle management (PLM) may provide controlled product definitions, revisions, materials, approved components and engineering change information. CPQ can use that data while managing the customer-specific configuration and quote workflow.

    How should calculation rules be tested?

    Testing should include normal cases, boundary values, invalid inputs, missing data, unit conversions, product revisions, integration failures and independently verified engineering examples. Results should be reviewed by qualified subject-matter experts.

    Can a CPQ calculation replace engineering approval?

    Not automatically. It can reduce repetitive work and validate standard configurations, but regulated, safety-critical, novel or out-of-range designs may still require formal engineering verification and approval.

    What should buyers ask CPQ vendors about engineering calculations?

    Ask whether formulas, constraints, external services, simulation jobs, CAD parameters, BOM logic, versioning, audit trails and approvals are supported natively or through customization and integrations. Request a demonstration using representative manufacturing data.

  • Geometric Constraints in Configurable Product Design

    Geometric constraints in configurable product design define the spatial and dimensional relationships that a product must satisfy when customers or sales engineers select options. They determine whether components fit, whether clearances are maintained, whether mounting patterns align and whether a configured product can be manufactured safely and correctly.

    In a manufacturing CPQ system, geometric constraints are more than CAD relationships. They form part of the engineering logic connecting a configurable product model to configuration validation, engineering calculations, computer-aided design (CAD) automation, bills of material (BOMs), pricing and the sales-to-engineering handoff. For example, a pump configurator may need to verify that the selected motor fits the baseplate, that the coupling guard clears the shaft and that the outlet orientation is compatible with the installation dimensions.

    A useful implementation treats geometry as structured product knowledge rather than as an isolated drawing problem. The CPQ configurator collects dimensions and options, evaluates rules and constraints, passes approved parameters to CAD or engineering services, and returns product-specific outputs such as a 3D model, drawing, configured BOM or manufacturing data. Not every CPQ platform provides this complete chain, so capability boundaries must be verified during software selection.

    What are geometric constraints?

    Geometric constraints are rules that control the shape, position, orientation, size or spatial relationship of features and components in a product design. They can be applied inside a CAD model, within a product configuration engine, in an engineering calculation service or across several of these systems.

    Typical geometric constraints include:

    • Dimensional constraints: a frame must be between 1,000 and 2,400 millimetres long, or a pipe diameter must match a selected connection standard.
    • Distance constraints: a motor must remain a minimum distance from a guard, wall or adjacent assembly.
    • Alignment constraints: bolt holes, shafts, rails or connectors must share a defined axis or pattern.
    • Orientation constraints: a valve, access panel or discharge nozzle must face a permitted direction.
    • Clearance constraints: moving or serviceable parts require sufficient space to operate or be removed.
    • Containment constraints: an electrical enclosure or component must fit within a cabinet, vehicle bay or machine frame.
    • Topology constraints: components must connect through permitted interfaces, such as a flange, mounting face or cable entry.
    • Motion constraints: doors, booms, actuators or linkages must move through a defined range without collision.

    These constraints are different from simple option compatibility rules. A rule stating that “stainless steel construction requires a particular material grade” is primarily a product or material rule. A rule stating that “the selected pump and motor require a baseplate longer than 1,200 millimetres” is a geometric and dimensional constraint. Manufacturing CPQ often needs both.

    Why geometric constraints matter in manufacturing CPQ

    Generic sales CPQ usually focuses on selecting products, applying pricing logic and generating a commercial quote. Manufacturing CPQ may perform those functions while also validating whether the selected product can be engineered and produced. Geometry becomes important when a configuration changes physical form, component placement, structural requirements or installation conditions.

    Without geometric validation, a quote may describe a product that cannot be assembled or used. Common consequences include:

    • components that interfere during assembly or operation;
    • mounting holes that do not align;
    • insufficient access for maintenance or tool clearance;
    • incorrect enclosure, cabinet or vehicle dimensions;
    • ducts, pipes or cables that cannot reach their connection points;
    • incorrect shaft, belt or coupling geometry;
    • drawings that do not reflect the selected options;
    • late engineering changes and manual redesign;
    • incorrect BOM quantities or component variants;
    • quotes that require unplanned engineering effort or cannot be fulfilled.

    A well-designed configuration process can reject invalid combinations, guide the user toward feasible dimensions or route a valid but unusual configuration to engineering review. The objective is not always to automate every design decision. It is to identify what can be validated reliably at the point of configuration and to make exceptions explicit.

    Types of geometric constraints in configurable products

    Dimensional and parametric constraints

    Parametric constraints express relationships between dimensions rather than storing every possible product size as a separate model. For example, the overall length of a conveyor may be calculated as the sum of standard sections, transfer zones and end allowances. A machine frame may have a width that depends on the number of lanes, the selected guarding arrangement and the required service aisle.

    A parametric model might contain relationships such as:

    frame_length = infeed_length + process_length + discharge_length
minimum_guard_clearance = shaft_diameter + safety_allowance
baseplate_length >= motor_length + coupling_length + service_allowance

    The exact syntax depends on the CAD or rules platform. The important point is that the model captures engineering relationships and limits rather than relying on manual redrawing for every configuration.

    Clearance and interference constraints

    Clearance constraints protect physical separation between parts. They are particularly important for rotating machinery, moving assemblies, high-voltage equipment, access doors and products installed in restricted spaces.

    For example, a configurable agricultural machine may require a minimum gap between a wheel, guard and hydraulic line throughout the steering range. A material-handling system may need to confirm that a selected mast height does not interfere with an overhead structure. A control cabinet may need free space in front of components for wiring and service access.

    Clearance validation may be implemented as a simple numerical comparison, a bounding-box test, a spatial calculation or a full CAD interference check. Simple checks are easier to run during a fast web configuration. Detailed collision detection may require a CAD engine or engineering service and may be more appropriate after the initial configuration.

    Interface and mating constraints

    Interface constraints describe how components connect. They can cover flange standards, bolt-hole patterns, shaft diameters, connector locations, rail profiles, mounting faces and pipe connection points.

    In a pump package, the selected pump, motor, coupling and baseplate may each have defined interfaces. A valid configuration must ensure that the shaft arrangement, mounting holes and coupling dimensions are compatible. In an electrical enclosure, the enclosure, gland plate, cable entries and internal mounting rails must use compatible reference locations.

    Interface data is often more reusable than a complete product model. A component can expose connection types and reference geometry, allowing the configuration system to select compatible parts from a controlled library.

    Orientation and location constraints

    Orientation constraints control how a component is positioned relative to the product or installation. Examples include a valve installed with a permitted flow direction, a motor mounted horizontally or vertically, a service door placed on the accessible side and a hydraulic outlet rotated to one of several approved positions.

    Orientation may affect more than geometry. It can change the BOM, cable and pipe lengths, safety requirements, price and installation instructions. The configuration model should therefore treat orientation as a meaningful product parameter, not merely as a visual display setting.

    Motion and kinematic constraints

    Kinematic constraints govern movement. They are used for articulated arms, lift tables, vehicle bodies, access panels, conveyors, linkages and actuated mechanisms.

    A configurator may need to check the operating envelope of a boom, the travel range of an actuator or the rotation of a service door. A static model that fits at rest may still fail when the product moves. Where motion is safety-critical, a CPQ rule should not replace the required engineering analysis. It can perform preliminary screening and identify configurations that require a higher level of review.

    How geometric constraints fit into the product configuration architecture

    Geometric logic usually sits between the product model and the engineering or CAD automation layer. The product model defines available options, parameters and relationships. The constraint engine evaluates whether those selections are valid. A CAD or engineering service then uses approved parameters to generate product-specific outputs.

    A simplified data flow is:

    1. A user or sales engineer selects product options, dimensions and operating requirements in the CPQ configurator.
    2. The configuration engine applies option dependencies, exclusions and required selections.
    3. Geometric constraints check dimensions, interfaces, clearances, orientations and operating limits.
    4. Engineering calculations determine values such as capacity, motor size, wall thickness or structural requirements where applicable.
    5. The system identifies the appropriate components and creates a configurable BOM or passes structured data to an engineering system.
    6. CAD automation updates a parametric model, assembly, drawing or 3D visualization if the connected tools support it.
    7. Pricing and costing logic use the approved configuration and selected components to calculate the commercial result.
    8. The quote records the configuration, assumptions, warnings, approvals and generated documents.
    9. After order acceptance, the approved configuration is transferred to enterprise systems such as enterprise resource planning (ERP), product lifecycle management (PLM), product data management (PDM) or manufacturing execution systems (MES), depending on the architecture.

    These stages do not have to run in a single application. A CPQ platform may validate rules and create a quote while a separate CAD automation service generates drawings. Another implementation may use a product configurator embedded in a CAD environment. The integration contract should define which system owns each parameter, rule, document and revision.

    Geometric constraints and CAD automation

    CAD automation uses configuration data to create or modify engineering models and documents. It may update dimensions in a parametric part, suppress or activate components, select standard parts, position assemblies, generate drawings or produce a neutral 3D file.

    Geometric constraints support CAD automation in several ways:

    • they provide limits for input parameters;
    • they determine which component variants can be inserted;
    • they define mating references and assembly positions;
    • they control feature suppression or inclusion;
    • they trigger warnings when a model exceeds validated conditions;
    • they provide calculated dimensions for drawings and documentation.

    For example, a configurable pump skid may use a base frame template with variable length, motor position and pipe connection orientation. The CPQ configuration supplies the selected pump, motor, coupling and connection parameters. The CAD automation process positions the components using defined references, checks known clearances and generates a layout drawing. The resulting geometry should still be reviewed according to the manufacturer’s engineering controls, especially when the configuration is outside the range of tested templates.

    More detail on this relationship is covered in the guide to CAD automation and engineering automation.

    Relationship to product rules and configuration constraints

    Geometric constraints are one category within a broader constraint model. A manufacturing product configurator commonly combines several rule types.

    Rule or constraint type Purpose Industrial example
    Option compatibility Prevents incompatible selections A particular controller is unavailable with an obsolete drive package
    Attribute dependency Sets or limits one value based on another Higher flow requires a larger pipe diameter
    Geometric constraint Controls physical dimensions and relationships The motor and coupling must fit within the base frame
    Engineering calculation Derives a technical result Calculate required motor power from load and speed
    Manufacturing rule Controls production feasibility A sheet-metal bend requires a minimum flange width
    Commercial rule Controls price, cost or approval Non-standard dimensions require an engineering surcharge
    Workflow rule Routes exceptions or approvals Configurations outside a validated envelope require engineering review

    Rules-based configuration often evaluates explicit conditions such as “if option A is selected, require option B.” Constraint-based configuration can represent a larger set of variables and relationships, allowing the system to find or validate solutions subject to limits. Guided selling presents questions in a user-friendly sequence and may conceal technical complexity from the salesperson. These approaches can be combined, but they are not interchangeable.

    See the guide to product configuration, product models and configuration rules for the wider configuration model.

    Practical manufacturing examples

    Configurable industrial pump package

    A pump package may vary by flow rate, pressure, fluid, temperature, motor rating, baseplate, coupling, seal, pipe size and discharge orientation. Geometric constraints can verify that:

    • the selected motor fits the baseplate and aligns with the pump shaft;
    • the coupling guard covers the rotating assembly without interference;
    • the chosen pipe connections are located within the skid envelope;
    • maintenance access remains available around the seal and motor;
    • the frame length supports the selected components;
    • the selected orientation does not conflict with installation access.

    The result may be a validated configuration, a configurable BOM, a price and a CAD layout. A non-standard skid length may be allowed but routed to an engineer rather than rejected automatically.

    HVAC air-handling unit

    An air-handling unit may be configured with fan sections, filters, coils, dampers, access doors and controls. Geometric constraints can govern section order, casing width, service-side access, coil face velocity limits and connection locations. If a customer selects a deep filter bank and a narrow casing, the configuration should identify the conflict before a quote is issued.

    The same parameters can influence pricing, material quantities, shipping dimensions, installation documentation and the generated drawing. The system should distinguish a physical impossibility from a commercial or logistics warning.

    Specialty vehicle body

    A specialty vehicle may combine chassis options, wheelbase, body length, storage modules, lifting equipment and access doors. Constraints may include axle load distribution, body envelope, wheel clearance, door swing and equipment mounting points. A visual configurator can help users understand the result, but visual placement alone does not prove compliance with structural, regulatory or safety requirements.

    Geometric constraints and BOM generation

    A bill of material (BOM) lists the components, assemblies, quantities and sometimes manufacturing information required to build a product. A geometric constraint does not automatically create a BOM, but it can determine which BOM items and variants are valid.

    It is important to distinguish:

    • Configurable BOM: a rules-driven structure containing alternatives, quantities or conditions that are resolved for a particular configuration.
    • Engineering BOM (EBOM): the engineering view of product structure, typically representing design assemblies and components.
    • Manufacturing BOM (MBOM): the manufacturing view, organized for production, work instructions, processes and assembly operations.

    For example, selecting a longer conveyor may require additional frame sections, supports, guards, cable and fasteners. The geometric model may calculate the number and placement of sections, while the product model resolves the correct part numbers. The resulting EBOM may then be transformed or synchronized with an MBOM in a PLM or ERP process.

    More information is available in the guide to BOM generation, costing, pricing and quote automation.

    Geometric constraints in the sales-to-engineering handoff

    The handoff from sales to engineering is a major reason manufacturers implement CPQ. A useful handoff should transfer more than a product name and total price. It should include the selected values, calculated dimensions, constraint results, assumptions, warnings, approvals, revision and generated files.

    A configuration record might contain:

    • product model and version;
    • customer and project identifiers;
    • selected options and parameter values;
    • units and dimensional tolerances;
    • calculated engineering values;
    • validated geometric relationships;
    • unresolved exceptions and engineering notes;
    • component identifiers and quantities;
    • CAD model, drawing or visualization references;
    • price, cost and approval status.

    This information reduces re-entry and makes it easier for engineering to understand what was promised. It does not eliminate the need for engineering review in engineer-to-order (ETO) work. Instead, it separates repeatable, validated configuration from genuinely new design work.

    In configure-to-order (CTO), the product is assembled from a controlled set of pre-engineered options. Geometric constraints can often be evaluated automatically within a defined envelope. In ETO, the constraints may identify a starting point and screen obvious conflicts, while engineers complete detailed design. Make-to-order (MTO) and assemble-to-order (ATO) processes may use similar logic, depending on how much design variation is permitted.

    See manufacturing workflows for CTO, ETO, MTO and ATO for the broader process context.

    Data requirements for implementing geometric constraints

    Successful implementation depends on reliable engineering data. A constraint engine cannot compensate for undefined interfaces, inconsistent units or undocumented design exceptions.

    Product and component data

    Each configurable component should have a stable identifier, revision, dimensions, interface definitions, allowable orientations and applicable operating limits. Standard parts should be separated from engineered variants where possible.

    Reference geometry

    CAD models need consistent reference planes, axes, mounting faces, connection points and coordinate systems. If every model uses different origins or naming conventions, automated assembly placement becomes fragile.

    Units, tolerances and assumptions

    Dimensions should use explicit units and, where necessary, tolerances. A clearance of 5 millimetres may have a different meaning from a nominal dimension of 5 millimetres with an allowable tolerance range. The system should also record assumptions such as standard installation orientation or service-access direction.

    Constraint ownership

    Each rule should have an owner and a review process. Product engineering may own interface constraints, manufacturing engineering may own process limits, commercial teams may own pricing rules and IT may own integration behavior. Shared ownership without clear responsibility leads to conflicting changes.

    Validation strategy and implementation considerations

    Manufacturers should not attempt to encode every engineering decision at once. A staged approach is usually more maintainable.

    1. Document the configuration envelope. Identify the products and variants that can be sold without bespoke design.
    2. List high-value failure modes. Start with errors that cause rework, safety concerns, late engineering intervention or unusable quotes.
    3. Classify constraints. Separate hard prohibitions, soft warnings, calculated values and approval triggers.
    4. Normalize engineering data. Standardize units, identifiers, interfaces, revisions and parameter names.
    5. Build test cases. Include valid boundaries, invalid combinations, unusual but valid configurations and intentionally ambiguous cases.
    6. Connect outputs gradually. Validate the configuration and BOM before automating complex CAD or manufacturing documents.
    7. Establish release governance. A change to a dimension, interface or component revision can affect rules, CAD templates, prices and downstream systems.

    Testing should include boundary values. For example, test a frame at the minimum and maximum validated length, a motor exactly at the allowable clearance and a door at the limit of its motion envelope. Test changes over time as well as individual configurations. A rule that worked for one product revision may become invalid after a component or CAD template changes.

    Integration architecture also matters. ERP, CRM, PLM, PDM, product information management (PIM), MES and CAD systems have different responsibilities. Customer and opportunity information may originate in a CRM system. Product revisions and engineering structures may be controlled in PLM or PDM. Orders, inventory and production planning may be managed in ERP. A CPQ application should not become an uncontrolled duplicate of all these data sources.

    Review the guide to CPQ integrations with ERP, CRM, PLM, PDM and CAD and the guide to CPQ implementation, testing and governance when defining the architecture.

    Limitations and risks

    Geometric constraints improve consistency, but they have important limits.

    • They depend on model quality. Incorrect dimensions, missing interfaces or obsolete CAD references produce incorrect results.
    • They may simplify real-world conditions. Bounding-box checks may not capture flexible hoses, tolerance stack-ups, thermal expansion or installation variability.
    • They can become difficult to maintain. A large network of exceptions and cross-product dependencies may be harder to manage than the original manual process.
    • They do not replace engineering judgment. Structural analysis, regulatory review, safety assessment and detailed tolerance analysis may require specialist tools and human approval.
    • They can create false confidence. A green validation status only means that the encoded checks passed; it does not prove every aspect of product suitability.
    • They may affect response time. Detailed CAD regeneration or collision analysis can be unsuitable for an interactive sales session unless it is optimized or performed asynchronously.
    • They require version control. Rules, product data, CAD templates and component revisions must be coordinated.

    A practical system should communicate the scope of validation. Messages such as “within the standard configurator envelope” or “requires engineering review” are more accurate than an unconditional claim that a product is fully engineered.

    How to evaluate CPQ support for geometric constraints

    When evaluating a CPQ configurator for manufacturing, ask specific questions rather than accepting a general claim about “3D configuration” or “engineering automation.”

    Evaluation area Questions to verify
    Constraint engine Can the system express dimensional, interface, clearance and conditional rules? Can it distinguish errors, warnings and approvals?
    Product model Can engineering teams maintain parameters, dependencies, revisions and reusable component definitions?
    CAD integration Does the platform connect to the required CAD tools or automation services? What outputs are generated and under what conditions?
    Performance Can common checks run interactively, and can complex calculations run asynchronously?
    BOM behavior Can geometric selections resolve component variants, quantities and configurable structures?
    Traceability Are the rule version, input values, validation results and generated files retained with the quote?
    Engineering workflow Can non-standard configurations be routed to engineering with complete context?
    Governance Are there testing, approval, simulation and release controls for changes to rules and models?

    Some platforms provide only guided selling, option compatibility and pricing. Others add product configuration, BOM generation, visualization, engineering calculations or CAD automation. These are separate capability areas and should be verified through demonstrations using representative manufacturing products and edge cases.

    Semantic map

    The following relationships summarize how geometric constraints connect configuration, engineering and manufacturing outputs:

    • CPQ configurator → evaluates → geometric constraints
    • Geometric constraints → validate → dimensions and spatial relationships
    • Configuration rules → prevent → invalid product combinations
    • Product parameters → drive → parametric CAD models
    • CAD automation → generates → product-specific drawings
    • Configured product → resolves → configurable BOM
    • Geometric validation → identifies → clearance and interference risks
    • Interface definitions → control → component compatibility
    • Engineering calculations → determine → derived design values
    • CPQ → exchanges data with → ERP
    • CPQ configuration → supports → sales-to-engineering handoff
    • Engineering exceptions → trigger → approval workflow
    • PLM and PDM → manage → product revisions and engineering data
    • Manufacturing BOM → supports → production planning and assembly
    • Validated configuration → informs → pricing and quote generation

    Frequently asked questions

    What are geometric constraints in product design?

    They are rules that control dimensions, positions, orientations, interfaces, clearances and movement in a product design. In manufacturing CPQ, they help determine whether a selected product configuration is physically feasible.

    Are geometric constraints the same as configuration rules?

    No. Geometric constraints are a specialized type of configuration constraint focused on physical relationships. Configuration rules also include option compatibility, material rules, pricing conditions, manufacturing limits and workflow requirements.

    Why do geometric constraints matter in a CPQ configurator?

    They help prevent quotes for products whose components do not fit, align, move or remain serviceable. This reduces avoidable engineering rework and improves the quality of the sales-to-engineering handoff.

    Can geometric constraints calculate product dimensions?

    Yes. Parametric relationships can calculate dimensions such as frame length, enclosure width or pipe routing allowances. The calculations must be based on validated engineering models and defined limits.

    Can a CPQ system perform CAD interference checking?

    Some manufacturing CPQ architectures support interference checking through native functionality or a connected CAD and engineering service. Others only perform simpler rules-based checks, so this capability must be verified for each platform.

    Do geometric constraints automatically generate CAD drawings?

    No. Constraints can provide inputs to CAD automation, but drawing generation requires a connected CAD system, automation service or platform capability designed for that purpose.

    How do geometric constraints affect a BOM?

    They can determine which component variants, quantities or assemblies are valid for a selected configuration. A separate BOM-generation function is still required to create the resolved engineering or manufacturing structure.

    What is an example of a geometric constraint in a pump configuration?

    A selected motor must fit the baseplate, align with the pump shaft and leave enough space for the coupling guard and maintenance access. If those conditions are not met, the configuration should be rejected or routed for review.

    What is the difference between clearance and interference?

    Clearance is the required separation between objects. Interference occurs when objects occupy the same physical space or violate a required minimum separation.

    How are geometric constraints used in configure-to-order?

    In configure-to-order, they validate combinations within a predefined engineering envelope. This allows standard products to be configured without creating a new design for every order.

    How are they used in engineer-to-order?

    They can screen obvious conflicts, calculate starting dimensions and define an engineering baseline. Configurations outside the validated envelope generally require engineering design and approval.

    What data is required to implement geometric constraints?

    Typical requirements include component dimensions, interface definitions, coordinate systems, allowable orientations, clearance limits, units, tolerances, product revisions and ownership of each rule.

    Should geometric constraints be stored in CAD or CPQ?

    It depends on the rule. Detailed model relationships may belong in CAD, while sales-facing configuration limits and option dependencies may belong in CPQ. Shared rules require controlled synchronization and clear system ownership.

    Can geometric constraints include manufacturing limitations?

    Yes. Examples include minimum bend radii, machining limits, weld access, tool clearance and standard material sizes. These may be implemented as manufacturing rules in addition to geometric checks.

    Do geometric constraints account for tolerances?

    They can, if the model includes tolerance ranges and the validation logic is designed for them. Simple nominal checks may not reveal tolerance stack-up or installation variation.

    Can 3D visualization prove that a configuration is valid?

    No. Visualization helps users understand the selected product and may reveal obvious spatial issues, but it is not a substitute for validated rules, engineering calculations or formal review.

    How should non-standard geometry be handled?

    The system should identify it clearly and route it to an engineering approval process with the selected parameters, constraint results, assumptions and related documents.

    What should manufacturers test before deploying geometric constraints?

    Test valid configurations, invalid combinations, minimum and maximum dimensions, boundary clearances, component revisions, unusual but permitted options and configurations that require engineering approval.

    How do geometric constraints affect pricing?

    They can change the selected components, material quantities, product dimensions, engineering effort, shipping dimensions and approval requirements. Pricing logic should use the validated configuration rather than independently recreating geometry assumptions.

    What is the most common implementation mistake?

    A common mistake is encoding rules before standardizing product data and deciding which system owns dimensions, interfaces, revisions and engineering calculations. Poor source data makes the constraint model difficult to trust and maintain.

    Geometric constraints are therefore a bridge between product configuration and engineering automation. When they are based on controlled product data, tested against real manufacturing cases and connected to the appropriate CAD, BOM and enterprise systems, they can make a CPQ process substantially more reliable. Their value comes not from creating an appearance of automation, but from enforcing the specific engineering relationships that determine whether a configured product can be quoted, designed, built and supported.

  • Engineering Calculations Inside a Product Configurator

    Engineering calculations inside a manufacturing product configurator turn customer requirements into technically valid product definitions. Instead of allowing a salesperson to select isolated options, the configurator can calculate dimensions, capacities, loads, material quantities, motor sizes, electrical ratings or other engineering values and use the results to select compatible components.

    In manufacturing CPQ, CPQ means configure, price, quote. A calculation-enabled CPQ system can connect product configuration rules with engineering formulas, pricing, bills of material (BOMs), computer-aided design (CAD) outputs and downstream enterprise systems. For example, a pump configurator might use flow rate, pressure, fluid properties and operating temperature to recommend a pump size, impeller diameter, motor rating and material combination. The result can then drive a quote, a configurable BOM, a CAD model or an engineering review.

    Not every CPQ platform supports engineering calculations. Some systems provide only guided selling, option rules and pricing. Others include a rules engine, calculation service, CAD automation or integration with external engineering applications. Buyers should therefore verify exactly where calculations run, which variables they support, how results are tested and whether the outputs are suitable for production.

    What are engineering calculations in a product configurator?

    Engineering calculations in a product configurator are formulas, algorithms and decision rules that derive technical product values from customer inputs, selected options, operating conditions and manufacturing constraints.

    These calculations may produce:

    • required dimensions such as length, width, height, diameter or wall thickness;
    • performance values such as flow, pressure, capacity, speed, torque or heat transfer;
    • component selections such as motors, pumps, valves, drives, bearings or structural members;
    • material quantities, weights, surface areas and cutting lengths;
    • electrical values such as voltage, current, breaker size or cable requirements;
    • manufacturing parameters used in a BOM, routing, drawing or CAD model;
    • cost, price, margin or surcharge inputs derived from the technical result.

    The calculation is part of a wider product model. The model defines features, options, parameters, dependencies, constraints, formulas, component relationships and outputs. A calculation should not be treated as an isolated spreadsheet copied into a sales tool. It should be governed as engineering logic with known inputs, units, assumptions, valid ranges, revision control and test cases.

    See the guide to product configuration and configuration rules for the relationship between product models, options, dependencies and validation.

    Why engineering calculations matter in manufacturing CPQ

    Generic sales CPQ often focuses on selecting commercial options, applying discounts and generating a proposal. Manufacturing CPQ may need to establish whether a product can be built and what its technical definition should be before a quote is released.

    Without embedded or connected calculations, the sales process commonly depends on manual engineering work. An application engineer may review a spreadsheet, resize a component, update a drawing, create a BOM and return a price. This can be appropriate for genuinely novel designs, but it creates delays and increases the risk of inconsistent assumptions for repeatable product families.

    A calculation-enabled configurator can automate the repeatable portion of that work. It can reject impossible combinations, recommend a valid design envelope, identify when a standard component is insufficient and route exceptional cases to engineering. The objective is not to remove engineering judgment. It is to apply approved engineering knowledge consistently and reserve expert time for cases that actually require review.

    Manufacturing problem Role of a calculation-enabled configurator
    Sales selects a motor that cannot meet the load Calculates required torque or power and restricts motor choices to valid ranges
    A frame is too small for the specified span Calculates dimensions or structural requirements and identifies a compatible frame family
    Material quantity changes with product dimensions Calculates quantity, weight and cost drivers for the configured design
    Each quote requires a new drawing Passes calculated parameters to CAD automation where supported
    Engineering receives incomplete order information Transfers validated parameters, selections, BOM data and assumptions with the handoff

    How calculations fit into the configurator architecture

    A typical architecture separates the user interface, product model, rules engine, calculation logic, output generation and connected business systems. The exact design varies by platform, but the following flow is common:

    1. Requirement capture: The user enters customer requirements such as capacity, dimensions, environment, voltage, material or duty cycle.
    2. Configuration validation: Rules check required fields, incompatible options, ranges and dependencies.
    3. Calculation: Formulas or engineering services derive technical values from the validated inputs.
    4. Component selection: The system selects or filters compatible components, variants and product families.
    5. Output generation: The configurator produces price, cost, BOM, specifications, drawings, CAD parameters or review data, depending on its capabilities.
    6. System integration: Relevant data is sent to enterprise systems such as customer relationship management (CRM), enterprise resource planning (ERP), product lifecycle management (PLM), product data management (PDM) or manufacturing execution systems (MES).

    The calculation layer may be embedded in the CPQ platform, implemented as a rules service, connected to an external engineering application or distributed across several systems. The important requirement is a clear source of truth. If a motor-selection formula exists separately in a spreadsheet, CAD macro and ERP customization, the organization must define which result controls the quote and order.

    Inputs, formulas and outputs

    Every calculation should document three basic elements:

    • Inputs: values entered by the user, inherited from the product model, retrieved from a component database or supplied by another system;
    • logic: formulas, lookup tables, constraints, standards, coefficients and exception conditions;
    • outputs: calculated values, selected components, warnings, errors, cost drivers, BOM attributes or engineering deliverables.

    Units and conversions require particular care. A calculation involving pressure, flow, torque or temperature can produce a dangerous result if the system silently mixes units. The data model should store units explicitly, define accepted input units and convert values in a controlled calculation layer.

    Examples of engineering calculations

    Pump and fluid equipment configuration

    A pump configurator may capture required flow rate, differential pressure, fluid temperature, viscosity, corrosion requirements and available electrical supply. It can use these values to calculate a duty point, estimate hydraulic power and filter pump families. Additional rules may select impeller size, motor rating, seal material, casing material and connection type.

    The result is not necessarily a final engineering certification. A configurator may use approved selection curves or lookup tables, while a specialist engineer may still need to verify cavitation margin, transient conditions, applicable standards or unusual fluid behavior. The system should make this boundary visible.

    Industrial machinery and conveyor sizing

    For a conveyor or material-handling machine, inputs may include product weight, throughput, belt speed, incline, conveyor length and operating environment. Calculations can estimate drive power, belt tension, roller spacing, frame dimensions and motor requirements. The outputs can drive a component selection, a configurable BOM and parameters for a 3D model.

    Rules may also identify conditions that require review. For example, a standard frame may be available up to a specified span, while a longer span triggers a reinforced frame, additional supports or an engineer-to-order workflow.

    HVAC and thermal equipment

    An HVAC configurator may calculate heating or cooling capacity from airflow, entering and leaving temperatures, ambient conditions and application requirements. It can use the result to select a coil, fan, heat exchanger, enclosure, motor and control package. Material and environmental inputs may affect corrosion protection, insulation and enclosure ratings.

    These calculations must be based on approved engineering methods and clearly defined assumptions. A simple capacity estimate may support preliminary selection, while final equipment performance may require detailed simulation, certification or a specialist review.

    Electrical equipment

    For an electrical panel or power distribution assembly, the configurator may calculate current demand from selected loads, apply diversity factors, select protective devices and determine enclosure size. It may also validate voltage, phase, short-circuit rating, wiring space and thermal constraints.

    Electrical calculations often involve standards, regional requirements and installation conditions. The configurator should identify the governing standard and revision where relevant, rather than presenting a calculated result without context.

    Specialty vehicles and mobile equipment

    A vehicle configurator may calculate payload, axle loading, center-of-gravity limits, battery capacity, range estimates or hydraulic requirements. A selected body, lift or attachment can change the permissible payload and structural requirements. The system may therefore need sequencing rules: calculate the base vehicle first, apply the attachment, recalculate the combined configuration and then validate the result.

    Rules, constraints and calculations are different

    These concepts work together but should not be treated as interchangeable.

    Concept Purpose Example
    Guided selling Asks questions to recommend a product or option Recommend a pump family based on application type
    Rules-based configuration Defines if-then relationships and allowed choices If the enclosure is outdoor-rated, require a suitable coating
    Constraint-based configuration Finds or validates combinations that satisfy multiple constraints Select a motor and gearbox that meet torque, speed and space limits
    Engineering calculation Derives a value from inputs and formulas Calculate required shaft torque from load and radius
    Pricing logic Converts selections and calculated drivers into cost or price Apply a material surcharge based on calculated weight

    A mature product model may use all five. A guided question captures the application, configuration rules validate selections, calculations derive technical values, constraint logic identifies feasible components and pricing logic converts the result into a commercial offer.

    From calculation to BOM, CAD and quote

    Configurable BOM, EBOM and MBOM

    A bill of material (BOM) lists the components required for a product. A configurable BOM contains conditional or variable items that depend on the selected configuration.

    An engineering BOM (EBOM) represents the product from an engineering and design perspective. A manufacturing BOM (MBOM) represents how the product is assembled and produced, including manufacturing-specific structure, operations or consumables where applicable. A CPQ-generated BOM may be an intermediate or sales-order structure rather than a complete production MBOM.

    For example, a calculated enclosure size may determine the enclosure part number, mounting plate, cable length and hardware quantity. The system should distinguish between a calculated attribute, a sellable item, a manufactured part and a reference value. Sending all of these as undifferentiated lines to an ERP can create planning and costing problems.

    Read more about BOM generation, costing, pricing and quote automation.

    CAD and 3D outputs

    Where CAD automation is supported, calculated dimensions and selected components can become parameters for a 2D drawing, 3D model or visualization. A configurator may pass values to parametric CAD, select pre-engineered models or invoke a design automation service.

    The CAD output should have defined status and purpose. A lightweight 3D model for sales visualization is not the same as a manufacturing drawing with tolerances, material specifications and revision control. A generated model may also require engineering approval before release.

    CAD automation is covered in the CAD and engineering automation guide.

    Pricing and quoting

    Technical results often affect commercial results. Calculated weight may affect material cost and freight. Motor size may determine a purchased component cost. A larger frame may trigger labor, tooling or manufacturing surcharges. However, engineering calculations and pricing calculations should remain conceptually separate.

    The calculation layer should produce approved technical drivers, while the pricing engine applies commercial rules such as currency, quantity breaks, discounts, markups and approval thresholds. Separating these concerns makes it easier to change a price policy without changing a safety-critical engineering formula.

    Sales-to-engineering data flow

    The main value of calculation-enabled CPQ is often the quality of the handoff. A completed configuration should communicate more than a product name and total price.

    A useful handoff can include:

    • the customer requirements and original input values;
    • the selected options and calculated parameters;
    • assumptions, units and applicable standards;
    • validation messages, warnings and unresolved exceptions;
    • the selected components and configurable BOM;
    • CAD references or generated files where approved;
    • cost and price inputs without exposing inappropriate commercial data;
    • revision, author, timestamp and product-model version.

    This information may move through an opportunity in a CRM system, an order or item structure in an ERP system, a product record in a PLM or PDM system, or an API between applications. CRM manages customer and sales context; ERP manages transactions, inventory, planning and financial data; PLM manages product lifecycle information; PDM commonly manages engineering files and revisions; CAD creates design representations; MES manages execution on the shop floor. These systems are related but not interchangeable.

    See CPQ integration patterns for guidance on connecting these systems.

    When calculations should trigger review or ETO

    Configure-to-order (CTO) uses predefined options and rules to produce a valid product. Engineer-to-order (ETO) requires engineering work to create or adapt the design. Make-to-order (MTO) means production starts in response to an order, while assemble-to-order (ATO) assembles stocked or predefined modules after the order.

    A calculation-enabled configurator can support CTO and identify the boundary between standard and engineered work. Examples of review triggers include:

    • a calculated value outside the validated range;
    • a component combination not represented in the approved product model;
    • an unusual material, temperature or environmental condition;
    • a load, pressure, voltage or safety value requiring certification;
    • a dimension that cannot be manufactured using standard tooling;
    • a conflict between customer requirements and available capacity;
    • a need for a new CAD design or design revision.

    In these cases, the system should create an explicit engineering task rather than silently accepting an unverified result. The workflow may continue as ETO, or the product team may add the new case to the standard model in a later release. See manufacturing workflows for CTO, ETO, MTO and ATO.

    Implementation approach

    1. Select repeatable calculation candidates

    Start with calculations that are common, well understood and based on stable engineering methods. Do not begin with the most complex bespoke design problem. A good first candidate may be motor sizing, enclosure selection, material quantity or a standard frame calculation.

    2. Define ownership and source data

    Identify who owns formulas, lookup tables, component ratings, material properties and standards. Determine whether product data comes from PLM, PDM, ERP, a component database or the CPQ product model. Avoid copying uncontrolled spreadsheets into production logic.

    3. Model inputs and units explicitly

    Define required, optional and derived values. Record units, valid ranges, precision, default assumptions and allowable conversions. Decide how missing, uncertain or approximate customer inputs are represented.

    4. Separate validation from recommendation

    A recommendation may suggest a motor or product family. Validation must establish whether the resulting configuration is allowed. The user interface should distinguish a recommendation, a warning, a blocking error and an engineering-review condition.

    5. Define output contracts

    Document what the calculation returns and how each result is used. For example, a calculated shaft diameter may be a design attribute, a CAD parameter, a BOM selection criterion and a quote explanation. Each downstream consumer should receive a stable data structure and version.

    6. Test with engineering reference cases

    Test normal, boundary, invalid and exceptional cases. Compare results against approved calculations, engineering software or controlled reference examples. Test unit conversions, rounding, missing values, rule sequencing and changes to component data.

    7. Govern revisions

    A formula change can alter a quote, BOM, drawing or production result. Record effective dates, approvers, model versions and affected products. Decide whether existing quotes and orders retain their original calculation version.

    The CPQ implementation guide provides broader guidance on requirements, testing, deployment, governance and maintenance.

    Limitations and risks

    Engineering calculations do not automatically make a configurator an engineering authority. Important limitations include:

    • Incomplete inputs: Customer requirements may be approximate or misunderstood.
    • Model boundaries: A formula may be valid only within a defined operating range.
    • Data quality: Incorrect component ratings, material properties or revisions produce incorrect results.
    • Standards and certification: A calculated selection may still require formal compliance verification.
    • Complex physical behavior: Simulation, finite element analysis or specialist analysis may be necessary for novel designs.
    • Integration failures: A stale or partial transfer to ERP, PLM, CAD or MES can break the handoff.
    • Maintenance burden: Product changes, supplier substitutions and manufacturing changes require model updates.
    • False confidence: A precise-looking number is not reliable if assumptions and uncertainty are hidden.

    The configurator should expose assumptions and route cases outside its validated domain to qualified engineers. It should not present an automated estimate as a certified design unless the organization has established that approval process.

    How to evaluate a CPQ configurator for engineering calculations

    During vendor evaluation, ask practical questions rather than relying on a general claim that the platform supports engineering. Verify whether it can:

    • represent variables, formulas, lookup tables and conditional logic;
    • handle units, ranges, precision and rounding;
    • sequence calculations when one result becomes another input;
    • separate warnings, blocking errors and review conditions;
    • version formulas and product models;
    • expose calculations through an application programming interface (API);
    • generate or exchange configurable BOM data;
    • pass parameters to CAD or design automation tools;
    • retain calculation inputs and outputs with the quote or order;
    • support testing, audit trails, approvals and rollback;
    • integrate with ERP, PLM, PDM, CRM and other relevant systems;
    • support both standard CTO products and exceptions requiring ETO.

    Require a demonstration using a representative product family, such as a pump, machine frame, electrical enclosure or configured vehicle. Ask the vendor to show the underlying model, not only the final screen. Confirm which capabilities are native, which require customization and which depend on third-party engineering or CAD software.

    Semantic map

    The article connects engineering calculations with product configuration, rules, CAD automation, BOM generation, pricing, enterprise integration and manufacturing workflows. The main relationships are:

    • Customer requirements feed configuration inputs.
    • Configuration rules prevent invalid combinations.
    • Engineering calculations derive technical values.
    • Calculated values influence component selection and BOM structure.
    • CAD automation can use calculated parameters to generate models and drawings.
    • Technical results provide controlled inputs to costing and pricing.
    • Validated configurations improve the sales-to-engineering handoff.
    • Out-of-range results trigger engineering review or ETO.
    • ERP, PLM, PDM, CRM, CAD and MES consume different parts of the configured product data.

    Frequently asked questions

    What are engineering calculations in CPQ?

    They are formulas, lookup tables and algorithms that derive technical values or component selections from customer requirements and configuration inputs. In manufacturing CPQ, they can support sizing, validation, BOM generation, CAD parameters and pricing inputs.

    Does every CPQ system support engineering calculations?

    No. Some CPQ systems focus on guided selling, option rules, pricing and quoting. Calculation, CAD automation and engineering integration may require a specialized manufacturing platform, customization or an external engineering service.

    What is an example of a product configurator calculation?

    A pump configurator can calculate required hydraulic power from flow and pressure, then use that result to select a pump family, impeller, motor and material combination.

    How are calculations different from configuration rules?

    A rule validates or controls a relationship, such as requiring an outdoor-rated enclosure with a suitable coating. A calculation derives a value, such as enclosure size or motor power, from one or more inputs.

    Can a configurator calculate motor size?

    It can when the product model contains an approved motor-sizing method and the required inputs, such as load, speed, torque, duty cycle and operating conditions. The result may still require engineering review outside the validated range.

    Can engineering calculations generate a BOM?

    They can contribute to BOM generation by determining dimensions, quantities, variants and component selections. Whether the platform creates a production-ready BOM depends on its native capabilities and integration with ERP, PLM or manufacturing systems.

    What is the difference between a configurable BOM and an EBOM?

    A configurable BOM contains conditional items that vary with the selected product. An EBOM represents the engineering product structure. A CPQ output may support an EBOM but should not automatically be treated as a complete manufacturing BOM.

    Can calculated values drive CAD automation?

    Yes, where the CPQ and CAD architecture supports it. Calculated dimensions, selected components and parameters can be passed to parametric CAD or design automation tools to create product-specific models and drawings.

    Are CPQ calculations suitable for safety-critical products?

    They may support preliminary selection or controlled standard designs, but safety-critical use requires defined engineering ownership, validation, standards compliance, testing and approval. Automation should not bypass required professional review.

    What happens when a calculation produces an invalid result?

    The system should show a blocking error, warning or engineering-review condition according to the severity. It should not silently create a quote or order from an unverified design.

    How should units be handled in a configurator?

    Units should be explicit in the data model, with controlled input units and documented conversion rules. This is essential for pressure, flow, temperature, torque, dimensions, mass and electrical values.

    Can calculations affect product pricing?

    Yes. Calculated weight, material quantity, motor size, labor content or manufacturing complexity can provide inputs to costing and pricing. The technical calculation and commercial pricing logic should remain separately governed.

    How do calculations support configure-to-order?

    They help validate predefined product families and derive the correct standard components for a customer-specific configuration. Cases outside the approved design envelope should be routed to engineering-to-order.

    What systems exchange data with a calculation-enabled CPQ platform?

    Depending on the architecture, it may exchange data with CRM for sales context, ERP for orders and materials, PLM or PDM for product data, CAD for design outputs and MES for manufacturing execution. These systems have different responsibilities.

    Should calculations be stored in spreadsheets?

    Spreadsheets can support analysis and prototyping, but uncontrolled spreadsheet logic is risky as a production source of truth. Approved formulas should be governed, versioned, tested and exposed through the product model or a controlled calculation service.

    How should engineering calculations be tested?

    Use approved reference cases covering normal, boundary, invalid and exceptional conditions. Test units, rounding, rule sequencing, component revisions, missing inputs and integration outputs.

    What should a vendor demonstration include?

    Ask the vendor to configure a representative machine or equipment family, enter real engineering inputs, show calculations and validation, generate the relevant BOM or CAD output and demonstrate the engineering-review path.

  • Design Automation in Manufacturing CPQ

    Design automation in manufacturing CPQ is the use of product rules, engineering calculations and computer-aided design (CAD) automation to turn a valid customer configuration into product-specific engineering outputs. Depending on the platform and implementation, those outputs may include a three-dimensional model, two-dimensional drawings, design parameters, an engineering bill of materials (EBOM), a manufacturing bill of materials (MBOM), manufacturing instructions or data for enterprise systems.

    This is a major distinction between manufacturing CPQ and generic sales CPQ. A sales-oriented CPQ system may select options, calculate a price and generate a proposal. A manufacturing CPQ system can also determine whether the product can be built, calculate technical dimensions, select components, create a product structure and pass controlled data to engineering and production.

    For example, a pump manufacturer might use CPQ to capture flow rate, pressure, fluid type, temperature, motor voltage, materials and connection standards. Design automation can then apply selection rules, size the pump assembly, choose compatible components, generate a product-specific CAD configuration and produce a BOM for review or production. The result is a shorter and more reliable sales-to-engineering handoff, provided that the product model, engineering logic and CAD templates are maintained correctly.

    For broader context, see the guide to CPQ software for manufacturing and the detailed overview of CAD and engineering automation.

    What design automation means in manufacturing CPQ

    Design automation is the controlled generation or modification of engineering outputs from structured inputs. In a manufacturing CPQ process, the inputs usually include customer requirements, selected options, dimensions, operating conditions, material choices and commercial decisions. The automation layer evaluates those inputs and produces outputs that would otherwise require manual engineering work.

    Design automation does not necessarily mean that every product is designed from scratch. Most successful implementations use a reusable engineering model containing standard components, parameterized CAD templates, rules, calculations and approved variants. The system assembles or modifies those assets according to the selected configuration.

    Input Typical example Possible automated output
    Customer requirement Required airflow, lifting capacity or fluid pressure Validated technical range and selected product family
    Configuration option Motor type, enclosure, material or mounting arrangement Compatible components and product variant
    Calculated parameter Shaft diameter, vessel volume or heat-transfer area Engineering dimension or component selection
    Geometric parameter Length, width, hole spacing or frame height Updated CAD model and drawing dimensions
    Approved configuration Complete machine or assembly definition EBOM, quote, drawing package or ERP order data

    How design automation fits into the manufacturing CPQ architecture

    Design automation is usually one part of a larger CPQ architecture. It depends on a product model and configuration engine, but it also interacts with CAD, product lifecycle management (PLM), product data management (PDM), enterprise resource planning (ERP) and sometimes manufacturing execution systems (MES).

    1. Product model and configuration interface

    The product model defines the configurable structure of the product. It may contain families, features, options, dimensions, materials, accessories and component relationships. The configuration interface presents the relevant choices to a sales engineer, dealer, distributor or customer.

    A product model is not the same as a price list. It must represent technical relationships. For instance, a stainless-steel pump casing may be available only for certain fluid types and pressure classes. A high-voltage motor may require a particular control panel, cable specification and enclosure. These dependencies belong in the configuration model or in connected engineering logic.

    See product configuration, rules and constraint management for a deeper explanation of product models and validation.

    2. Rules and constraints engine

    The rules engine evaluates whether a proposed configuration is valid. Rules can include compatibility rules, exclusion rules, dependency rules, range limits, required selections and conditional defaults.

    • A 50 Hz motor may be required for a particular regional electrical standard.
    • A selected impeller diameter may require a larger casing or a different shaft.
    • A vehicle body length may restrict the available axle or suspension package.
    • A pressure rating may require a different valve body material and test procedure.
    • A lifting capacity above a defined threshold may require a larger frame and reinforced weldment.

    Rules-based configuration evaluates explicit product logic. Constraint-based configuration solves or validates relationships among variables and limits, such as dimensions, load, temperature, pressure or capacity. Guided selling is different: it recommends products or options based on customer needs, but it does not by itself prove that the resulting design is manufacturable.

    3. Engineering calculation service

    Engineering calculations convert requirements into technical values. Examples include pump selection, motor sizing, heat exchanger sizing, pressure-vessel calculations, structural checks, cable sizing and throughput calculations.

    Calculations may be implemented inside the CPQ platform, exposed through an engineering service, or connected to specialist calculation software. The important requirement is traceability. The organization should know which inputs were used, which calculation version was applied and whether the result was within the approved design envelope.

    4. CAD and visualization layer

    CAD automation uses configuration values to create or modify a parametric model. A parametric model is controlled by dimensions, features and relationships rather than being a collection of unrelated manually edited geometry.

    The output may be a three-dimensional model for review, a simplified model for a web configurator, a detailed model for engineering, or two-dimensional drawings with product-specific dimensions and annotations. Some implementations generate only visual representations, while others create native CAD files. These are materially different capabilities and should be verified during software evaluation.

    5. BOM and manufacturing data generation

    A configured product can generate a structured bill of materials (BOM), but the structure and purpose of the BOM must be defined. An EBOM is an engineering bill of materials that describes the designed product. An MBOM is a manufacturing bill of materials that reflects how the product is assembled and produced. A configurable BOM may contain rules, placeholders or selectable component relationships rather than one fixed list.

    Design automation may generate or update an EBOM directly. In other architectures, the CPQ system sends configuration data to PLM or ERP, where the approved EBOM or MBOM is created. The system of record should be explicit; otherwise, different departments may maintain conflicting product structures.

    The related guide to BOM generation, pricing and quoting explains how engineering structures connect to commercial and manufacturing outputs.

    Typical design automation workflow

    1. Capture requirements. A sales engineer or customer enters application, performance, dimensional and commercial requirements.
    2. Validate the product family. The CPQ model determines which product family and configuration path can satisfy the requirements.
    3. Apply configuration rules. The rules engine rejects incompatible choices, adds required components and identifies unresolved decisions.
    4. Run engineering calculations. The system calculates dimensions, capacities, ratings or other technical values within approved limits.
    5. Select or derive components. Standard parts, configurable components and engineered elements are assigned to the product structure.
    6. Generate engineering outputs. CAD models, drawings, specifications or visualization files are created or updated.
    7. Generate commercial outputs. Cost, price, lead time and proposal content are calculated from the validated configuration.
    8. Route exceptions. Configurations outside the standard design envelope are sent to an engineer for review rather than being silently accepted.
    9. Transfer controlled data. The approved configuration and relevant outputs are sent to CRM, ERP, PLM, PDM or MES according to the process design.
    10. Release and maintain. The configuration, rules, CAD references and related revisions are recorded for later order processing and support.

    Example: automated design of an industrial pump package

    Consider a manufacturer selling centrifugal pump packages for industrial water systems. The customer specifies flow, head, fluid temperature, material preference, motor voltage, connection standard, mounting arrangement and environmental conditions.

    The CPQ product model first checks whether the application falls within the supported product family. The rules engine may restrict materials based on temperature and fluid chemistry. An engineering calculation selects a suitable impeller diameter and motor rating. Additional rules determine whether a baseplate, coupling guard, seal package or control panel is required.

    Once the configuration is valid, a CAD template can update the pump skid length, nozzle position, motor footprint and baseplate hole pattern. A product-specific drawing may show the revised dimensions. The EBOM can include the pump, motor, coupling, guard, valves, instrumentation and fabricated base. A manufacturing process may transform that structure into an MBOM with fabrication, assembly and testing steps.

    Pricing is calculated separately but uses the same configuration facts. Material choices affect cost, while motor rating and accessories affect both cost and lead time. The proposal can include technical specifications and an image derived from the configured model. If the customer requests a flow and head combination outside the approved envelope, the system should create an engineering review rather than generate a falsely precise design.

    Design automation and the sales-to-engineering handoff

    Without automation, sales may send an email, spreadsheet or partially completed form to engineering. Engineers then interpret requirements, check compatibility, rebuild the product definition and prepare drawings or BOM data. This creates delays and introduces ambiguity about which revision, option or calculation was used.

    A manufacturing CPQ process can make the handoff structured. The sales record contains the validated configuration, calculated values, selected options, customer requirements, assumptions, exceptions and revision information. Engineering receives a defined starting point rather than a narrative request.

    This does not eliminate engineering involvement. Engineers still govern the design envelope, approve new rules, handle non-standard requests, review safety-critical applications and release controlled revisions. The goal is to move repeatable decisions into a governed model and reserve expert time for genuine engineering work.

    Design automation should therefore be evaluated together with configure-to-order, engineer-to-order and sales-to-engineering workflows.

    Relationship between CPQ, CAD, PLM, PDM and ERP

    System Primary responsibility Typical relationship with manufacturing CPQ
    CPQ Configuration, commercial logic and quote process Captures requirements, validates choices and coordinates outputs
    CAD Geometric product design Receives parameters or configuration selections and produces models or drawings
    PDM Control of CAD files, documents and revisions Stores or manages generated design files and their relationships
    PLM Product lifecycle, revisions, approvals and product structures Governs engineering data, EBOMs and release processes
    ERP Enterprise transactions, inventory, purchasing and production planning Receives order, item, BOM, price or production data
    MES Execution and tracking of manufacturing operations May receive production structures, routings or work instructions
    CRM Customer, opportunity and account management Provides the commercial context for the configuration and quote

    These systems are not interchangeable. A CPQ platform may calculate a configuration without owning the CAD file, and a CAD system may generate geometry without managing pricing or customer approvals. The integration architecture should define which system owns each object and how revisions are synchronized.

    See CPQ integrations with ERP, CRM, PLM, PDM and CAD for integration patterns and design considerations.

    Benefits of design automation in manufacturing CPQ

    • Faster engineering response: repeatable calculations and standard design variants can be produced without rebuilding them manually.
    • Fewer configuration errors: rules prevent or flag combinations that are technically incompatible.
    • More consistent quotes: technical assumptions, options, costs and lead times are based on the same configuration.
    • Better customer visualization: a configured three-dimensional image or drawing can make dimensions and options easier to review.
    • Improved data quality: structured configuration data is more useful than free-text descriptions in emails and quote notes.
    • Reduced duplicate entry: the same validated values can support the proposal, CAD output, BOM and order record.
    • Scalable expert knowledge: approved engineering logic can be used by trained sales engineers and dealers within defined limits.
    • Clearer exception management: non-standard designs can be identified and routed to engineering instead of being hidden in the order process.

    Limitations and risks

    Design automation is not a shortcut around product engineering. It exposes the quality of the underlying product knowledge. If rules are incomplete, the system can produce fast but invalid results. If CAD templates are poorly structured, automated outputs may require extensive manual repair.

    Common limitations

    • Incomplete design envelope: calculations may cover standard applications but not unusual loads, environments or regulatory requirements.
    • Complex legacy CAD: older models often contain fragile references, inconsistent naming and undocumented dependencies.
    • ETO variability: engineer-to-order products may include genuinely new design work that cannot be reduced to option selection.
    • Data ownership conflicts: CPQ, ERP, PLM and CAD teams may disagree about the authoritative item, revision or BOM.
    • Change management: a change to a component, rule or calculation can affect quotes, drawings, inventory and active orders.
    • Performance constraints: native CAD generation can be slower and more resource-intensive than generating a lightweight visual model.
    • Regulatory requirements: automated design outputs may still require documented checks, signatures or approval by qualified personnel.
    • False automation expectations: a platform may support configurable BOMs or visual models without supporting native CAD generation or engineering calculations.

    Vendor claims should therefore be tested with representative product data. Buyers should ask whether the capability is native, delivered through an integration, dependent on custom development or limited to a demonstration scenario.

    Implementation considerations

    Start with a bounded product family

    Choose a product family with meaningful configuration volume, repeated engineering decisions and a reasonably stable design. A standard pump, modular conveyor, electrical enclosure or vehicle body may be a better starting point than a product with extensive one-off engineering.

    Document the design envelope

    Record supported ranges, exclusions, calculation assumptions, material limits, regulatory conditions and escalation triggers. Engineers should define when the CPQ workflow can approve a design automatically and when human review is mandatory.

    Separate rules from presentation

    The configuration interface should not be the only location where product logic exists. Rules, calculations and option definitions should be structured, versioned and testable. This makes it easier to reuse the same logic across internal sales, dealer portals and customer-facing configuration.

    Prepare CAD templates deliberately

    Parameterize stable dimensions and use controlled references. Define naming conventions for parameters, components, configurations and output files. Decide whether the process needs native CAD, neutral formats such as STEP, PDF drawings, lightweight web visualization or a combination of these outputs.

    Define BOM ownership

    Decide whether CPQ creates a quote-level configurable BOM, whether PLM creates the released EBOM, and how ERP receives an MBOM or order-specific structure. Do not assume that one BOM representation can satisfy sales, engineering and production equally.

    Build testing around real scenarios

    Test valid configurations, invalid combinations, boundary values, revision changes, missing inputs, calculation failures, CAD regeneration and integration errors. Include regression tests so a rule change does not silently invalidate previously approved products.

    Govern releases and maintenance

    Assign ownership for product options, rules, calculations, CAD templates, prices and integration mappings. Establish an approval process for changes and retain the revision used for each quote or order. These governance practices are covered in the manufacturing CPQ implementation guide.

    How to evaluate design automation capabilities

    Evaluation area Questions to ask
    Configuration depth Can the system model nested assemblies, dimensions, dependencies, exclusions and conditional components?
    Engineering calculations Can calculations use formulas, external services, lookup tables and versioned assumptions?
    CAD automation Does it generate native CAD, neutral geometry, drawings, lightweight visualization or only images?
    BOM handling Can it create configurable BOMs, EBOMs or MBOM-related data, and where is the system of record?
    Exception workflow Can non-standard configurations be routed to engineers with complete context and audit history?
    Integration Are ERP, PLM, PDM, CRM and CAD connections standard, API-based or custom?
    Governance Can product rules, templates, calculations and revisions be tested and approved?
    Operational scale Can the architecture handle large product models, dealer users, concurrent calculations and document generation?

    When design automation is appropriate

    Design automation is most suitable where products contain repeatable engineering patterns, defined parameter ranges and a meaningful volume of similar configurations. It is especially useful for modular machinery, pump and valve packages, HVAC units, electrical equipment, material-handling systems, specialty vehicles and configurable assemblies.

    It is less suitable as a fully automated process when every order requires novel research, unbounded geometry, extensive simulation or a new regulatory interpretation. In those cases, CPQ can still capture requirements, calculate commercial values, guide standard selections and create an engineering request, while the final design remains an ETO activity.

    The practical objective is not to automate every engineering task. It is to automate the stable and repeatable decisions while preserving controlled engineering judgment where risk or novelty requires it.

    Semantic map

    The following relationships summarize the main entities discussed in this guide:

    • Manufacturing CPQ connects customer requirements to validated product configurations.
    • Configuration rules prevent invalid combinations of options, dimensions and components.
    • Engineering calculations convert application requirements into technical parameters.
    • CAD automation uses technical parameters to generate product-specific models and drawings.
    • A configured product can generate or inform an EBOM.
    • PLM governs engineering revisions and released product structures.
    • ERP uses approved order, item, BOM and commercial data for enterprise execution.
    • Exception workflows connect non-standard configurations to engineering review.
    • Design automation reduces manual sales-to-engineering data re-entry.
    • Product model governance controls changes to rules, calculations, templates and revisions.

    Frequently asked questions

    What is design automation in manufacturing CPQ?

    It is the automated generation or modification of engineering outputs from a validated product configuration. Outputs may include calculations, CAD models, drawings, specifications and BOM-related data.

    How is design automation different from generic CPQ?

    Generic CPQ commonly focuses on selecting products, calculating prices and producing quotes. Manufacturing design automation adds engineering logic and may create CAD, BOM or production-related outputs.

    Does every manufacturing CPQ platform generate CAD files?

    No. Some platforms generate visualizations or pass parameters to a CAD system, while others support native CAD automation. This capability must be verified for the specific CAD tools and file types required.

    Can CPQ automatically create an engineering bill of materials?

    Some systems can create a configurable or order-specific BOM, but the exact behavior varies. The implementation must define whether CPQ, PLM or ERP owns the released EBOM.

    What is the difference between an EBOM and an MBOM?

    An EBOM represents the product as designed by engineering. An MBOM represents how the product is assembled or manufactured. They may contain different structures, quantities, operations or production groupings.

    Can design automation support engineer-to-order products?

    It can support parts of an engineer-to-order process, such as requirement capture, standard component selection and preliminary calculations. Novel designs normally still require engineering review and manual development.

    What information is needed for CAD automation?

    Typical inputs include configuration selections, dimensions, component identifiers, material choices, parameter mappings, CAD templates and rules governing valid geometry.

    What role does the rules engine play?

    It validates selections, enforces dependencies, applies defaults, restricts ranges and identifies conditions that require engineering review.

    Is guided selling the same as engineering configuration?

    No. Guided selling recommends products or options based on customer needs. Engineering configuration validates technical compatibility and may calculate or generate a product design.

    How does design automation affect pricing?

    The configuration and calculated technical values can provide inputs to costing and pricing. Design automation does not replace the pricing engine; it supplies more accurate product facts for commercial calculations.

    Can a configured 3D model be used for manufacturing?

    Sometimes, but not automatically in every implementation. A visual model may be suitable for customer review, while manufacturing may require controlled native CAD, drawings, tolerances and released product data.

    How does design automation improve the sales-to-engineering handoff?

    It transfers structured requirements, validated selections, calculations and exceptions instead of relying on free-text emails or manually re-entered spreadsheets.

    What happens when a customer requests a non-standard design?

    The CPQ process should identify the request as outside the approved design envelope and route it to engineering with the captured requirements and proposed configuration.

    Which systems commonly integrate with design automation?

    Depending on the architecture, integrations may include CAD, PDM, PLM, ERP, CRM, MES and document-generation services. A CPQ product does not necessarily support all of these natively.

    How should manufacturers test automated designs?

    They should test valid and invalid configurations, boundary values, calculation results, CAD regeneration, BOM accuracy, revision changes, integration failures and exception routing using representative products.

    What is the biggest implementation risk?

    The biggest risk is automating incomplete or poorly governed product knowledge. Fast output is not useful if the rules, calculations, CAD templates or BOM mappings are inaccurate.

    Should CPQ replace engineering approval?

    No. CPQ can automate repeatable decisions within an approved design envelope, but qualified engineers should retain responsibility for exceptions, safety-critical decisions and controlled product releases.

  • Augmented Reality in Manufacturing CPQ: Engineering, CAD and Configuration Workflows

    Augmented reality in manufacturing CPQ combines augmented reality (AR) with configure, price, quote (CPQ) processes so users can review a configured product in a real or simulated environment before it is quoted, engineered or manufactured. A CPQ system may use the selected options, dimensions, materials, accessories and engineering outputs to display a product-specific 3D model, identify components, show clearances or guide an assembly review.

    In manufacturing, AR is not simply a visual sales feature. Its value depends on whether the AR experience is connected to a governed product model and reliable engineering data. When connected correctly, a configuration can produce a validated visual representation, a bill of materials (BOM), pricing, drawings and downstream manufacturing information. When it is not connected, AR may show an attractive but generic model that does not represent the product being quoted.

    This guide explains where AR fits in a manufacturing CPQ architecture, how data moves between configuration and engineering systems, which use cases are practical, and what manufacturers should verify before implementation.

    What is augmented reality in manufacturing CPQ?

    Augmented reality in manufacturing CPQ is the use of digital overlays, 3D models and contextual product information to present a configured industrial product in the user’s physical environment or field of view.

    For example, a sales engineer configuring a pump skid could use AR to place the selected skid in a plant area. The visualization might show the chosen pump, motor, frame, pipe connections and control enclosure. It could also display approximate footprint, service access zones and connection locations. The underlying CPQ configuration should determine which model variants and dimensions appear.

    AR is therefore an interaction and visualization layer around CPQ data. It does not replace:

    • Product configuration, which selects valid options and applies dependencies and constraints;
    • Engineering calculation, which determines whether the selected product meets duty, load, capacity or dimensional requirements;
    • CAD, or computer-aided design, which represents product geometry and can produce drawings or design outputs;
    • BOM generation, which identifies components required for a configured product;
    • Pricing and costing, which calculate commercial values; or
    • Enterprise integration, which transfers approved information to systems such as enterprise resource planning (ERP), product lifecycle management (PLM) or customer relationship management (CRM).

    A manufacturing CPQ platform may support some of these functions directly, integrate with specialist systems, or provide only the configuration and quotation layer. Buyers should verify the documented scope of each product rather than assuming that a CPQ system includes native AR, CAD automation or engineering automation.

    How AR fits into a manufacturing CPQ architecture

    A typical architecture contains several connected layers. The product model defines what can be configured. The rules engine validates selections. Engineering services calculate dimensions or performance. CAD and visualization services produce geometry. The AR application displays the resulting model on a device. Commercial and enterprise systems manage pricing, quotes, orders and production data.

    Layer Typical responsibility AR relationship
    Product model Defines options, features, attributes, variants and component relationships. Determines which product components and visual assets may be displayed.
    Rules and constraints Prevents incompatible combinations and validates technical conditions. Prevents the AR view from representing an invalid configuration.
    Engineering logic Calculates capacity, dimensions, performance, loads, clearances or selections. Supplies configuration-specific values and geometry parameters.
    CAD and 3D services Generate or retrieve parametric models, assemblies, drawings and lightweight visualization files. Provide the three-dimensional assets rendered by the AR experience.
    CPQ commercial layer Calculates cost, price, discounts, lead time and quote content. Associates the displayed configuration with a quote or opportunity.
    ERP, PLM, PDM and MES Manage enterprise, lifecycle, design, production and execution data. Supply approved revisions, item identifiers and manufacturing context where required.

    A product data management (PDM) system manages design files and revisions, while PLM manages product lifecycle information, structures, changes and governance. A manufacturing execution system (MES) manages production execution. These systems are related but not interchangeable. An AR application should use approved and traceable data, especially when the visual output is used for engineering review or production support.

    Data flow from configuration to AR

    The exact implementation varies, but a common flow is:

    1. Start with requirements. A user enters application data such as flow rate, pressure, voltage, payload, dimensions, environment or vehicle use case.
    2. Apply configuration rules. The CPQ product model enables valid options and rejects incompatible selections. For example, a motor voltage may be restricted by the selected electrical standard, and a frame size may depend on pump capacity.
    3. Run engineering calculations. A calculation service may determine shaft size, heat exchanger area, structural dimensions, cable length or required safety factors.
    4. Resolve product identity. The system identifies selected components, part numbers, variants and revision-controlled assemblies.
    5. Generate or retrieve 3D data. The solution obtains a lightweight model, a parametric CAD output or a prebuilt 3D asset that matches the configuration.
    6. Apply metadata. Components can be associated with labels, service zones, technical attributes, item numbers, cost information or installation instructions.
    7. Render the AR experience. The user places, rotates, measures or inspects the configured product using a supported device.
    8. Return decisions to CPQ. The user may confirm the configuration, request a change, attach an image to the opportunity or send the result for engineering review.

    The most important control point is the relationship between the product configuration and the 3D output. A model generated from different rules, an old CAD revision or a generic product family may create false confidence. The system should record the configuration version, CAD revision and relevant calculation results where the AR output influences a quote or design decision.

    Manufacturing use cases for AR-enabled CPQ

    Industrial machinery and equipment

    Manufacturers of machinery can use AR to show how a configured machine fits into a customer’s facility. A configured conveyor, packaging machine or material-handling system may include different lengths, guards, drives, access doors and discharge directions. An AR view can help the customer review footprint, operator access and interfaces before quotation approval.

    Pumps, valves and process skids

    For pumps and valves, AR can display selected connection sizes, orientation, actuator position, motor arrangement and service access. In a skid configuration, the visual output can help reveal clashes with adjacent equipment. It should not be treated as a substitute for a certified layout or piping design unless the underlying geometry and engineering process support that use.

    HVAC and electrical equipment

    An HVAC CPQ workflow may use AR to show an air-handling unit, duct connections, service panels and clearance zones in a building area. An electrical equipment configuration may display enclosure dimensions, cable entry locations, busbar sections and selected accessories. Rules still need to validate ratings, environmental requirements and applicable product constraints.

    Specialty vehicles and mobile equipment

    Vehicle and mobile-equipment manufacturers can display a configured body, cab, tank, boom, tool carrier or accessory package. The visualization may support customer review of reach, access and interference. Engineering validation remains necessary for axle loads, structural limits, legal requirements, stability and production feasibility.

    Sales-to-engineering handoff

    AR can make handoff discussions more concrete. A sales engineer can mark a customer concern on the configured model and transfer the same configuration identifier, selected options, dimensions and attachments to engineering. This is more useful than sending an unstructured screenshot, provided the receiving team can trace the visual output back to the controlled product model.

    Installation, service and production support

    After the sale, the same product-specific data may support installation or service guidance. A technician could identify components, access panels or connection points using an approved model. However, this requires revision control and a clear distinction between a sales visualization and an authoritative service or work instruction.

    AR compared with 3D product configuration and CAD automation

    These capabilities overlap but solve different problems.

    Capability Primary purpose Typical output
    3D product configuration Lets users inspect and manipulate a digital representation of a product. Browser-based model, option visualization or interactive assembly.
    CAD automation Creates or modifies engineering geometry from parameters and rules. Parametric CAD file, drawing, assembly or manufacturing geometry.
    Augmented reality Places digital content in a physical context or user field of view. Device-based overlay, spatial review or guided visualization.
    Virtual reality Places the user in a fully digital environment. Immersive simulated facility or product review.

    A CPQ system may offer browser-based 3D without AR, or it may integrate with a separate visualization and AR platform. CAD automation may produce a precise engineering model while AR uses a simplified model for performance. The simplified model must still preserve the dimensions, interfaces and components relevant to the intended decision.

    Benefits for engineering-driven manufacturers

    • Earlier spatial validation: Customers and sales engineers can identify footprint, access and interface problems before order release.
    • Clearer technical communication: A configured assembly can be easier to review than a text description or generic catalogue image.
    • More useful sales-to-engineering handoff: The same configuration identifier and visual context can accompany the request for engineering review.
    • Reduced ambiguity in options: Users can see the practical difference between accessories, orientations, enclosures and connection arrangements.
    • Support for complex products: AR is particularly useful when the product contains many physical options whose effects are difficult to communicate in a quote.
    • Potential reuse of engineering assets: Approved 3D models and metadata may support sales, installation, service and training, subject to governance.

    These benefits depend on data quality. AR cannot correct an incomplete product model, missing constraints, inaccurate CAD geometry or an uncontrolled engineering process.

    Limitations and implementation risks

    Visual accuracy is not engineering validation

    A model can look correct while failing a load, pressure, thermal, electrical or regulatory requirement. CPQ rules and engineering calculations must remain authoritative for those decisions.

    Model preparation can be expensive

    Detailed CAD assemblies may be too large for real-time AR. Manufacturers may need simplified meshes, material definitions, texture optimization, coordinate systems and separate visual variants. This creates another data-maintenance task.

    Configuration and CAD may not align

    A CPQ option may not map cleanly to a CAD feature. Some options change geometry, while others change only metadata, hardware, purchasing items or manufacturing operations. The implementation must define what appears visually and what is represented only in the BOM.

    Revision and lifecycle control are essential

    AR content associated with an obsolete CAD revision can mislead users. The system should define approval states, effective dates, ownership and traceability between product rules, CAD files, visual assets and production structures.

    Devices and operating conditions affect usability

    Lighting, network availability, tracking quality, screen size, protective equipment and factory conditions can affect the experience. A browser or tablet workflow may be more practical than specialized headsets for some sales and engineering teams.

    AR may not be appropriate for every product

    For a small configurable component, a 2D drawing or standard 3D viewer may provide sufficient value. AR is most justified when physical context, spatial relationships or customer understanding materially affect configuration and approval.

    Implementation approach

    1. Select a specific decision to improve. Start with a use case such as equipment footprint review, accessory selection or plant interface validation rather than an open-ended AR project.
    2. Map the authoritative data. Identify which system owns product options, rules, CAD revisions, item numbers, BOM structures, calculations and customer requirements.
    3. Define configuration-to-geometry mappings. Document how each relevant option changes the model, metadata, assembly structure or no visual output at all.
    4. Choose the required fidelity. Decide whether users need a conceptual model, dimensionally reliable layout, engineering CAD output or a service-grade representation.
    5. Design identifiers and traceability. Link the AR session to a configuration ID, quote revision, product revision and, where appropriate, CAD or PLM revision.
    6. Test rule and visual consistency. Test valid and invalid combinations, boundary dimensions, substitutions, obsolete parts and engineering overrides.
    7. Integrate with the sales and engineering workflow. Define how users request review, capture customer approval, transfer comments and update the quote.
    8. Govern changes after launch. Assign ownership for product rules, CAD assets, visual content, device support and release testing.

    Manufacturers should document requirements, integration boundaries and acceptance tests as part of the wider CPQ implementation process. The product model and rule governance should be designed alongside the AR experience, not after it.

    Questions to ask when evaluating AR and CPQ software

    • Does the platform provide native AR, browser-based 3D, or an integration framework?
    • Can the AR model be generated from the exact configured options and dimensions?
    • How are CAD files simplified, versioned and approved?
    • Can visual components be linked to part numbers, BOM items and engineering attributes?
    • Does the solution support parametric geometry, prebuilt variants or both?
    • How are configuration rules shared between CPQ and CAD automation?
    • Can the system distinguish a sales visualization from an engineering-approved model?
    • How are revisions synchronized with PLM or PDM?
    • Can a user return comments, measurements or approval status to the quote?
    • What happens when an option has no visible geometry but changes cost, BOM or manufacturing work?
    • Are offline use, device management and access permissions supported?
    • Can the implementation handle configure-to-order (CTO) and engineer-to-order (ETO) products?

    These questions should be evaluated with representative products, not only a demonstration model. Review a product with dimensional dependencies, optional components, substituted parts and at least one engineering exception.

    Related manufacturing CPQ concepts

    AR is one part of a broader engineering and commercial architecture. Read the guide to CAD and engineering automation for parametric models, drawings and calculations. The guide to product configuration and rules engines explains how options and constraints are modeled. For downstream structures and commercial outputs, see BOM generation, pricing and quoting. The manufacturing workflows guide covers configure-to-order, engineer-to-order and sales-to-engineering handoff. Integration patterns are described in the guide to CPQ integrations.

    Semantic map

    The following relationships summarize how augmented reality connects to manufacturing CPQ and engineering data:

    Entity Relationship Related entity
    CPQ configures configurable industrial products
    Configuration rules prevent invalid option combinations
    Configured product generates configuration-specific BOM
    CPQ exchanges data with ERP
    CAD automation generates product-specific geometry and drawings
    AR application displays configured 3D model
    Engineering calculations determine technical product parameters
    PLM governs product revisions and lifecycle data
    PDM manages CAD files and design revisions
    AR review supports sales-to-engineering handoff
    Configured options control visual components and metadata
    Approved product model supports quote, engineering and production workflows

    Frequently asked questions

    What is augmented reality in manufacturing CPQ?

    It is the use of digital overlays and configured 3D product content to show an industrial product in a physical or spatial context during configuration, quotation, engineering review or service.

    Does every manufacturing CPQ system support augmented reality?

    No. Some systems provide only rules, pricing and quoting. Others include 3D visualization or connect to external CAD, visualization or AR platforms. Native AR capability must be verified with the vendor.

    How is AR different from 3D product configuration?

    3D configuration displays and manipulates a digital product, often in a browser. AR places digital content into the user’s physical environment or field of view. A CPQ solution may provide one without the other.

    Can AR generate a BOM?

    AR normally does not generate the BOM itself. The CPQ or engineering system generates a configurable BOM, while AR displays selected components or metadata associated with that BOM.

    Can AR replace CAD automation?

    No. CAD automation creates or modifies engineering geometry and drawings. AR presents visual content. They can be connected, but they perform different functions.

    What product data does AR-enabled CPQ require?

    It commonly requires product options, configuration rules, dimensions, part identifiers, approved 3D assets, revision information and mappings between configuration selections and visual components.

    Can AR show a completely engineered-to-order machine?

    It can, if the engineering process produces suitable geometry and the AR workflow can consume it. ETO products usually require stronger review, revision and approval controls than standard CTO products.

    How does AR support sales-to-engineering handoff?

    It can provide a shared visual reference and transfer the configuration ID, selected options, dimensions, comments and attachments to engineering. The handoff is reliable only when the visual output remains traceable to controlled data.

    Is an AR model the same as an engineering-approved model?

    Not necessarily. AR often uses a simplified model optimized for performance. It should be labeled according to its purpose and should not be treated as an approved design without the required engineering validation.

    Can AR validate physical clearances?

    It can support an early clearance review when the model, scale, coordinate system and placement method are reliable. Formal layout, safety and compliance decisions may require certified drawings or engineering analysis.

    What is the role of configuration rules in AR?

    Rules ensure that the visualized product reflects valid combinations. For example, they can prevent an AR view from showing an incompatible motor, frame, enclosure or connection arrangement.

    Does AR affect pricing and quoting?

    AR does not inherently calculate price. It can improve option understanding and customer approval, while the CPQ pricing engine calculates cost, price, discounts, lead time and quote values.

    Can AR use data from PLM or PDM?

    Yes, an integration may retrieve approved CAD assets, revisions and metadata from PLM or PDM. The integration must define ownership, release status, access rights and revision synchronization.

    Is AR useful for configure-to-order products?

    Yes. CTO products often have repeatable option structures and reusable visual assets, making them practical candidates for AR-based configuration and customer review.

    Is AR useful for make-to-order and engineer-to-order products?

    It can be useful, but the value depends on how much geometry and engineering data exists before the order. ETO workflows need careful handling of design changes, approvals and model revisions.

    What are the main risks of implementing AR in CPQ?

    Common risks include inaccurate or obsolete models, weak configuration-to-CAD mappings, poor device usability, excessive model detail, unclear data ownership and treating visualization as engineering validation.

    How should a manufacturer start an AR CPQ project?

    Choose one high-value use case, such as reviewing equipment footprint or accessory placement. Map authoritative data, define model fidelity, connect the configuration to visual assets and test the workflow with real product variants.

    What should buyers ask AR and CPQ vendors?

    Ask whether AR is native or integrated, how models are generated and versioned, how options map to geometry, how BOM and CAD data are linked, how revisions are governed and how the result returns to the quote or engineering workflow.

  • System-Level Configuration for Complex Industrial Solutions

    System-level configuration is the process of selecting and validating multiple related products, subsystems and engineering parameters as one complete industrial solution. In manufacturing CPQ, or Configure, Price, Quote software, the objective is not merely to choose options on a single product. It is to ensure that pumps, motors, valves, controls, frames, electrical equipment, software and services work together, meet technical constraints, produce accurate commercial results and generate usable downstream data.

    A system-level configurator therefore sits between product configuration, engineering, pricing and manufacturing. It may use rules to prevent incompatible selections, calculations to size components, configuration data to create a configurable bill of materials (BOM), and integrations to transfer the result to enterprise systems. The exact scope depends on the platform. Some CPQ products focus primarily on guided selling and quotations, while manufacturing-oriented systems may also support engineering calculations, CAD automation, BOM generation or configure-to-order and engineer-to-order workflows.

    For example, configuring an industrial pumping system may require more than selecting a pump model. The system may need to evaluate flow, pressure, fluid properties, temperature, materials, motor voltage, starter type, instrumentation, piping connections, skid dimensions and site requirements. A valid configuration must satisfy hydraulic, mechanical, electrical, commercial and production constraints simultaneously.

    This guide explains how system-level configuration works, how to structure the product model, how to manage rules and dependencies, where the data flows after configuration, and what manufacturers should consider before implementing it. For a broader introduction, see the guide to manufacturing CPQ and the detailed guide to product configuration and rules engines.

    What is system-level configuration?

    System-level configuration is the coordinated configuration of a complete solution made up of several products, assemblies or functional subsystems. The configurator evaluates relationships between those parts rather than treating each item as an independent selection.

    A system may include:

    • a primary machine or piece of equipment;
    • mechanical assemblies such as frames, conveyors, guards and enclosures;
    • electrical components such as motors, drives, starters, panels and sensors;
    • fluid, hydraulic or pneumatic components;
    • control hardware and software;
    • installation materials, commissioning services and documentation;
    • customer-specific engineering or site adaptations.

    In a simple product configurator, an option may be valid or invalid within one product family. In a system-level configurator, validity may depend on selections made elsewhere in the system. A selected motor can affect the drive, electrical panel, cooling requirements, mounting arrangement, cable size, price and BOM. A selected process fluid can affect pump materials, seals, temperature limits and certification requirements.

    Why system-level configuration matters in manufacturing

    Complex industrial sales often begin with a customer requirement rather than a finished part number. The sales engineer must translate a process need into a complete technical solution. This creates several risks when configuration is performed manually in spreadsheets, product catalogs, email and disconnected engineering tools.

    • Incomplete scope: important accessories, controls, protection devices or services may be omitted.
    • Invalid combinations: selected components may not be mechanically, electrically or operationally compatible.
    • Inconsistent calculations: two engineers may apply different sizing assumptions or formulas.
    • Slow engineering review: specialists must repeatedly check routine configurations.
    • Incorrect pricing: system dependencies, options and engineering effort may not be reflected in the quote.
    • Poor order handoff: sales information may not be structured for ERP, product lifecycle management or production systems.

    System-level configuration addresses these problems by making the relationships explicit in a governed product model. It does not eliminate engineering judgment. Instead, it automates repeatable decisions and identifies cases that require review or a separate engineer-to-order process.

    System-level configuration compared with other configuration approaches

    Approach Primary purpose Typical manufacturing example Main limitation
    Guided selling Help a user select suitable products through questions and recommendations Recommend a standard air-handling unit based on airflow and building type May not validate deep engineering relationships or create manufacturing data
    Rules-based configuration Apply explicit if-then logic to options and dependencies If a high-temperature seal is selected, restrict the material and certification options Large numbers of exceptions can make rules difficult to maintain
    Constraint-based configuration Represent permitted and prohibited relationships across variables and components Ensure pump duty, motor capacity, voltage, impeller size and frame dimensions remain compatible Requires a well-defined constraint model and clear ownership
    Product configuration Define one product or product family Configure a conveyor length, belt type, drive and guarding package May not coordinate several product families or subsystems
    System-level configuration Validate and generate a complete interconnected solution Configure a packaging line with conveyors, robots, controls, safety equipment and services Has greater data, integration and governance complexity

    These approaches can coexist. A system-level configurator may use guided questions at the user interface, rules-based logic for explicit policies, constraint solving for technical compatibility and engineering calculations for sizing.

    The product model behind a system configurator

    The product model is the structured representation of what can be sold, how it can be configured and what the configuration produces. A maintainable model separates commercial choices from engineering logic while defining the relationships between them.

    System hierarchy

    The hierarchy describes the solution from the system level down to modules, assemblies, components and selectable options. For example, a material-handling system could be represented as:

    • material-handling solution;
    • conveyor line;
    • infeed conveyor, transfer section and discharge conveyor;
    • frame, belt, roller, motor, gearbox and guarding assemblies;
    • drive, control panel, sensors and safety devices;
    • installation, commissioning and documentation services.

    The hierarchy should reflect how the company sells, engineers, procures and manufactures the solution. A sales bundle is not always the same as an engineering assembly or a manufacturing assembly.

    Features, options and parameters

    Features describe meaningful aspects of the system, such as capacity, operating environment, control architecture or compliance requirement. Options are selectable values or components. Parameters are measurable inputs such as flow rate, length, voltage, pressure, temperature, load or speed.

    For a pump skid, parameters may include:

    • design flow and differential pressure;
    • fluid density, viscosity and temperature;
    • pump material and seal arrangement;
    • motor power, voltage, frequency and enclosure rating;
    • connection standard and nozzle orientation;
    • skid footprint, lifting points and access requirements;
    • instrumentation and control protocol.

    Parameters can drive calculations and rules. They should not be treated as free-text notes if downstream systems need to use them. A structured temperature value can trigger material restrictions; a free-text statement such as hot service cannot reliably do so.

    Relationships between subsystems

    The model must represent relationships such as requires, excludes, compatible with, derives from, sized by and supplied with. These relationships may cross product boundaries.

    For example, selecting a 460-volt motor may require a matching control-panel voltage, affect the starter or variable-frequency drive, and restrict the available documentation package. Selecting stainless steel wetted parts may require compatible fasteners, seals and welding procedures. Selecting outdoor installation may require a specific enclosure rating, heater, coating system and cable-entry arrangement.

    Rules and constraints in system-level configuration

    Rules determine how the configurator responds to selections and calculated values. A constraint is a condition that must be satisfied for the complete configuration to be valid. In practice, manufacturers often use several types of logic together.

    Compatibility rules

    Compatibility rules prevent combinations that cannot work together. A gearbox may be incompatible with a particular conveyor width. A control panel may not support the selected number of axes. A valve material may be unsuitable for the specified chemical or temperature range.

    Dependency rules

    Dependency rules add or require related elements. Selecting a hazardous-area motor may require certified cable glands, an appropriate enclosure, special documentation and an inspection activity. Selecting a robotic cell may require safety fencing, interlocks and a safety controller.

    Exclusion rules

    Exclusion rules remove options that are not available in a particular configuration. A compact frame may exclude a large motor. A selected certification route may exclude certain materials or control components. Exclusions should be explained clearly to the user so that a technical restriction does not appear to be an arbitrary sales limitation.

    Calculation rules

    Calculation rules derive values from customer inputs. A configurator may calculate required motor power, heat-exchanger area, tank volume, cable size, pressure drop, structural load or estimated cycle time. Calculations need version control, documented assumptions, units and an approval process. A formula embedded in an interface without ownership or testing becomes difficult to trust.

    Availability and commercial rules

    Some rules relate to sourcing and commercial policy rather than technical validity. A component may be technically suitable but unavailable in a region, obsolete, restricted to a particular plant or subject to a minimum order quantity. These rules should be distinguished from engineering constraints because they have different owners and change cycles.

    Example: configuring a complete pump and control skid

    Consider a manufacturer selling packaged pump skids for industrial water treatment. The customer specifies flow, pressure, fluid temperature, installation location, electrical supply and control requirements.

    Configuration inputs

    • flow rate and required head;
    • fluid composition and temperature;
    • continuous or intermittent duty;
    • indoor or outdoor installation;
    • available voltage and frequency;
    • single-pump or duty-standby arrangement;
    • local control, remote monitoring or plant-network integration;
    • footprint, lifting and access restrictions.

    Configuration logic

    The model uses the duty point to select an appropriate pump family and impeller range. Fluid temperature and composition restrict materials and seal options. Duty-standby operation adds a second pump, isolation valves, check valves, instrumentation and control logic. Outdoor installation affects the panel enclosure, coating, heater and weather protection. The available electrical supply constrains the motor and drive options.

    If the calculated motor load exceeds the selected drive range, the configurator should reject the combination or propose a larger drive. If the skid footprint is too small for the selected pump and maintenance clearance, the system should identify the issue before quotation. If the requested duty falls outside the standard product model, the configuration may be routed to engineering review rather than silently producing a standard quote.

    Outputs

    The configuration may produce a technical specification, price, lead-time assumptions, system BOM, equipment tag list, control narrative and quotation. Depending on the company’s architecture, it may also trigger CAD automation for the skid layout, create an engineering bill of materials (EBOM), or send order data to an enterprise resource planning (ERP) system.

    How system-level configuration connects to engineering and manufacturing

    A system configurator is most useful when its output is structured for the next process. The exact flow depends on whether the product is configure-to-order, make-to-order or engineer-to-order.

    Configuration to engineering

    For standard or lightly variable solutions, the configuration may provide enough information for order release. For more complex solutions, it can create an engineering work package containing selected options, calculated values, unresolved decisions, customer documents and review requirements.

    CAD, or computer-aided design, automation may use configuration parameters to select templates, suppress or activate features, set dimensions and generate drawings. This capability is not present in every CPQ platform and may require a separate CAD automation service or integration. More detail is available in the guide to CAD and engineering automation.

    Configuration to BOM generation

    A BOM is a bill of materials listing the components and quantities required for a product or system. An EBOM, or engineering bill of materials, describes the design structure. An MBOM, or manufacturing bill of materials, describes how the product is assembled or produced. A configurable BOM is a rule-driven structure that resolves into a specific BOM after selections and calculations are complete.

    System-level configuration may generate a sales or technical BOM first, then pass data to PLM, ERP or manufacturing systems for further transformation. The configurator should define whether it owns the final BOM, proposes a BOM for engineering approval, or only identifies commercial components. These are different operating models and should not be conflated.

    Configuration to pricing and quoting

    Pricing is related to configuration but is not the same function. The system model determines what the solution contains and whether it is valid. The pricing engine determines material prices, labor, engineering effort, services, discounts, margins, freight assumptions and commercial adjustments.

    A pump skid may have a component price, a package assembly charge, engineering hours, testing fees and commissioning services. Some values may come from ERP or a costing system. A quote should make clear which values are calculated automatically and which require commercial approval. See BOM, pricing and quoting automation for the relationship between these functions.

    Configuration to enterprise systems

    Common systems have different responsibilities:

    System Typical responsibility in a system-level workflow
    CRM, or customer relationship management Customer, opportunity, account and sales-process information
    CPQ Configuration interaction, rules, calculations, pricing and quote preparation
    ERP, or enterprise resource planning Items, inventory, purchasing, production orders, sales orders, finance and fulfillment
    PLM, or product lifecycle management Product structures, revisions, approvals, engineering change and lifecycle governance
    PDM, or product data management Controlled CAD files, drawings and related design data
    CAD Geometric design, assemblies, drawings and design automation
    MES, or manufacturing execution system Production execution, work instructions, tracking and shop-floor reporting
    PIM, or product information management Commercial product content, descriptions, attributes and channel information

    These systems can exchange data through APIs, integration middleware, files or platform-specific connectors. A reliable architecture defines the system of record for each object and avoids creating conflicting versions of the same product, component or rule. See the guide to CPQ integrations for integration patterns and ownership questions.

    System-level configuration across manufacturing workflows

    Configure-to-order

    In configure-to-order (CTO), the manufacturer offers a defined product architecture with controlled options. System-level configuration can validate the customer solution and generate a production-relevant structure without designing a new product for every order.

    Make-to-order

    In make-to-order (MTO), production begins after the order is received, but the product may still use a relatively stable design. The configurator can determine the required components, dimensions and routing information while preserving standard manufacturing rules.

    Engineer-to-order

    In engineer-to-order (ETO), each order requires substantial engineering work. System-level configuration can capture the customer requirement, perform preliminary sizing, define standard subsystems and identify the boundary between reusable logic and bespoke design. It should not pretend that every ETO decision can be automated.

    Assemble-to-order

    In assemble-to-order (ATO), standard modules are assembled after the order is placed. A system configurator can coordinate module compatibility, availability and assembly requirements across the complete solution.

    These workflow distinctions matter because they determine how much authority the configurator has. A CTO model may generate a releasable BOM. An ETO model may generate a controlled engineering request and preliminary estimate instead.

    Benefits of system-level configuration

    • More complete solutions: dependencies help include required accessories, controls and services.
    • Earlier error detection: invalid technical combinations can be identified before quote submission or order entry.
    • Faster routine engineering: repeatable sizing and selection logic can be applied consistently.
    • Better quote quality: price, scope, lead-time assumptions and technical content are based on the same configuration.
    • Improved handoff: structured data is easier to transfer to ERP, PLM, CAD and production processes.
    • Reusable engineering knowledge: validated rules preserve expertise when products, staff or markets change.
    • Greater traceability: the company can identify which rules, revisions and inputs produced a quoted solution.

    Limitations and risks

    System-level configuration is not a shortcut around product data quality or engineering governance. Its limitations usually arise from model scope, unclear ownership and excessive complexity.

    Rules can become unmaintainable

    A model with thousands of overlapping exceptions may be harder to manage than the manual process it replaced. Rules should be modular, named, documented and tested. Repeated logic should be centralized rather than copied across many product families.

    Engineering knowledge may be incomplete

    Experienced engineers often rely on assumptions that are not written down. Before automation, the organization must identify units, tolerances, safety factors, valid operating ranges, standards and approval conditions.

    System boundaries can create ambiguity

    Manufacturers need to decide whether product rules live in CPQ, PLM, ERP, CAD or another service. Duplicating the same logic in several systems creates synchronization risk. A CPQ model may need a simplified commercial representation while PLM remains the authority for released engineering structures.

    Not every configuration is automatable

    Novel applications, unusual site conditions, regulatory interpretations and major customizations may require engineering review. A mature system should support controlled exceptions, not force every opportunity into a standard model.

    Integration does not guarantee usable data

    An API can transfer fields successfully while still producing an unusable manufacturing result. Integration design must address units, revisions, item identities, effectivity, configuration status, error handling and ownership of changes.

    Implementation approach

    1. Select a bounded system

    Start with a product family or solution type where demand is significant, configuration patterns are repeatable and the business can identify a measurable problem. A complete factory-wide model is rarely the best first release.

    2. Map the current workflow

    Document how requirements move from customer inquiry to quote, engineering review, order entry, design release, procurement and production. Identify where data is re-entered, where decisions are delayed and where errors occur.

    3. Establish product and rule ownership

    Assign owners for product options, engineering formulas, pricing, availability, compliance, BOM structures and integration mappings. Define who approves a rule, who tests it and who can release a revision.

    4. Build the minimum viable product model

    Model the system hierarchy, key parameters, standard modules, critical constraints and required outputs first. Avoid automating low-value exceptions before the core logic is proven.

    5. Separate decisions from presentation

    The user interface should guide sales engineers or customers, but the underlying model should hold the authoritative rules and calculations. This makes the logic easier to test and reuse in dealer portals, internal tools or APIs.

    6. Test real configuration scenarios

    Testing should include valid standard cases, boundary values, incompatible selections, changed product revisions, unavailable components, incomplete inputs and deliberate engineering exceptions. Test the resulting quote, BOM, CAD output and ERP transaction where applicable.

    7. Pilot the downstream handoff

    Do not stop at a technically valid quote. Confirm that engineering, purchasing, production and service can use the generated output. A system-level model is successful only when it reduces work across the workflow rather than moving effort to a later department.

    8. Govern changes after launch

    Manufacturers need a release process for new components, obsolete parts, price updates, revised formulas, regulatory changes and plant-specific availability. Configuration models require ongoing maintenance, regression testing and monitoring.

    Further guidance is available in the guide to CPQ implementation and governance and the overview of manufacturing configuration workflows.

    How to evaluate a system-level CPQ configurator

    Buyers should evaluate the complete configuration lifecycle rather than counting interface features. Important questions include:

    • Can the model represent multiple interacting subsystems and reusable modules?
    • Can rules express dependencies, exclusions, ranges, calculations and approval conditions?
    • Can non-developers maintain appropriate product content and rules?
    • Can the system distinguish technical validity from commercial availability?
    • Can it generate or integrate with a configurable BOM, EBOM or MBOM process?
    • Can it pass structured parameters to CAD, PLM, ERP or MES systems?
    • Can it support both standard configurations and controlled ETO exceptions?
    • Can it show users why a selection is invalid or what additional information is needed?
    • Does it provide versioning, testing, audit trails and effective dates?
    • Can it support dealer, distributor, internal sales-engineering and API-based channels?
    • How are units, currencies, revisions, item numbers and configuration identifiers handled?
    • What happens when an integration fails or a component becomes unavailable?

    Vendor claims should be verified through a realistic scenario using the manufacturer’s own product structure and rules. A platform may advertise configuration support while requiring separate software for CAD automation, engineering calculations or manufacturing BOM transformation. Product research can be organized using the manufacturing CPQ software profiles and comparison and selection guidance.

    Semantic map

    System-level configuration connects customer requirements, product models, rules, engineering calculations, commercial outputs and manufacturing systems. The following relationships summarize the article:

    • Customer requirements feed system parameters.
    • System parameters drive engineering calculations.
    • Engineering calculations constrain component selection.
    • Configuration rules prevent invalid subsystem combinations.
    • Subsystem dependencies determine required accessories and controls.
    • A valid configuration produces a structured solution definition.
    • A structured solution definition can generate a configurable BOM.
    • An engineering BOM may be transformed into a manufacturing BOM.
    • Configuration data informs pricing and costing.
    • CPQ exchanges customer and configuration data with CRM and ERP.
    • CAD automation can use configuration parameters to generate drawings.
    • PLM governs released product structures and revisions.
    • ETO exceptions create engineering review work.
    • Configuration governance maintains rules, formulas and product revisions.

    Frequently asked questions

    What is system-level configuration in manufacturing?

    It is the configuration of a complete industrial solution made up of several related products, assemblies or subsystems. The system validates technical relationships across those parts rather than configuring each product independently.

    How is system-level configuration different from product configuration?

    Product configuration usually focuses on one product family. System-level configuration coordinates multiple product families and evaluates dependencies between mechanical, electrical, software, service and process elements.

    What is a system-level CPQ configurator?

    It is CPQ software that captures requirements, applies configuration rules and produces a valid industrial solution across multiple subsystems. Depending on the platform, it may also calculate prices, generate BOM data or connect to engineering and enterprise systems.

    Does every CPQ system support system-level configuration?

    No. Some CPQ platforms primarily support guided selling, option selection and quote generation. Buyers must verify whether a platform supports deep rules, calculations, multi-level BOMs, engineering workflows and required integrations.

    What types of rules are needed?

    Common rule types include compatibility, dependency, exclusion, calculation, availability, compliance and approval rules. The mix depends on the product and the level of engineering automation required.

    Can system-level configuration replace engineering?

    No. It can automate repeatable decisions and identify standard solutions, but novel applications, unusual conditions and major customizations still require engineering judgment and review.

    Can a system configurator calculate equipment size?

    Some systems can perform engineering calculations or call an external calculation service. This is not universal. The manufacturer must verify formula support, unit handling, validation, versioning and approval controls.

    Can system-level configuration generate a BOM?

    Some manufacturing CPQ systems can generate a configurable or resolved BOM, while others pass selections to ERP or PLM for BOM creation. The implementation must define whether the CPQ output is authoritative, preliminary or subject to engineering transformation.

    What is the difference between an EBOM and an MBOM?

    An EBOM represents the engineering design structure. An MBOM represents the structure and sequence used to manufacture or assemble the product. A system-level configurator may create one, both, or data that another system transforms between them.

    How does system-level configuration support engineer-to-order?

    It captures structured requirements, selects reusable modules, performs preliminary calculations and identifies the work that requires engineering. It supports ETO without assuming that all custom design decisions can be automated.

    How does system-level configuration support configure-to-order?

    It validates selections within a predefined product architecture and can produce a quote, configuration identifier, BOM and order data for a standard but customizable solution.

    What manufacturing example suits system-level configuration?

    Examples include pump skids, HVAC systems, packaging lines, electrical distribution systems, industrial vehicles, conveyors and machine cells where several subsystems must operate together.

    Where should configuration rules be stored?

    The answer depends on the architecture. CPQ may own commercial configuration logic, PLM may govern released engineering structures, ERP may own item and availability data, and CAD may own geometric logic. Ownership and synchronization must be defined explicitly.

    How can manufacturers keep rules maintainable?

    Use modular rules, clear naming, documented assumptions, ownership, version control, effective dates, automated regression tests and a formal change process. Avoid duplicating the same logic across multiple systems.

    What happens when a customer request is outside the product model?

    The configurator should identify the exception and route it to engineering or commercial review. It should not silently accept a configuration that has not been technically or commercially approved.

    What is the role of CAD automation?

    CAD automation can use configuration parameters to select templates, set dimensions, activate features and generate product-specific drawings. It is often implemented through a separate CAD automation capability or integration rather than being native to every CPQ platform.

    How does system-level configuration affect pricing?

    The selected system structure determines which components, services and engineering activities need pricing. A pricing engine then applies costs, prices, discounts, margins and approval policies. Configuration and pricing should be connected but governed as separate concerns.

    What integrations are usually required?

    Common integrations include CRM for opportunities, ERP for items and orders, PLM or PDM for product data, CAD for design automation, MES for production execution and PIM for commercial product information. The required set depends on the workflow.

    How should a manufacturer start a system-level configuration project?

    Start with one bounded product or solution family, map the current workflow, establish rule ownership, model the critical constraints, test real cases and validate the downstream handoff before expanding the scope.

  • Product Hierarchies and Configuration Trees in CPQ

    Product hierarchies and configuration trees are the structures that organize a configurable product inside a manufacturing CPQ system. They show how a finished product is divided into assemblies, subassemblies, components, options and selectable values, while configuration rules determine which combinations are valid.

    In a manufacturing context, a CPQ configurator uses this model to do more than present sales options. It can validate technical choices, calculate dimensions or performance, select compatible components, create a configurable bill of materials (BOM), apply costing and pricing logic, and pass approved product data to engineering, enterprise resource planning (ERP), product lifecycle management (PLM), computer-aided design (CAD) or manufacturing systems. The exact capabilities depend on the CPQ platform and its integrations.

    A well-designed hierarchy separates the product structure from the user interface, pricing and downstream production data. That separation makes the model easier to test and maintain as products, components, suppliers and manufacturing processes change.

    This guide explains how product hierarchies work, how configuration trees differ from BOMs and option lists, how rules operate across a model, and what manufacturers should consider when building and governing a CPQ product model. For broader context, see the guide to product configuration and the manufacturing CPQ guide.

    What is a product hierarchy in CPQ?

    A product hierarchy in CPQ is a structured representation of a product family and its components, assemblies, options and variants. It defines the levels at which a product can be configured and the relationships between those levels.

    For example, an industrial pump product hierarchy might contain:

    • Product family: centrifugal process pump.
    • Base model: horizontal end-suction pump.
    • Major assemblies: hydraulic end, motor, baseplate, coupling and protection system.
    • Subassemblies: impeller, casing, shaft, seal arrangement and bearing housing.
    • Options: material grade, motor voltage, seal type, mounting arrangement and instrumentation.
    • Calculated attributes: flow rate, pressure, shaft power, motor size and connection dimensions.
    • Outputs: configured product identifier, BOM lines, price, cost, drawings and order data.

    The hierarchy can represent physical structure, commercial structure, engineering structure or a combination of them. These structures do not always match. A sales option such as “corrosive service package” may select several engineering components, while one purchased component may support several commercial options.

    What is a configuration tree?

    A configuration tree is a navigable decision structure used to guide a user through the choices required to define a product. It commonly appears as a set of product levels, option groups and selections, but it may also be represented internally as a graph of related objects and rules.

    In a simple configuration tree, the user moves from a parent item to child choices:

    Industrial air-handling unit
├── Unit type
│   ├── Rooftop
│   └── Indoor
├── Airflow range
│   ├── 10,000 m³/h
│   └── 20,000 m³/h
├── Heat exchanger
│   ├── Standard coil
│   └── High-temperature coil
├── Fan assembly
│   ├── Direct drive
│   └── Belt drive
└── Controls
    ├── Basic controller
    └── Building management system interface

    The visible tree is usually only part of the model. A user may select “20,000 m³/h,” but the system may need to validate fan capacity, motor power, casing dimensions, coil selection, electrical supply and transport limits. Those relationships may cross several branches of the tree.

    For that reason, a manufacturing CPQ system should not be treated as a menu builder. The tree provides structure and sequence; the rules engine provides technical logic.

    Product hierarchy, configuration tree and product model compared

    These terms are related but not interchangeable.

    Concept Purpose Manufacturing example
    Product hierarchy Organizes products, assemblies, subassemblies and components into levels. Machine, drive system, frame, guarding and control panel.
    Configuration tree Guides the sequence and context of configuration choices. Select machine type, then capacity, motor, accessories and controls.
    Product model Contains structure, attributes, rules, calculations, references and output behavior. Defines valid pump combinations, motor sizing logic, BOM mappings and price rules.
    Option list Defines individual choices available for an attribute or feature. 304 stainless steel, 316 stainless steel or duplex stainless steel.
    Bill of materials Lists materials and components required to build a particular product or assembly. Configured pump, impeller, seal, motor, fasteners and baseplate.

    A hierarchy or tree is therefore not automatically a production BOM. The CPQ model may use a commercial hierarchy to collect selections and then transform those selections into an engineering or manufacturing structure.

    How product hierarchies work in a manufacturing CPQ model

    1. Product families and base products

    The top level usually identifies a product family, such as industrial conveyors, hydraulic power units, switchgear cabinets or mobile elevating work platforms. A family may contain several base products with different architectures.

    Choosing a base product should establish the applicable structure and rule set. A skid-mounted pump, for example, may expose baseplate and coupling choices that are not relevant to a close-coupled pump.

    2. Assemblies and subassemblies

    Assemblies divide a complex product into manageable engineering or manufacturing areas. A material handling machine might contain a frame assembly, lifting mechanism, hydraulic system, electrical cabinet, safety system and operator platform.

    Assemblies are useful because different teams may own different sections of the model. They also support modular BOM generation, reuse of common components and more targeted testing.

    3. Features, attributes and options

    A feature is a configurable characteristic or capability, such as lifting capacity or temperature rating. An attribute is a value associated with the product, such as width, voltage, material or operating pressure. An option is a selectable value or component associated with that feature.

    Some values are discrete, such as 400 V or 480 V. Others are numeric ranges, such as a conveyor length between 3 and 12 metres. Numeric inputs normally require validation rules, units of measure and engineering calculations.

    4. Optional, mandatory and conditional branches

    Each branch should have a defined selection behavior. It may be mandatory, optional, mutually exclusive, repeatable or conditionally visible. For example, a pump seal selection may be mandatory, while a spare-parts kit is optional. A hazardous-area motor may become available only when the installation classification requires it.

    5. Components and output mappings

    Leaf nodes in the hierarchy may represent saleable options, engineering components, purchased parts, documents or production instructions. A commercial option such as “washdown package” could map to stainless-steel guards, sealed bearings, a revised control enclosure and a different paint specification.

    These mappings are often critical to BOM generation. A CPQ implementation should make clear whether a node is only a sales choice, a physical component, a configurable placeholder or an instruction to generate or select another object.

    Configuration rules and constraints across the tree

    Configuration rules control how choices interact. A rule may hide an option, require another option, prohibit a combination, calculate a value, select a component or raise an engineering review.

    Common rule types include:

    • Availability rules: show or hide options based on product family, market, date or customer context.
    • Compatibility rules: prevent incompatible combinations, such as a motor that cannot be mounted to a selected pump frame.
    • Dependency rules: require one choice when another is selected, such as requiring a temperature sensor with a specific process package.
    • Exclusion rules: prevent two choices from being selected together.
    • Cardinality rules: control the minimum or maximum number of repeated components, such as one to four conveyor sections.
    • Range rules: validate dimensions, loads, pressures, temperatures or electrical values.
    • Calculation rules: derive values such as motor size, cable length, tank volume or structural reinforcement.
    • Substitution rules: select an approved component based on performance, availability or regional requirements.
    • Workflow rules: route a configuration to engineering approval when it exceeds standard product limits.

    Rules can be local to one branch or cross the entire model. A local rule may state that a particular seal is compatible with a casing material. A cross-tree rule may state that the total machine width cannot exceed a transport limit after the frame, guarding and accessory dimensions are combined.

    Rules-based configuration, constraint-based configuration and guided selling

    Manufacturers should distinguish three related approaches.

    Approach How it works Typical use
    Rules-based configuration Explicit if-then logic determines availability, dependencies and exclusions. If voltage is 480 V, restrict control transformer choices to approved variants.
    Constraint-based configuration The system evaluates limits and relationships across variables, often solving for valid values. Ensure pump flow, head, impeller diameter and motor power remain within technical limits.
    Guided selling The user answers business or application questions and the system recommends suitable products or paths. Recommend a valve family based on media, pressure, temperature and connection type.

    These methods can coexist. Guided selling may select a product family, rules may control available options, and constraint logic may validate dimensions or performance. A basic CPQ configurator may support only simple dependencies, while a deeper manufacturing configuration platform may also support calculations, constraint solving or engineering automation. Buyers should verify the actual capabilities of each system.

    Relationship between the configuration tree and the BOM

    A bill of materials is a structured list of components required to build or service a product. CPQ may produce several BOM-related outputs, but the configuration tree is not necessarily identical to any of them.

    Configurable BOM

    A configurable BOM contains alternatives, rules, optional items or placeholders that are resolved when a product is configured. It may represent the reusable engineering logic for a product family.

    EBOM

    An engineering bill of materials, or EBOM, represents the product from an engineering perspective. It may reflect design assemblies, CAD references, revision-controlled parts and engineering ownership.

    MBOM

    A manufacturing bill of materials, or MBOM, represents how the product is built. It may group components by operation, workstation, plant or production sequence and can differ from the EBOM.

    For example, a CPQ tree for a hydraulic power unit may select reservoir size, pump type, motor, valve block and instrumentation. The resulting EBOM may contain design assemblies, while the MBOM may add hose kits, installation kits, labels and work instructions required at particular manufacturing stages.

    Whether CPQ generates an EBOM, MBOM, configurable BOM or only a sales-level structure depends on the product model and system architecture. Some organizations use CPQ to create a preliminary structure and rely on PLM or ERP to create the authoritative production BOM.

    See the guide to BOM generation, pricing and quoting for a deeper discussion of these outputs.

    How hierarchies support pricing, costing and quoting

    Product hierarchy provides the context for pricing and costing, but configuration and pricing remain separate concerns.

    A selected motor may add a component cost and a customer price. A larger frame may change material cost, labour assumptions, freight classification and engineering effort. A custom coating may add both a purchased service and a production operation. The price model must define whether these values are inherited from a parent assembly, calculated from attributes or supplied by an external system.

    Common pricing relationships include:

    • base price plus option surcharges;
    • quantity or length-based pricing;
    • cost-plus margin calculations;
    • customer, channel or regional price lists;
    • currency, tax and commercial-term adjustments;
    • engineering or non-standard configuration charges;
    • discount and approval thresholds.

    A technically valid configuration is not automatically commercially valid. The CPQ workflow may need to check minimum margins, obsolete components, supplier restrictions or approval requirements before producing a quote.

    CAD, engineering calculations and product hierarchies

    In engineering-led manufacturing, configuration choices may drive CAD parameters, calculations and drawings. For example, selecting a tank diameter and nozzle arrangement may change the model dimensions, support structure, insulation panels and fabrication drawings.

    A CPQ system may pass configuration values to a CAD or engineering automation process, which then generates product-specific geometry, drawings or documentation. However, CAD automation is not a default feature of every CPQ product. It may require a separate design automation tool, custom integration or engineering service.

    Important data relationships can include:

    • configuration attributes mapped to CAD parameters;
    • selected components mapped to approved CAD parts;
    • calculated dimensions passed to drawing templates;
    • engineering results used to select a component or trigger review;
    • revision and effectivity data synchronized with PLM or product data management (PDM) systems.

    CAD output should not be generated from an ungoverned sales tree. The model must identify which values are design-defining, which are commercial only and which require engineering confirmation. More detail is available in the CAD and engineering automation guide.

    Example: configuration tree for an industrial pump

    Consider a configurable centrifugal pump used in chemical processing.

    1. Select the pump family and hydraulic arrangement.
    2. Enter required flow, head, fluid temperature and specific gravity.
    3. Select casing and wetted-part materials.
    4. Select seal arrangement based on fluid, temperature and pressure.
    5. Select motor voltage, frequency, enclosure and hazardous-area classification.
    6. Choose mounting, baseplate, coupling guard and instrumentation.
    7. Calculate or validate impeller diameter, shaft power and motor size.
    8. Generate a configured product identifier, price, cost estimate and BOM.
    9. Route non-standard duty points or material combinations to engineering review.

    Some dependencies cross the hierarchy. Fluid temperature affects seal selection and material compatibility. Flow and head affect hydraulic selection and motor size. Motor size affects baseplate dimensions and electrical documentation. Hazardous-area classification affects motor, instrumentation and enclosure choices.

    The resulting product hierarchy may be used for navigation, while the rules and calculations determine the technically valid configuration. The output may include a sales quote, a configurable BOM, an engineering review package and data for ERP or PLM.

    Configuration trees and CTO, ETO, MTO and ATO workflows

    Configuration trees support several manufacturing operating models, but they support them in different ways.

    • Configure-to-order (CTO): the customer selects from a predefined product model and approved combinations. The tree and rules should resolve to repeatable components and processes.
    • Engineer-to-order (ETO): the product requires new or modified engineering. The tree may capture requirements and standard modules, then trigger calculations, CAD work or engineering approval.
    • Make-to-order (MTO): production begins after an order, but the product may use a standard or configured design. CPQ can supply the order-specific structure and requirements.
    • Assemble-to-order (ATO): standard modules are assembled after an order. The hierarchy should map selections to available modules, inventory items and assembly instructions.

    A configuration tree should therefore identify where standard logic ends and human engineering begins. If every unusual request is forced into a large collection of exceptions, the model may become difficult to govern.

    See the manufacturing workflow guide for more on CTO, ETO, MTO and ATO processes.

    Architecture and enterprise-system relationships

    Product hierarchy data may be distributed across several systems:

    System Typical responsibility Possible CPQ relationship
    CRM Customer, opportunity and account information. Provides sales context and receives quote status or configured product details.
    ERP Items, inventory, purchasing, costing, orders and production transactions. Receives orderable items, prices, BOM references or order data.
    PLM Product definitions, revisions, approvals and lifecycle governance. Provides approved product structures, options or revisions.
    PDM CAD files, documents and product data management. Stores or references design files and revision-controlled documents.
    CAD Parametric geometry, assemblies and drawings. Receives configuration parameters or provides design references.
    PIM Product information, descriptions, attributes and content. Supplies commercial descriptions and channel-facing information.
    MES Manufacturing execution, operations and shop-floor information. May receive production-relevant configuration or work instructions.

    These systems are not interchangeable. A CPQ hierarchy should have clear ownership rules. For example, PLM may own engineering revisions, ERP may own orderable item codes and CPQ may own interaction logic. The integration design should specify which system is authoritative for each attribute, component, revision and status.

    Read the CPQ integration guide for architecture and data-exchange considerations.

    Benefits of a well-designed configuration hierarchy

    • More reliable configuration: incompatible combinations can be blocked before quotation or order entry.
    • Faster sales engineering: users work from approved product logic instead of repeatedly checking spreadsheets and catalogues.
    • Consistent downstream data: the configured result can provide a common basis for pricing, BOMs, drawings and orders.
    • Reusable product modules: shared assemblies and rules can be reused across product families.
    • Improved change control: owners can identify which branches, rules and outputs are affected by a product change.
    • Better customer guidance: the interface can present relevant choices in a logical sequence.
    • Clearer exception handling: configurations outside standard limits can be routed to engineering rather than silently accepted.

    Limitations and common failure modes

    Overloading the tree with every rule

    A tree is useful for structure and navigation, but not every relationship belongs in the visible hierarchy. Cross-branch dependencies should be implemented and documented as rules or constraints rather than represented through excessive nesting.

    Confusing commercial options with physical parts

    A customer-facing package may select multiple components, operations and documents. Treating the package as one physical item can produce incomplete BOMs or unclear manufacturing instructions.

    Duplicating product logic across systems

    If the same compatibility rule exists separately in CPQ, ERP, PLM and CAD without ownership or synchronization, the systems can disagree. A governance model should define where each rule is maintained and how changes are propagated.

    Creating too many exceptions

    Repeated exceptions often indicate that the standard product model is poorly defined or that ETO requirements are being forced into a CTO structure. Exception categories, approval paths and engineering handoffs should be explicit.

    Ignoring effectivity and revision

    Components and rules can change by date, plant, market, certification, supplier or product revision. A configuration that was valid last year may not be valid for a current order. Effectivity and revision behavior must be tested.

    Using descriptions as identifiers

    Names and descriptions can change for commercial reasons. Stable internal identifiers, revision references and controlled mappings are more suitable for integrations and BOM generation.

    Implementation approach for product hierarchies

    1. Define the product scope: identify the product families, markets, plants and workflows included in the first release.
    2. Document the physical and commercial structures: compare sales options, engineering assemblies, EBOM structures and MBOM requirements.
    3. Classify configuration data: separate features, attributes, options, calculations, constraints, components, documents and approval triggers.
    4. Identify rule ownership: assign responsibility to product management, engineering, manufacturing, pricing or another accountable team.
    5. Model standard paths first: implement common CTO and ATO configurations before adding rare exceptions.
    6. Define output contracts: specify what CPQ sends to quoting, ERP, PLM, CAD, PDM or MES and in what format.
    7. Build test cases: include valid combinations, invalid combinations, boundary values, revisions, substitutions, missing data and exception routes.
    8. Validate with engineering and production: confirm that selected components, quantities, documents and calculations reflect how the product is actually built.
    9. Introduce governance: establish change requests, approvals, release processes, regression testing and model ownership.

    Implementation guidance should cover product data migration, testing, deployment and ongoing maintenance. The CPQ implementation guide provides a broader framework.

    How to keep a configuration tree maintainable

    • Use consistent names and identifiers for product families, assemblies, features and options.
    • Keep commercial labels separate from technical identifiers.
    • Group options by engineering or customer decision rather than by the order in which they were historically added.
    • Document rule intent, not only rule syntax.
    • Prefer reusable rules and modules over copied logic.
    • Use units, ranges and precision explicitly for numeric attributes.
    • Record rule owners and affected outputs.
    • Test product revisions and effectivity dates.
    • Measure invalid configurations, engineering overrides, model defects and quote rework.
    • Review unused, obsolete and duplicate options regularly.

    Maintainability is especially important when product knowledge is distributed across application engineers, product managers, sales engineers and manufacturing specialists. A model that only one developer understands is a business risk, even if it produces correct results.

    How to evaluate a CPQ configurator’s hierarchy capabilities

    When evaluating software, ask vendors to demonstrate a real manufacturing scenario rather than a simple product bundle. Useful demonstration requirements include:

    • multiple assembly levels and reusable subassemblies;
    • numeric dimensions and engineering constraints;
    • cross-branch dependencies;
    • optional, mandatory, repeatable and mutually exclusive components;
    • revision and effectivity handling;
    • configuration of standard and engineered products;
    • configurable BOM output and distinction between EBOM and MBOM;
    • price and cost changes driven by configuration;
    • engineering approval for non-standard combinations;
    • integration with ERP, CRM, PLM, PDM or CAD where required;
    • API access and support for external product data;
    • testing, versioning, audit history and role-based model governance.

    Do not assume that a platform’s ability to display a nested option list means it supports deep product modeling. Verify how it stores rules, evaluates constraints, handles calculations, manages revisions and produces downstream data. A vendor comparison should distinguish documented capabilities from planned, partner-provided or custom-developed functionality. Relevant selection resources are available in the manufacturing CPQ comparisons guide and CPQ software profiles.

    Semantic map

    The following relationships summarize how product hierarchies and configuration trees connect manufacturing CPQ concepts.

    • CPQ configurator → organizes → configurable product models
    • Product hierarchy → contains → assemblies and subassemblies
    • Configuration tree → guides → product selections
    • Configuration rules → prevent → invalid combinations
    • Constraints → validate → technical limits
    • Configured product → generates → configuration-specific BOM data
    • Configurable BOM → resolves into → selected components and quantities
    • Product attributes → drive → engineering calculations
    • Configuration values → parameterize → CAD automation
    • Configured product → determines → price and cost
    • CPQ → exchanges data with → ERP
    • CPQ → integrates with → PLM and PDM
    • Engineering exception → triggers → approval workflow
    • Configuration model → supports → configure-to-order
    • Configuration model → initiates → engineer-to-order handoff

    Frequently asked questions

    What is a product hierarchy in CPQ?

    A product hierarchy is the structured organization of a configurable product into families, models, assemblies, subassemblies, components and options. In manufacturing CPQ, it provides the context for rules, pricing, BOM generation and engineering outputs.

    What is a configuration tree?

    A configuration tree is a structured path through product choices. It guides users from a product family or base model to the options, values and components required to define a valid configuration.

    Is a configuration tree the same as a BOM?

    No. A configuration tree guides selections, while a BOM lists components required to build or service a product. A CPQ model may transform tree selections into a configurable BOM, EBOM, MBOM or another downstream structure.

    How does a CPQ configurator use a product hierarchy?

    It uses the hierarchy to present relevant choices, apply rules, calculate values, validate compatibility and create outputs such as prices, quotes, BOM references or engineering requests.

    What is the difference between a product hierarchy and a product model?

    The hierarchy describes the product structure. The product model is broader and may include the hierarchy, attributes, rules, calculations, revisions, output mappings and workflow behavior.

    Can a configuration tree contain multiple assembly levels?

    Yes. Industrial machines commonly require several levels, including the finished machine, major assemblies, subassemblies and individual components. The model should balance detail with maintainability.

    What are cross-branch configuration rules?

    Cross-branch rules connect choices in different parts of the tree. For example, a hazardous-area selection may restrict the motor, instrumentation, enclosure and documentation branches.

    How are technical constraints different from configuration rules?

    Rules often express explicit relationships such as requires or excludes. Constraints describe limits or relationships that must be satisfied, such as maximum load, pressure, temperature, dimension or power.

    Can product hierarchies support engineer-to-order products?

    Yes, but the hierarchy should identify which selections are standard and which trigger engineering work. ETO workflows may use CPQ to capture requirements before CAD, calculation, design approval or manual BOM work.

    How does a hierarchy affect pricing?

    It provides the context for base prices, option surcharges, quantity-based calculations, component costs, engineering charges and approval thresholds. Pricing logic should remain distinguishable from technical configuration logic.

    How does a configuration tree support BOM generation?

    Selections in the tree can map to components, quantities, substitutes, assemblies or production instructions. The result may be a configurable BOM or a resolved configuration-specific BOM, depending on the system design.

    Can one commercial option map to several components?

    Yes. A package such as a washdown or hazardous-area package may map to several physical components, documentation requirements and manufacturing operations.

    What is the role of PLM in a product hierarchy?

    Product lifecycle management, or PLM, may own approved product structures, revisions, effectivity and engineering change information. CPQ can consume or reference that data, but ownership depends on the architecture.

    What is the role of ERP in a configuration model?

    Enterprise resource planning, or ERP, commonly manages items, inventory, purchasing, costing, orders and production transactions. CPQ may send orderable item data, prices, BOM references or configuration details to ERP.

    Does every CPQ system generate CAD drawings?

    No. CAD automation may be native, integrated through another tool or unavailable. Buyers should verify whether a platform supports CAD parameters, drawings, engineering calculations and revision-controlled design outputs.

    How should manufacturers test a configuration tree?

    Testing should cover valid and invalid combinations, boundary values, missing data, revisions, substitutions, pricing changes, BOM outputs, integration messages and engineering exception routes.

    Who should own a product hierarchy?

    Ownership is usually shared. Product management may own commercial structure, engineering may own technical rules, manufacturing may own production implications and IT or CPQ administrators may manage implementation. Responsibilities should be documented.

    What makes a configuration tree difficult to maintain?

    Common causes include duplicated rules, unclear ownership, excessive exceptions, copied logic, inconsistent identifiers, missing revision control and confusion between commercial options and physical components.

    Should every product option appear in the customer-facing tree?

    No. Some technical selections can be derived automatically, hidden behind a package, controlled by engineering or maintained in downstream systems. The visible tree should expose the decisions users need to make.

    How do product hierarchies support configure-to-order manufacturing?

    They organize approved modules and options so that standard configurations can be validated and translated into repeatable BOM, pricing and production data with limited engineering intervention.

  • How to Prevent Dead Ends in Product Configuration

    A dead end in product configuration occurs when a salesperson, dealer, engineer or customer can make several apparently valid selections, but a later choice reveals that the product cannot actually be completed, manufactured, priced or delivered. For example, a customer may select a large pump casing, a high-flow impeller and a compact motor frame before the configurator discovers that the motor cannot fit the selected baseplate.

    The most reliable way to prevent these failures is to treat the product model as an engineering decision system rather than a catalogue of options. A manufacturing CPQ system must represent valid components, dependencies, constraints, calculations, availability rules, manufacturing limits and downstream outputs. It should reject or prevent incompatible choices as early as possible, explain why a choice is unavailable and preserve enough structured data to generate an accurate bill of materials, quote and engineering handoff.

    This is more demanding than generic sales CPQ, which may primarily select products, quantities, discounts and commercial terms. Manufacturing CPQ can also need to validate dimensions, materials, electrical ratings, performance calculations, assembly relationships, CAD parameters and production data. The concepts of product configuration and configuration validation are therefore central to preventing dead ends.

    What is a configuration dead end?

    A configuration dead end is a state in which a partially configured product has no valid path to completion, even though the selections made so far were accepted by the system. The user may have to undo several choices, restart the configuration or send the request to an engineer for manual review.

    Dead ends are different from simple validation errors. A validation error usually identifies an immediate conflict, such as selecting a 460-volt motor with a control panel designed only for 230 volts. A dead end can remain hidden until several dependent decisions have been made. The system accepts each individual decision but fails to recognise that their combined effect leaves no feasible product.

    Situation Example Result
    Direct conflict A stainless-steel option is selected for a frame available only in painted carbon steel. The system can block the second selection immediately.
    Capacity conflict A selected lifting mast, payload and reach exceed the available hydraulic capacity. A calculation or constraint must identify the limit.
    Downstream conflict A selected enclosure requires a cable entry arrangement not supported by the chosen control cabinet. The product model must include electrical and manufacturing dependencies.
    Availability dead end A component is technically compatible but obsolete or unavailable in the plant or supply chain. Lifecycle, plant and sourcing data must influence configuration.
    Output dead end A configuration is commercially valid but cannot produce a required BOM, drawing or manufacturing attribute. Output completeness must be tested before quoting or ordering.

    Why dead ends occur in manufacturing product models

    Dead ends usually result from incomplete product knowledge, weak rule structure or a configuration process that checks decisions too late. The most common causes are below.

    Options are modelled independently

    A flat list of options may show a motor, gearbox, enclosure and mounting arrangement as separate choices. However, the product may allow only particular combinations. If the relationships are not modelled, the configurator cannot distinguish an available option from an option that is valid only in a specific context.

    Rules are written as exceptions

    Product teams sometimes encode knowledge as a growing set of statements such as do not allow option A with option B, except when option C is present. This can work for a small product but becomes difficult to review as exceptions accumulate. Contradictory rules, duplicate rules and rules with unclear ownership create gaps in validation.

    Engineering calculations are separated from configuration

    A pump selection may depend on flow, head, fluid temperature, viscosity, speed and material. If the CPQ model checks only whether a pump family is selected, while a spreadsheet performs the actual hydraulic calculation later, the user can reach a commercially valid but technically unsuitable configuration.

    Downstream systems impose hidden constraints

    An enterprise resource planning system, or ERP system, may require a specific material code, plant assignment or routable assembly. A product lifecycle management system, or PLM system, may require an approved component revision. A computer-aided design system, or CAD system, may support only certain parameter ranges. If these constraints are not reflected in the product model, the dead end appears after the quote.

    Product variants are not governed as a system

    Engineering changes, supplier substitutions, obsolete parts and plant-specific manufacturing practices can change what is valid. Without controlled releases and ownership, the CPQ model gradually diverges from engineering and production reality.

    Model the product as a constraint network

    A robust product model represents more than features and prices. It describes the relationships between choices, measurements, components, calculations and outputs. A useful model commonly includes:

    • Products and families: the configurable machine, assembly or equipment family.
    • Features and options: customer or engineer selections such as drive type, material, voltage, capacity or finish.
    • Attributes: values such as length, pressure rating, temperature, payload, speed or operating environment.
    • Dependencies: relationships stating that one choice requires, excludes or changes another.
    • Constraints: technical limits that must hold across the entire configuration.
    • Calculations: formulas that derive dimensions, performance, capacity, power, cost or component selection.
    • Component mappings: relationships between selections and configurable bills of materials.
    • Output requirements: data needed for pricing, quoting, CAD, BOM, ERP, PLM or manufacturing.
    • Lifecycle and availability data: approved, obsolete, superseded, plant-specific or supplier-specific status.

    This structure creates a network rather than a linear questionnaire. A change to a motor may affect the coupling, shaft, baseplate, enclosure, power supply, price, weight and CAD parameters. The system must be able to propagate those effects or explain which dependent decisions must be revisited.

    Use the right type of rule

    Not all configuration logic is the same. Separating rule types improves clarity, testing and maintenance.

    Rule type Purpose Industrial example
    Availability rule Controls whether an option is shown or selectable. Show a hazardous-area motor only when the application classification supports it.
    Requires rule States that one selection needs another. A stainless-steel hopper requires stainless-steel product-contact fasteners.
    Excludes rule Prevents incompatible combinations. A high-temperature seal excludes a standard elastomer.
    Cardinality rule Controls the number of selections. A control panel must contain exactly one primary controller and may contain up to four expansion modules.
    Range constraint Limits a numerical value. A conveyor width must be between the frame’s minimum and maximum supported width.
    Calculation rule Derives a value or selection. Motor power is calculated from load, speed, efficiency and service factor.
    Compatibility rule Matches options across domains. A valve body, actuator and pressure class must come from a compatible combination.
    Manufacturing rule Reflects production capability. A plant can weld a selected frame only within its available length and material limits.
    Lifecycle rule Controls approved and obsolete items. Prevent a discontinued drive from being selected for a new quote.

    Prevent dead ends with forward checking

    Forward checking means evaluating the consequences of a choice before the user proceeds too far. After a user selects a 12-metre conveyor, the configurator should not merely accept the length. It should check the available frame sections, splice arrangements, motor capacity, shipping limits, guarding requirements, support spacing and CAD or BOM mappings.

    The interface can then remove impossible options, mark conditional options, or present a warning requiring review. This is preferable to allowing every option and showing a long list of errors at the end.

    Use domain filtering

    Each configurable attribute has a domain: the set of values that may be selected. A rule engine can reduce that domain as other decisions are made. For example:

    1. The customer selects a pump application with a specified flow and head.
    2. The calculation identifies an acceptable impeller diameter and speed range.
    3. The system removes motors that cannot provide the required power.
    4. The system removes baseplates and couplings incompatible with the remaining motor and pump combinations.
    5. The user sees only combinations with a feasible engineering and manufacturing path.

    Domain filtering is especially useful for dimensions, ratings, materials and standard component families. It is less suitable when the result depends on a complex engineering analysis that requires a specialist calculation service or manual review.

    Expose the reason for restrictions

    A blocked choice should have a useful explanation. Instead of saying option unavailable, the system might state that the selected 400-millimetre impeller requires a frame size that exceeds the chosen skid width, or that the selected pressure class requires a valve body material not available in the chosen connection type.

    Explanations help sales engineers correct the configuration, reduce support requests and reveal weaknesses in the product model. They also make rules easier to validate with engineering and product management.

    Build a complete configuration workflow

    A dead-end prevention strategy should cover the full path from requirements to manufacturing data.

    1. Capture requirements before options

    Begin with operating requirements such as flow, pressure, payload, travel distance, ambient temperature, duty cycle, voltage, regulatory classification and installation constraints. Requirements often narrow the feasible product space more effectively than asking users to choose components directly.

    2. Select a product architecture

    Use the requirements to identify a product family, frame size, architecture or platform. For a material-handling machine, this might determine whether the product uses a belt, roller or chain conveyor before detailed components are selected.

    3. Resolve technical dependencies

    Evaluate dimensions, ratings, performance and compatibility. This is where constraint-based configuration differs from simple guided selling. Guided selling helps a user navigate questions toward a likely product. Constraint-based configuration evaluates whether the combined selections satisfy technical rules.

    4. Generate and validate engineering data

    Where supported, the system can create a configurable bill of materials, CAD parameters, drawings or engineering calculations. A bill of materials, or BOM, lists the components and quantities needed for the configured product. An engineering BOM, or EBOM, describes the product from an engineering perspective, while a manufacturing BOM, or MBOM, represents how it is assembled or produced. These structures should not be treated as interchangeable.

    Some CPQ platforms generate only a commercial configuration and quote. Others support BOM generation, CAD automation or engineering calculations through native functions or integrations. The implementation must verify what the selected platform actually produces.

    5. Validate commercial and operational feasibility

    After technical validation, check costing, pricing, lead time, plant assignment, supplier status, minimum order quantities and approval requirements. A configuration that is technically possible may still be unavailable for a specific plant or outside the organisation’s commercial policy.

    6. Produce a controlled handoff

    The final configuration should pass structured data to the relevant systems. ERP manages business and production transactions, PLM manages product definitions and revisions, product data management or PDM manages engineering files and relationships, CAD manages geometry and drawings, and a manufacturing execution system or MES may manage shop-floor execution. A CRM system manages customer and opportunity information; it is not a substitute for product or manufacturing data management.

    More detail on these system relationships is available in the CPQ integrations guide.

    Use a dependency matrix before writing rules

    A dependency matrix helps teams discover hidden relationships before implementing them. Each row can represent a feature, attribute or component, while columns identify affected domains.

    Selection Configuration impact Engineering impact Manufacturing impact Commercial impact
    Motor voltage Filters controller and cable options. Changes electrical diagram and motor data. Changes wiring and test requirements. Changes price and possibly lead time.
    Frame material Filters finish and fasteners. Changes weight and structural properties. Changes welding and surface treatment. Changes cost and sourcing.
    Operating temperature Filters seals, lubricants and sensors. Changes allowable performance range. May require special assembly procedures. Changes price and approval requirements.
    Overall length Filters modules and support spacing. Changes CAD and structural calculations. Changes BOM quantities and transport constraints. May require freight or installation surcharges.

    The matrix should include negative relationships as well as positive ones. Teams often document what an option enables but fail to document what it makes impossible.

    Design rules for maintainability

    Preventing dead ends is not only a logic problem. It is also a product-model governance problem. Rules should be readable, traceable and owned.

    Separate product facts from user-interface behaviour

    A rule stating that a 316 stainless-steel wetted part requires compatible fasteners is product knowledge. A rule stating that the user must answer material before seal type is interface behaviour. Keeping these concepts separate allows the same product logic to support a sales portal, dealer interface, engineering application or API.

    Use reusable constraints

    If the same pressure-class rule applies to several valve families, implement it as a reusable constraint or service where the platform permits it. Copying the rule into multiple models increases the risk that one version will be updated while another remains stale.

    Assign ownership

    Engineering should own technical constraints, product management should own supported product scope, manufacturing should own plant and process constraints, supply chain should own sourcing status, and commercial teams should own pricing and approval policies. One system owner should coordinate changes and resolve conflicts.

    Version the model with the product

    Rules, components, prices and drawings change at different rates. A quote should use a controlled version of the product model and identify the effective dates of important data. If an approved component is replaced, the organisation must decide whether open quotes retain the old component or are revalidated.

    Avoid unrestricted custom logic

    Custom scripts can solve difficult cases, but they may be difficult to test, explain and migrate. Use the platform’s standard modelling concepts where they are sufficient, and isolate custom calculations behind documented interfaces when they are necessary.

    Test for dead ends systematically

    Testing should not stop after checking a few popular configurations. A manufacturing product model needs structured coverage of normal, boundary, exceptional and historical cases.

    • Pairwise tests: test important combinations of two features, such as material and temperature rating.
    • Boundary tests: test minimum and maximum dimensions, capacities, pressures, speeds and temperatures.
    • Three-way or higher-order tests: test combinations known to create interactions, such as motor, enclosure and voltage.
    • Negative tests: confirm that invalid combinations are blocked with understandable messages.
    • Completion tests: verify that every accepted configuration can produce the required price, quote data, BOM or engineering output.
    • Change-impact tests: change a core rule or component and verify all affected product families.
    • Integration tests: check that ERP, PLM, PDM, CAD and other systems accept the resulting data.
    • Regression tests: rerun known scenarios after each model release.

    One useful test criterion is configuration completeness: every configuration accepted by the CPQ system must either produce all required downstream outputs or be explicitly routed to engineering review. This prevents a system from claiming success when it has only completed the commercial part of the process.

    Handle unavoidable engineering review explicitly

    Not every product can be fully constrained in a CPQ model. Engineer-to-order, or ETO, products may require a new design or engineering decision for each order. Even configure-to-order, or CTO, products can include combinations that require specialist review.

    The goal is not to pretend that every configuration is fully automatic. The goal is to distinguish three states clearly:

    1. Valid and automatable: the product model can generate the required commercial and technical outputs.
    2. Valid but requires review: the request is within a supported family but needs engineering confirmation or a non-standard calculation.
    3. Invalid: no approved product or engineering path exists.

    A review queue should capture the selected requirements, rule results, calculations, assumptions, affected components and missing decisions. This is more useful than sending an unstructured email containing a screenshot of the configuration.

    Connect dead-end prevention to BOM, CAD and quoting

    Configuration validation has downstream consequences. A valid selection should map to the right component records, quantities, revisions and attributes. If the system generates a configurable BOM, the rules must determine which components are included, excluded, substituted or added conditionally.

    For example, selecting a high-temperature pump package may require a different seal, lubricant, bearing arrangement, motor insulation class and warning label. If the product model changes only the displayed price but not the BOM and engineering data, the configuration is not operationally complete.

    CAD automation may use configuration values to generate a product-specific model, drawing or layout. However, CAD automation introduces its own constraints: parameter ranges, feature dependencies, template versions and file-generation rules. These should be tested alongside the configuration model rather than assumed to work because the commercial configuration is valid. See the CAD and engineering automation guide for the relationship between configuration and engineering outputs.

    Pricing should also be separated from technical validation. A price rule can calculate a surcharge for a material or capacity, but it should not be the only place where compatibility is checked. The BOM, pricing and quoting guide explains how technical configuration data can flow into costing and quote generation.

    Common approaches that do not work well

    Allow everything and validate at the end

    This creates long correction cycles and makes it difficult for users to understand which earlier choice caused the problem. It may be acceptable for exploratory engineering tools, but it is risky for dealer, sales and self-service workflows.

    Use only exclusion lists

    Exclusion lists are useful for direct incompatibilities but do not model capacities, calculations, ranges or derived components. A pump may be compatible with a motor in isolation but unsuitable for the required duty point.

    Put all rules in one person’s knowledge

    Unwritten knowledge creates a single point of failure. When an experienced application engineer leaves, the business may lose the reasoning behind important constraints.

    Copy rules between product families

    Copied rules drift. A shared standard, reusable rule service or centrally governed component model is usually safer when the same constraint applies in multiple families.

    Measure only quote speed

    Faster quoting is not a success if it increases engineering corrections, order changes or production holds. Track configuration quality as well as speed.

    Implementation checklist

    Use the following checklist when designing or improving a manufacturing CPQ configurator:

    • Identify the product families and configuration boundaries.
    • Document requirements, options, attributes, components and derived values.
    • Map dependencies across mechanical, electrical, software and process domains.
    • Separate direct compatibility rules from calculations and manufacturing constraints.
    • Define valid, review-required and invalid outcomes.
    • Identify the required EBOM, MBOM, CAD, quote and ERP outputs.
    • Record component lifecycle, revision, plant and sourcing conditions.
    • Assign business and technical owners to each rule group.
    • Build test cases from real quotes, engineering exceptions and production failures.
    • Test boundary values and combinations with high interaction risk.
    • Provide explanations for blocked or conditional choices.
    • Version the model and establish a controlled release process.
    • Monitor rejected configurations, manual overrides, engineering escalations and order corrections.
    • Review the model after product changes, supplier changes, plant changes and ERP or CAD changes.

    For a broader implementation plan covering data migration, testing, governance, deployment and adoption, see the CPQ implementation guide. The manufacturing workflows guide is also relevant when configuration results must move from sales engineering into production.

    How to measure improvement

    Useful measures should reveal whether the product model is preventing errors rather than merely hiding them. Consider tracking:

    • percentage of configurations completed without manual correction;
    • number of invalid combinations detected before quote submission;
    • number of engineering reviews caused by missing or ambiguous rules;
    • quote revisions caused by configuration errors;
    • orders placed on hold because of incomplete technical data;
    • percentage of accepted configurations producing complete BOM and CAD outputs;
    • time required to update and test a product rule;
    • frequency of manual overrides and their approval outcomes;
    • configuration abandonment at specific questions or decision points;
    • production or procurement corrections linked to configuration data.

    These measures should be interpreted carefully. A fall in engineering reviews may mean that the model is better, or it may mean that the system is accepting more invalid configurations. Pair efficiency measures with quality and downstream outcome measures.

    Conclusion

    Preventing dead ends in product configuration requires more than adding validation messages to a sales form. A manufacturing CPQ configurator must represent product architecture, dependencies, technical limits, calculations, component status, manufacturing capability and downstream output requirements.

    The strongest approach filters impossible choices early, explains restrictions, tests interactions and maintains a controlled relationship between the CPQ model and engineering, ERP, PLM, PDM, CAD and production data. It also recognises that some ETO and non-standard products require an explicit engineering-review path rather than forced automation.

    When configuration rules are treated as governed product knowledge, the result is not simply a faster quote. It is a more reliable transition from customer requirements to a manufacturable, correctly priced and properly documented product.

    Semantic map

    The article connects the following entities and relationships:

    • Manufacturing CPQ connects customer requirements to configurable product decisions.
    • Configuration rules constrain options, attributes, dimensions and components.
    • Constraint-based configuration evaluates whether combined selections are technically feasible.
    • Guided selling helps users navigate toward suitable products but does not replace engineering validation.
    • Calculations derive performance, capacity, dimensions, power and component selections.
    • Configuration validation prevents invalid combinations and identifies review-required cases.
    • A configured product generates structured BOM and quote data when the platform supports those outputs.
    • EBOM represents an engineering product structure, while MBOM represents a manufacturing structure.
    • CAD automation uses configuration parameters to generate product-specific geometry or drawings.
    • ERP receives commercial, item, plant and order data from connected workflows.
    • PLM and PDM manage product definitions, revisions and engineering files.
    • Dead-end prevention depends on testing, ownership, versioning and product-model governance.

    Frequently asked questions

    What is a dead end in product configuration?

    A dead end is a configuration state in which the selections already made leave no valid way to complete the product. It may be technically impossible, unavailable to manufacture, unsupported by downstream systems or unable to produce required outputs.

    How is a dead end different from a configuration error?

    A configuration error often identifies an immediate conflict. A dead end may appear only after several individually valid choices combine into an infeasible product.

    Can a CPQ configurator prevent every dead end?

    No. A well-modelled CPQ system can prevent known and testable conflicts, but novel engineering requirements, incomplete data and ETO work may still require human review.

    What types of rules prevent configuration dead ends?

    Common rules include requires, excludes, compatibility, range, capacity, calculation, lifecycle, plant and manufacturing rules. Together they describe more than simple option visibility.

    What is forward checking in product configuration?

    Forward checking evaluates the consequences of a selection immediately and removes or flags downstream options that can no longer lead to a valid product.

    Why are calculations important in manufacturing configuration?

    Many products depend on calculated values such as motor power, flow, pressure, load, heat transfer, structural capacity or dimensions. Option compatibility alone cannot validate these requirements.

    Should invalid options be hidden or displayed?

    Either approach can work. Hiding clearly impossible options simplifies the experience, while displaying disabled options with explanations can help users understand product boundaries and revise requirements.

    How should a system explain a blocked option?

    It should identify the relevant selection and constraint, such as a motor being unavailable because its frame size exceeds the selected baseplate or its voltage does not match the control system.

    What is the difference between rules-based and constraint-based configuration?

    Rules-based configuration applies explicit statements such as requires or excludes. Constraint-based configuration evaluates relationships, ranges and calculations across multiple variables to determine whether a complete solution is feasible.

    Is guided selling enough to prevent dead ends?

    No. Guided selling can ask useful questions and recommend a product family, but manufacturing products often require deeper validation of dimensions, performance, components and production constraints.

    How do BOMs relate to dead-end prevention?

    A valid configuration should map to the required components and quantities. If an accepted configuration cannot produce a complete or approved BOM, the product model has not been validated operationally.

    What is the difference between an EBOM and an MBOM?

    An EBOM, or engineering bill of materials, describes the product from the design perspective. An MBOM, or manufacturing bill of materials, describes the structure, operations or components used to build it. A CPQ process may generate or contribute to one or both, depending on the platform and integration architecture.

    Can CAD automation help prevent dead ends?

    Yes, if CAD parameters, templates and feature limits are connected to configuration validation. CAD automation can also reveal unsupported geometry, but it should not be assumed that every CPQ platform includes CAD generation.

    How should ETO products be handled?

    ETO products should have an explicit engineering-review path. The system should capture requirements and known constraints, identify what is standard or non-standard, and avoid presenting an unverified configuration as production-ready.

    Who should own configuration rules?

    Ownership should be divided by subject area. Engineering typically owns technical constraints, product management owns supported scope, manufacturing owns process limits, supply chain owns sourcing status and commercial teams own pricing policies.

    How often should configuration rules be reviewed?

    Rules should be reviewed whenever products, components, suppliers, plants, ERP structures, CAD templates or regulatory requirements change. Routine regression testing should accompany each controlled model release.

    What should happen when no valid configuration exists?

    The system should explain the limiting requirements and offer alternatives where possible. If the request may be feasible through engineering work, it should create a structured review case rather than forcing the user to restart or submit an unstructured request.

    Which metrics show that dead ends are decreasing?

    Useful metrics include invalid combinations caught early, engineering corrections, quote revisions, order holds, manual overrides, complete BOM or CAD output rates and time required to update product rules.

  • Assemblies and Subassemblies in Product Configuration

    Assemblies and subassemblies are the structural building blocks of a configurable product model. In manufacturing CPQ, an assembly is a functional or physical grouping of components, while a subassembly is a lower-level grouping that is installed, tested, purchased or manufactured as part of a larger assembly. Modeling these relationships correctly allows a CPQ configurator to validate customer selections, calculate prices, generate a configurable bill of material (BOM), support engineering automation and pass reliable product data to enterprise systems.

    This is more than a matter of arranging parts in a product tree. A configurable pump skid, industrial conveyor, HVAC unit or specialty vehicle may contain optional assemblies, mutually exclusive subassemblies, quantity-dependent components, variant-specific hardware and engineering calculations. The product model must represent those relationships and apply rules consistently from the initial configuration through quoting, design release and production.

    In manufacturing CPQ, assemblies and subassemblies usually sit between the commercial product definition and the detailed engineering and manufacturing structures. They can influence configuration, costing, pricing, lead time, CAD outputs, engineering review and the final production BOM. The exact capabilities depend on the CPQ platform and its integrations; not every CPQ system creates BOMs, automates CAD or supports deep engineering structures.

    What are assemblies and subassemblies?

    An assembly is a product or functional unit made from multiple components or lower-level assemblies. A subassembly is an assembly used inside a larger assembly. The distinction is relative to the product level being examined: a motor-and-coupling module may be a subassembly of a pump package but a complete assembly for a motor supplier.

    Examples include:

    • A conveyor system containing a drive assembly, frame assembly, guarding assembly and controls assembly.
    • A centrifugal pump package containing a pump assembly, motor assembly, baseplate assembly, coupling guard and instrumentation panel.
    • An air-handling unit containing a fan section, filter section, coil section, damper assembly and control panel.
    • A specialty vehicle containing a chassis assembly, powertrain assembly, hydraulic system, cab assembly and body equipment.

    Assemblies can be defined by physical structure, manufacturing responsibility, serviceability, purchasing strategy or functional behavior. A CPQ model therefore should not assume that every visible product grouping is automatically a manufacturing subassembly. The product structure must reflect how the manufacturer designs, prices, sources, builds and services the product.

    Why assemblies matter in manufacturing CPQ

    A generic sales quoting tool may treat a product as a list of selectable options. A manufacturing CPQ system often needs to understand which components belong together, where they are installed, which options are compatible and what downstream data must be produced.

    Assembly-level modeling helps a manufacturer:

    • organize a large product model into maintainable modules;
    • reuse a common subassembly across multiple finished products;
    • apply rules at the appropriate level of the product structure;
    • calculate quantities, costs, prices, dimensions and capacities;
    • generate configurable engineering or manufacturing BOMs;
    • identify which changes require engineering review;
    • control optional, mandatory, purchased and manufactured content;
    • create product-specific CAD models, drawings or installation documents when supported;
    • send structured data to enterprise resource planning (ERP), product lifecycle management (PLM), product data management (PDM) or manufacturing execution systems (MES).

    Without this structure, configuration rules become a flat collection of exceptions. That makes them difficult to test and increases the risk that a valid-looking quote produces an incomplete BOM or an unbuildable design.

    How assemblies are represented in a product model

    A product model is the structured definition of a configurable product, including features, options, components, rules, calculations and relationships. Assemblies normally appear as nodes in a hierarchical product tree.

    Industrial pump package
  Pump assembly
    Casing
    Impeller
    Mechanical seal
    Bearing housing
  Drive assembly
    Motor
    Coupling
    Coupling guard
  Baseplate assembly
    Baseplate
    Anchor hardware
  Instrumentation assembly
    Pressure transmitter
    Temperature sensor
    Junction box

    Each node may have attributes such as part number, revision, description, quantity, unit of measure, sourcing type, effective dates, plant, operation, lead time, cost and sales price. A configurable node may also have conditions that determine whether it is included, which variant is selected and how its quantity or parameters are calculated.

    Common assembly attributes

    Attribute Purpose in configuration Manufacturing example
    Assembly type Identifies a standard, configurable, purchased or engineered structure. Standard motor module versus engineered skid assembly.
    Parent relationship Shows where the assembly is installed or used. Control panel installed on the main frame.
    Option condition Controls when the assembly is included. Washdown enclosure required for a food-processing application.
    Quantity rule Calculates the number of instances. One support bracket for every defined length of conveyor.
    Variant or revision Controls the applicable design or part revision. High-temperature seal kit for a specified temperature range.
    Manufacturing status Indicates whether content is released, obsolete or under review. Prevent a superseded drive assembly from being quoted.
    Downstream mapping Connects the model to ERP, PLM, CAD or other records. Map a CPQ assembly to an ERP phantom assembly or material.

    Assembly rules and configuration constraints

    Assembly logic determines how a selected product configuration changes the product structure. Rules may add, remove, replace or modify assemblies and components. They may also block combinations that would create an unsafe, incompatible or unmanufacturable result.

    Typical rules

    • Inclusion rules: selecting a 400-volt motor adds the corresponding motor assembly and electrical protection components.
    • Exclusion rules: a compact enclosure excludes a large variable-frequency drive because there is insufficient space.
    • Dependency rules: selecting a stainless-steel wetted path requires compatible seals, fasteners and instrumentation.
    • Substitution rules: a selected performance range chooses one of several impeller or gearbox variants.
    • Quantity rules: the number of rollers, supports, brackets or cable sections is calculated from product dimensions.
    • Compatibility rules: a high-pressure valve assembly can only be selected with a body material and actuator rated for that pressure.
    • Completeness rules: an electrical control assembly cannot be released until the required disconnect, enclosure and control voltage are defined.

    Rules can be implemented as simple rules-based logic, constraint-based logic or guided selling. Rules-based logic explicitly states conditions such as if option A is selected, include assembly B. Constraint-based configuration evaluates permitted combinations across many variables, such as pressure, flow, temperature, material, dimensions and regulatory requirements. Guided selling helps a user reach a valid configuration through questions, but it does not replace the underlying product rules.

    These approaches can be combined. A guided selling interface may ask about fluid type and operating temperature; a constraint engine may then determine compatible materials and seals; and a rules engine may add the appropriate subassemblies to the BOM.

    Assemblies, subassemblies and BOM structures

    A bill of material (BOM) lists the components and quantities needed to define or build a product. Assembly modeling is closely related to BOM generation, but the two concepts are not identical. A product model describes configurable behavior, while a BOM is a resulting or released structure for a particular product, variant or manufacturing process.

    Configurable BOM

    A configurable BOM contains alternatives, optional components, rules or placeholders that can resolve into a specific structure after configuration. It may represent the range of possible products before a customer makes selections.

    Engineering BOM

    An engineering BOM (EBOM) represents the product as designed, often emphasizing functional and design relationships. It may contain CAD parts, design assemblies, technical documents and engineering revisions.

    Manufacturing BOM

    A manufacturing BOM (MBOM) represents how the product is built. It may reorganize components by production operation, work center, plant, kit or assembly sequence. A single engineering subassembly can be split, combined or restructured for manufacturing.

    Structure Main purpose Relationship to CPQ
    Configurable BOM Represent possible product variants and option logic. Resolved from customer selections and configuration rules.
    EBOM Represent the designed product and engineering relationships. May receive selected components, parameters or revisions.
    MBOM Represent the buildable production structure. May be generated or completed downstream in ERP or manufacturing systems.

    A CPQ application may generate one or more of these structures, or it may pass configuration results to PLM, PDM or ERP for authoritative BOM creation. The implementation should define which system owns each structure rather than assuming that CPQ is the system of record.

    Example: configuring a pump skid

    Consider a pump skid configured for a chemical-processing customer. The user selects flow rate, discharge pressure, fluid temperature, wetted material, motor voltage, control method and installation environment.

    The CPQ product model may apply the following logic:

    1. The required duty point selects a pump family and calculates a suitable impeller diameter.
    2. The fluid and temperature select a compatible casing material, seal arrangement and gasket material.
    3. The motor power calculation selects a motor size and starter or variable-frequency drive.
    4. An outdoor installation adds a weather-resistant enclosure and modifies the baseplate coating.
    5. A hazardous-area classification restricts the motor, instruments, enclosure and cable entries.
    6. The selected control method adds a control panel subassembly with the required components.
    7. The final configuration creates a quote, a price calculation, a lead-time estimate and, where supported, an engineering BOM or CAD package.

    Some outcomes are commercial and some are engineering outcomes. The price may use assembly-level costs, purchased component prices, labor, engineering effort, margin and freight rules. The BOM may include the selected motor, seal, valves, instruments and hardware. A CAD integration may use calculated dimensions and selected variants to produce a skid layout. These capabilities may be distributed across CPQ, CAD, PLM and ERP rather than delivered by one application.

    Assemblies in CTO, ETO, MTO and ATO workflows

    Assembly modeling supports several manufacturing approaches, but the required depth differs.

    • Configure-to-order (CTO): the manufacturer builds a product from predefined options and approved subassemblies. The model should resolve to known components and routings with limited engineering intervention.
    • Engineer-to-order (ETO): the configuration defines requirements, but engineers create or adapt designs for the order. Assembly structures may include engineered placeholders, calculated dimensions or review gates.
    • Make-to-order (MTO): production begins after the order, often using a configured product definition and order-specific planning.
    • Assemble-to-order (ATO): standard subassemblies are stocked or prepared in advance and combined after the customer order.

    For example, a standard conveyor drive module may support CTO, while a conveyor frame with unusual length, loading and environmental constraints may move into ETO. The CPQ system should make that transition explicit, such as by assigning an engineering review status or creating a structured handoff to engineering.

    Relationship to CAD and engineering automation

    Assemblies are often the bridge between commercial configuration and design automation. A CAD system may use the selected assembly variant, dimensions, mounting points, material, hole patterns and component positions to create a product-specific model or drawing.

    Possible outputs include:

    • an assembly-level 3D model;
    • configured component models;
    • 2D manufacturing or installation drawings;
    • dimension and clearance checks;
    • customer layout drawings;
    • assembly instructions or service documentation.

    CAD automation is not automatic merely because a CPQ platform contains an assembly tree. The CAD models, parameters, templates, mappings, revision controls and error handling must be implemented. Read more about CAD and engineering automation in manufacturing CPQ.

    Assembly-level pricing, costing and quoting

    Assembly structure can support more accurate costing and pricing. A configurable pump package may calculate material cost from the pump, motor, baseplate, instruments and controls, then add labor, testing, engineering, overhead and margin. An assembly may also have its own price, cost, lead time or approval threshold.

    However, price structure should not be confused with product structure. A commercial package may be sold as one line item even when it contains many manufacturing assemblies. Conversely, one physical assembly may contain components that need separate commercial treatment because of options, service contracts or compliance requirements.

    Pricing and BOM logic should be tested independently. A component can be included in the BOM without having a separate visible price, or a commercial option can change price without changing the physical BOM. Guidance on this relationship is covered in BOM generation, pricing and quote automation.

    Maintainability and governance

    Large assembly models become difficult to maintain when structure, rules and ownership are unclear. A practical governance model should define:

    • which team owns each assembly and its rules;
    • which system is authoritative for item numbers, revisions and released BOMs;
    • how common subassemblies are reused across product families;
    • how obsolete parts and superseded revisions are blocked;
    • how effective dates, plants and regional variants are handled;
    • how rules are named, documented and tested;
    • which changes require engineering, manufacturing or commercial approval;
    • how configuration results are traced back to the options and rules that created them.

    Modular product models are generally easier to maintain than one large flat model, but excessive modularization also creates problems. A subassembly should represent a meaningful reusable or governed unit. Creating a separate node for every minor component can make navigation, testing and integration unnecessarily complex.

    Testing assembly logic

    Testing should cover both valid and invalid configurations. A useful test set includes normal products, boundary values, incompatible options, missing selections, revision changes and downstream output checks.

    Test area Example
    Selection validity Confirm that a high-pressure pump cannot use an unrated seal assembly.
    Quantity calculation Verify that conveyor support quantities change correctly with length.
    Variant selection Confirm that the correct motor and coupling are selected for each power range.
    BOM completeness Check that required fasteners, brackets and control components are included.
    Revision control Ensure an obsolete subassembly cannot be selected after its effective end date.
    Integration output Verify that item numbers, quantities and revisions are accepted by ERP or PLM.
    Engineering escalation Confirm that an out-of-range dimension creates an ETO review rather than an invalid release.

    Automated test cases are particularly useful when a common subassembly is reused across many product families. A change to a motor, valve, enclosure or mounting pattern can have consequences in every parent assembly that uses it.

    Common limitations and implementation risks

    • Confusing sales options with physical structure: not every selectable option is a component, and not every component should be exposed to sales users.
    • Duplicated assembly definitions: copies of the same subassembly can diverge and produce inconsistent pricing or BOM results.
    • Unclear system ownership: CPQ, ERP, PLM and CAD may each hold part of the product definition. Without clear ownership, revisions become difficult to control.
    • Hidden engineering assumptions: rules based on undocumented calculations are difficult for sales, engineering and IT to maintain.
    • Overly flat models: a large list of individual components makes dependencies and reuse difficult to understand.
    • Overly deep models: excessive hierarchy can slow configuration and complicate integrations, reporting and user interfaces.
    • Incomplete downstream mapping: an assembly may configure correctly but fail when ERP requires a specific item, unit, plant or routing.
    • Unsupported automation claims: a CPQ product may support configurable options but not native EBOM, MBOM, CAD or engineering calculations.

    These risks should be addressed during requirements analysis and implementation planning. See the guide to manufacturing CPQ implementation, testing and governance and the overview of CPQ integrations with ERP, PLM, PDM, CAD and MES.

    Recommended implementation approach

    1. Map the current product structure: document finished products, assemblies, subassemblies, options, common parts and engineered variants.
    2. Separate structure from rules: identify what the product contains and what conditions determine inclusion, substitution or quantity.
    3. Classify each assembly: mark it as standard, configurable, purchased, manufactured, phantom, engineered or service-related according to the manufacturer’s processes.
    4. Define ownership: decide whether CPQ, ERP, PLM, PDM or CAD owns each item, revision, BOM and design record.
    5. Model a representative product family: choose a product with meaningful configuration complexity rather than a simple demonstration product.
    6. Connect downstream outputs: test quote lines, prices, BOMs, CAD parameters, engineering tasks and ERP transactions.
    7. Test reuse and change impact: modify a shared subassembly and evaluate every affected parent product.
    8. Establish release governance: document approvals, effective dates, revision rules, ownership and regression testing.

    The goal is not to reproduce every legacy engineering record inside CPQ. The goal is to hold enough product and rule information to guide valid configuration and create reliable downstream outputs, while preserving the appropriate system of record for detailed engineering and production data.

    Related manufacturing CPQ concepts

    Assemblies and subassemblies are closely connected to product configuration, product models and configuration rules, as well as configure-to-order and engineer-to-order workflows. They also relate to configurable BOMs, engineering automation, costing, quote generation and enterprise integration. For a broader introduction, see the guide to manufacturing CPQ.

    Frequently asked questions

    1. What is an assembly in product configuration?

    An assembly is a product structure made from multiple components or lower-level assemblies. In manufacturing CPQ, it may represent a functional module, manufacturing unit, purchased package or configurable section of a finished product.

    2. What is a subassembly?

    A subassembly is an assembly used inside a larger assembly. Examples include a motor-and-coupling module in a pump package or a drive module in a conveyor.

    3. Are assemblies the same as BOMs?

    No. An assembly is a structural product concept, while a BOM is a formal list of components and quantities for a product, variant or manufacturing process. A CPQ product model may resolve into one or more BOM structures.

    4. Can a CPQ configurator generate subassemblies automatically?

    Some manufacturing CPQ systems can generate or resolve configurable subassemblies. Others only pass selections and parameters to ERP, PLM, PDM or another engineering system. This capability must be verified for the specific platform.

    5. How do assembly rules prevent configuration errors?

    Rules can include required assemblies, exclude incompatible variants, select approved substitutions and calculate quantities. They can prevent combinations such as an undersized motor, incompatible seal or incorrectly rated enclosure.

    6. Should every component be modeled as a separate subassembly?

    No. Separate subassemblies should represent meaningful reusable, functional, manufacturing or governed units. Modeling every small component as a separate module can make the product model harder to maintain.

    7. How do assemblies affect pricing?

    Assembly contents can contribute material, labor, purchased-component, testing and engineering costs. An assembly may also carry a price or surcharge, although commercial pricing does not always mirror the physical BOM exactly.

    8. How do assemblies affect CAD automation?

    Selected assemblies can provide CAD variants, dimensions, mounting locations, materials and parameters. When the necessary CAD integration and templates exist, these inputs can produce product-specific models or drawings.

    9. What is the difference between an EBOM and an MBOM for assemblies?

    An engineering BOM represents the designed product, while a manufacturing BOM represents how the product is built. Manufacturing may reorganize or combine engineering assemblies for production operations.

    10. How are assemblies used in configure-to-order manufacturing?

    In configure-to-order manufacturing, approved assemblies and subassemblies are selected from a defined product model. The resolved structure should normally map to known parts, routings and production data.

    11. How are assemblies used in engineer-to-order manufacturing?

    In engineer-to-order manufacturing, assemblies may include calculated dimensions, engineered placeholders or review conditions. CPQ can define requirements and initiate engineering work rather than fully determining every component.

    12. Can one subassembly be reused in several products?

    Yes. Reuse is a major reason to model subassemblies explicitly. The shared module must have controlled revisions, compatible interfaces and rules that work in each parent product.

    13. Which system should own assembly data?

    There is no universal answer. CPQ may own commercial configuration logic, PLM or PDM may own design structures, and ERP may own released manufacturing items and plant-specific data. Ownership and synchronization must be defined during implementation.

    14. What happens when a selected assembly is not buildable?

    A well-designed model should block the configuration, request a missing selection, calculate a valid alternative or route the order to engineering review. It should not silently create an incomplete production structure.

    15. How should assembly changes be tested?

    Test valid and invalid combinations, quantity calculations, BOM completeness, revisions, pricing, CAD outputs and integrations. Also test every major parent product that reuses the changed subassembly.

    16. Are assemblies visible to sales users?

    They can be, but they do not have to be. Sales users may select business-level options such as capacity or environment, while the CPQ model resolves the underlying assemblies and components automatically.

    17. How do assemblies support dealer or distributor configuration?

    They allow dealers to work with understandable product choices while the system applies technical rules and resolves the required modules. Permissions may limit access to engineering-level details or sensitive costs.

    18. What is a phantom assembly?

    A phantom assembly is a logical grouping used for planning or structuring a BOM that may not be built or stocked as a separate physical unit. Whether and how it is supported depends on the manufacturing system and integration design.

    19. What is the main implementation mistake with assembly modeling?

    A common mistake is copying an existing BOM into CPQ without defining configuration behavior, ownership, revisions and downstream mappings. A usable product model must explain how customer choices produce a valid product structure.

    Semantic map

    • CPQ connects customer requirements to configurable product structures.
    • Assemblies organize components into functional or manufacturing units.
    • Subassemblies provide reusable modules within larger product structures.
    • Configuration rules control assembly inclusion, exclusion, substitution and quantity.
    • Constraints prevent incompatible or unbuildable combinations.
    • Configured products can generate resolved BOMs when the CPQ platform supports that capability.
    • EBOMs represent designed products and MBOMs represent manufacturing structures.
    • CAD automation can use configured assembly parameters to create product-specific design outputs.
    • Assembly content contributes to costing, pricing, lead-time estimation and quote generation.
    • CPQ exchanges configuration and order data with ERP, PLM, PDM, CAD and MES through integrations or APIs.
    • CTO uses approved assemblies, while ETO may use engineered assembly requirements and review gates.
    • Assembly governance controls ownership, revisions, reuse, testing and release status.