Tag: sales-to-engineering handoff

  • Visual CPQ: How Visual Product Configuration Works

    Visual CPQ combines interactive product visualization with configure, price, quote (CPQ) logic. A user selects dimensions, materials, components or accessories and sees the configured product change in a 2D or 3D view. Behind the interface, a product model validates the choices, calculates technical and commercial results, and may generate a bill of materials (BOM), CAD output, quotation or manufacturing handoff.

    In manufacturing, visual CPQ is more than a sales image or product selector. A useful implementation connects the visual representation to the same configuration data and rules used for engineering, pricing and production. For example, configuring an industrial pump may change the pump casing, impeller, motor, coupling, baseplate and dimensions in the visualization. The system may also check flow and pressure requirements, calculate price, create a configurable BOM and pass approved data to enterprise systems.

    This guide explains how visual product configuration works, what systems it requires, where it fits in the sales-to-engineering process, and what manufacturers should verify before implementation.

    What is visual CPQ?

    Visual CPQ is a manufacturing CPQ capability that lets users configure a product through an interactive 2D, 3D or augmented visual representation while the system applies product rules, engineering logic, pricing and quoting processes.

    Traditional CPQ may present a sequence of forms, dropdowns and checkboxes. Visual CPQ adds a visual layer that represents the selected product configuration. Depending on the platform and implementation, the visual layer may show:

    • Product options, such as motors, valves, seats, handles or control panels.
    • Dimensional changes, including length, width, height, capacity or mounting positions.
    • Material and finish selections.
    • Optional assemblies and accessories.
    • Product exclusions or unavailable combinations.
    • Configuration status, warnings and missing information.
    • Product-specific images, drawings or three-dimensional models.

    The visual component does not replace the configuration engine. It provides an interactive representation of the product model. The configuration engine remains responsible for determining whether choices are valid and what technical, commercial and manufacturing data should result.

    Manufacturers should therefore distinguish between a visual product configurator and a complete visual CPQ solution. A visual configurator may change images or display selected options without generating a valid BOM, calculating engineering values or supporting downstream production. Visual CPQ connects visualization to those broader processes, although the exact capabilities vary by product and implementation.

    How visual product configuration works

    A visual CPQ workflow normally contains several connected layers: the user interface, product model, rules engine, visualization data, engineering calculations, commercial logic and enterprise integrations.

    1. The user selects product requirements

    The process begins with a guided configuration experience. A salesperson, dealer, engineer or customer may specify requirements such as load, flow rate, operating temperature, voltage, dimensions, capacity, environment or intended application.

    In an industrial machinery example, the user might choose:

    • Machine type and operating capacity.
    • Working width and overall length.
    • Drive motor and gearbox.
    • Material grade and surface treatment.
    • Safety enclosure and access doors.
    • Control system and electrical supply.
    • Installation location and required accessories.

    The interface can expose direct options or ask requirement-based questions. The latter is often called guided selling. Guided selling recommends or narrows products based on user needs; it is not the same as a rules engine. The system still needs configuration rules to validate the final engineered combination.

    2. The configuration engine evaluates rules

    Each selection is evaluated against the product model. Rules may determine which options are available, which components are required, which combinations are prohibited and which values must be calculated.

    Common rule types include:

    Rule type Manufacturing example Purpose
    Compatibility rule A high-temperature seal is required for a specified process temperature. Prevents incompatible selections.
    Dependency rule A variable-frequency drive requires a compatible motor and control cabinet. Adds required components.
    Exclusion rule A particular mounting arrangement is unavailable with a large motor. Blocks invalid combinations.
    Calculation rule Frame dimensions change when conveyor length exceeds a threshold. Derives technical values.
    Selection rule A pressure class is selected based on operating pressure and temperature. Automates engineering choices.
    Commercial rule Dealer discount or freight treatment depends on market and configuration. Controls price and terms.

    Rules may be implemented as decision tables, constraints, formulas, scripts, object relationships or a combination of these methods. A constraint-based configuration approach describes valid and invalid states across many variables. A rules-based approach often expresses explicit conditions and consequences. In practice, manufacturing systems frequently use both.

    For a deeper explanation of product models, dependencies and validation, see the manufacturing product configuration guide.

    3. The visual model responds to configuration changes

    After a valid selection or an in-progress selection, the visual layer updates the representation. A component may appear, disappear, move, change colour or change geometry. Dimensional labels may update when a parameter changes.

    There are several common approaches:

    • Image-based configuration: The system switches product images or assembles layered images. This can be practical for products with a limited number of visual variants.
    • Parametric 3D configuration: A three-dimensional model changes dimensions, components or geometry based on configuration variables.
    • Component assembly: The viewer combines reusable 3D parts into an assembly. This is useful when options correspond to modular components.
    • CAD-driven visualization: Configuration data is passed to a CAD or engineering automation process that produces a product-specific model or drawing.
    • Web-based 3D visualization: A browser-based viewer displays models using web-compatible formats and communicates with the CPQ application through APIs.

    The visual output may be immediate, while a detailed CAD regeneration happens later. This distinction matters. A lightweight viewer can provide fast interaction, but it may not represent every manufacturing detail. A CAD-generated output can be more authoritative, but it may require more processing time and engineering data.

    4. Engineering calculations and validation are applied

    Visual changes should not be treated as proof that a configuration is manufacturable. The system may need to perform engineering calculations such as:

    • Motor sizing and power requirements.
    • Pump duty-point or pressure calculations.
    • Structural load and deflection checks.
    • Thermal or airflow calculations.
    • Electrical load, voltage and enclosure calculations.
    • Clearance, reach and interference checks.
    • Material quantity and dimensional calculations.
    • Weight, centre-of-gravity or transport calculations.

    Some CPQ platforms provide calculation features; others call external engineering services, CAD systems or custom applications. Manufacturers should verify whether a claimed calculation is a formal engineering validation, a simple sizing formula or only a recommendation.

    5. The configured product produces commercial and manufacturing outputs

    Once the configuration is valid, the CPQ application can calculate price and generate quote content. In manufacturing, the output may also include structured product data.

    A typical result can contain:

    • Configured product identifier and revision.
    • Selected options and parameter values.
    • Technical specifications.
    • Pricing, discounts, surcharges, taxes or freight assumptions.
    • Configurable BOM or order-specific BOM.
    • Engineering notes and approval status.
    • Product images, rendered views or drawings.
    • CAD files or references to generated CAD outputs.
    • Data for enterprise resource planning (ERP), customer relationship management (CRM), product lifecycle management (PLM) or manufacturing execution systems (MES).

    A BOM is not automatically the same as a CAD assembly. An engineering BOM (EBOM) describes the product from an engineering perspective. A manufacturing BOM (MBOM) structures components and operations for production. A configurable BOM may contain rules or options that resolve into an order-specific structure. The required output depends on whether the next step is quotation, engineering review, purchasing or manufacturing release.

    The relationship between BOMs, pricing and quote generation is covered in the BOM, pricing and quoting guide.

    Visual CPQ architecture

    A practical visual CPQ architecture commonly includes the following components:

    Layer Responsibility Typical data
    Experience layer Provides the configuration interface and visual interaction. Questions, options, dimensions, views and user permissions.
    Product model Defines products, variants, components and attributes. Features, materials, components, revisions and option relationships.
    Rules and constraints Validates combinations and derives values. Dependencies, exclusions, formulas, constraints and approvals.
    Visualization engine Displays the configured product. Images, 3D meshes, assembly metadata, camera views and annotations.
    Engineering services Performs calculations or generates technical outputs. Parameters, sizing inputs, CAD templates, drawings and calculations.
    Commercial engine Calculates costs, prices and quote terms. Price lists, cost models, discounts, currencies and approval thresholds.
    Integration layer Moves approved data between systems. Product IDs, BOMs, configurations, orders, documents and status.

    These layers may be delivered by one platform or distributed across CPQ, CAD, PLM, ERP and custom services. A manufacturer should evaluate the complete data flow rather than assuming that a single visual interface owns every product record.

    How visual CPQ connects CAD and engineering automation

    CAD means computer-aided design. In a visual CPQ workflow, CAD can be used in three different ways.

    CAD as a visualization source

    Existing CAD models can be simplified, converted or published for browser-based visualization. This approach provides a visual representation without regenerating the full engineering model for every interaction.

    CAD as a parametric output engine

    Configuration parameters can be passed to a parametric CAD template. The CAD process then changes dimensions, suppresses features, selects components or creates a product-specific assembly. The resulting model may be used to generate drawings, neutral files or manufacturing documentation.

    CAD as a downstream engineering system

    CPQ may send a validated configuration to CAD or product data systems after quotation or order approval. Engineering automation can then create or complete the detailed design. This is common where the product has significant engineered-to-order content.

    These approaches have different governance requirements. A visual model may be suitable for communication but not for manufacturing release. A CAD output may be geometrically accurate but still require engineering approval, tolerance definition, material verification and production planning. More information is available in the CAD and engineering automation guide.

    Manufacturing example: configuring an industrial pump skid

    Consider a pump manufacturer selling configurable skid-mounted systems. The buyer or sales engineer selects flow rate, pressure, fluid type, temperature, motor voltage, pump material, valve arrangement, instrumentation and skid dimensions.

    The visual CPQ process might work as follows:

    1. The user enters duty requirements and installation constraints.
    2. The system recommends compatible pump families and motor ranges.
    3. Rules exclude materials that are unsuitable for the selected fluid or temperature.
    4. The visualization adds the chosen pump, motor, valves, instruments and access features.
    5. A calculation service checks pump selection and motor requirements.
    6. Skid length and baseplate dimensions are recalculated.
    7. The configured BOM includes the pump, motor, coupling, base, valves, fittings, instruments and fasteners.
    8. Pricing applies component prices, engineering charges, options, freight assumptions and commercial approvals.
    9. A quote displays the configured visual, technical specifications and commercial terms.
    10. After approval, configuration data is sent to ERP and engineering systems for order processing and detailed documentation.

    If the pump skid is standard enough for configure-to-order (CTO), the rules may resolve most of the design automatically. If each skid requires substantial new design work, the process may be engineer-to-order (ETO), with the visual configuration acting as a controlled starting point for engineering rather than a complete design release.

    Visual CPQ in the sales-to-engineering handoff

    The main operational value of visual CPQ is not only that customers can see a product. It can create a shared, structured definition of what was sold.

    A strong handoff includes:

    • A unique configuration identifier.
    • Revision and model version.
    • All selected options and parameter values.
    • Resolved components and quantities.
    • Calculation results and assumptions.
    • Exceptions, warnings and engineering review requirements.
    • Approved drawings, images or CAD references.
    • Commercial status and approval history.

    This is different from sending engineering a PDF or salesperson’s notes. Documents may be useful, but structured configuration data is easier to validate, reuse and map to ERP, PLM, PDM or MES processes. PDM means product data management, while MES means manufacturing execution system. Neither is interchangeable with CPQ: CPQ manages configuration and commercial decisions, whereas PDM manages product files and revisions and MES manages shop-floor execution data.

    See the guide to configure-to-order, engineer-to-order and sales-to-engineering workflows for a broader process view.

    Benefits of visual CPQ for manufacturers

    • Better product understanding: Sales teams, dealers and buyers can see the effect of options that are difficult to explain in text.
    • Earlier detection of misunderstandings: A visual representation can reveal incorrect orientation, access assumptions or missing accessories before order release.
    • Reduced manual re-entry: A structured configuration can be reused for pricing, quote documents, BOMs and engineering tasks.
    • More consistent sales engineering: Guided interaction and validation reduce dependence on individual spreadsheet knowledge.
    • Improved quote communication: The quote can show the actual proposed equipment rather than a generic catalogue image.
    • Faster variant definition: Standard components and rules can reduce repetitive design work for repeatable products.
    • Support for dealer and self-service channels: Visual configuration can make complex products easier to sell through authorized channels, provided the rules are governed centrally.

    Limitations and risks

    Visual CPQ does not remove the underlying complexity of engineered products. It can expose or manage that complexity, but it cannot compensate for poor product data or incomplete rules.

    • Visual accuracy may not equal engineering accuracy: A model can look correct while omitting tolerances, internal parts, materials or manufacturing constraints.
    • Large option spaces are difficult: Many product variants can create complex model maintenance and slow visualization performance.
    • CAD data may be unsuitable for direct web use: Detailed models often require simplification, conversion, security controls and performance testing.
    • Rules can become difficult to govern: Duplicated formulas and undocumented exceptions make changes risky.
    • Engineering calculations may remain external: Integration with specialist tools can require custom services, data mapping and validation.
    • Configuration and manufacturing structures may differ: The product selected by the customer may need transformation into an EBOM, MBOM or production order structure.
    • ETO work still needs engineering review: A visual configuration should not be presented as automatic design release when substantial engineering remains.
    • Data ownership can be unclear: Product, CAD, price and manufacturing data may be maintained by different departments and systems.

    Implementation considerations

    Define the authoritative product model

    Decide which system owns product definitions, component identifiers, revisions, materials, CAD references and lifecycle status. CPQ may consume data from PLM or PDM rather than becoming the master for every engineering object.

    Separate visual, configuration and engineering data

    Map each visual object to a controlled product option or component. Do not rely on image names or informal labels as the only connection between what the user sees and what the ERP or engineering system receives.

    Prioritize high-value configuration paths

    Start with products where visual errors, engineering rework or quote delays create measurable operational problems. A focused model is easier to test than an attempt to represent every product family at once.

    Test rules and outputs together

    Test not only whether the interface allows or blocks a choice, but also whether the resulting price, BOM, CAD output, technical specification and integration message are correct. Use valid, invalid, boundary and change-impact test cases.

    Plan model governance

    Assign ownership for rules, visual assets, CAD templates, prices, BOM mappings and integrations. Establish review processes for product revisions, obsolete components, engineering changes and market-specific pricing.

    Measure operational outcomes

    Useful measures may include configuration error rate, engineering clarification workload, quote cycle time, percentage of quotes requiring manual re-entry, BOM correction rate, CAD automation success rate and time from order approval to engineering release. Measures should distinguish improvements caused by better rules from improvements caused only by a redesigned user interface.

    Implementation planning, migration, testing and governance are discussed in the manufacturing CPQ implementation guide. System boundaries and integration patterns are covered in the CPQ integration guide.

    How to evaluate visual CPQ software

    Evaluation question Why it matters
    Can the platform represent dimensions, dependencies, constraints and calculated values? Visual interaction is useful only when it reflects valid product logic.
    Does the 3D viewer use configurable components, parametric geometry or static assets? This determines how accurately variants and dimensions can be represented.
    Can the system generate or exchange BOM data? Manufacturing handoff requires structured product output, not only images.
    How does it connect to CAD, PLM, PDM and ERP? Integration determines whether configuration data can be reused downstream.
    Are engineering calculations native or external? The answer affects architecture, validation and implementation effort.
    Can users distinguish warnings, invalid states and engineering review requirements? Not every non-standard configuration should be silently accepted.
    How are visual assets and product rules versioned? Visual output must remain aligned with released product definitions.
    Can the platform support CTO and ETO workflows? Manufacturers need to know whether the result is an order-ready configuration or an engineering starting point.
    Are APIs available for headless, dealer or ecommerce channels? Multiple channels may need to use the same product model and rules.

    Do not evaluate visual CPQ by screenshots alone. Request a demonstration using representative products, including dimensional changes, incompatible options, calculated selections, BOM output, CAD handoff and an ERP or PLM integration scenario where relevant.

    Visual CPQ versus related technologies

    Technology Primary role Relationship to visual CPQ
    Product configurator Defines and validates product options. Visual CPQ adds an interactive representation and may connect configuration to quoting and engineering.
    CAD automation Creates or modifies technical geometry and drawings. Visual CPQ may supply parameters or consume CAD outputs.
    Product visualization Displays products in 2D or 3D. Visualization may exist without rules, pricing or manufacturing outputs.
    Guided selling Recommends products or options based on requirements. It can be part of the interface but does not replace configuration validation.
    CRM Manages customer, opportunity and sales activity data. CRM may launch CPQ and store quote status but is not normally the product rules authority.
    ERP Manages enterprise, order, inventory, purchasing and financial processes. ERP may receive configured items, BOMs, prices or orders from CPQ.
    PLM or PDM Manages product definitions, files, revisions and lifecycle data. These systems may provide controlled engineering data to CPQ.

    Frequently asked questions

    What is visual CPQ?

    Visual CPQ is CPQ software that combines product configuration and quoting with an interactive 2D or 3D representation of the configured product. In manufacturing, it may also connect to engineering, BOM, CAD and enterprise workflows.

    How is visual CPQ different from a product configurator?

    A product configurator validates options and parameters. Visual CPQ adds a visual representation and commonly connects the validated configuration to pricing, quoting and downstream outputs. The exact scope depends on the software.

    Does visual CPQ always include 3D?

    No. Some implementations use 2D images, layered graphics, drawings or simplified product views. Three-dimensional visualization is an option, not a requirement for every visual CPQ project.

    Can visual CPQ generate CAD models?

    Some platforms integrate with CAD automation or parametric templates, while others only display prepared visual assets. CAD generation should be verified for the specific CAD system, product family and required output.

    Can visual CPQ generate a BOM?

    Some manufacturing CPQ systems can resolve a configurable BOM or produce an order-specific BOM. Others pass configuration selections to ERP, PLM or a separate BOM service. This capability should not be assumed.

    Is a visual model the same as a manufacturing model?

    No. A visual model may omit internal components, tolerances, materials or production information. It can communicate the proposed product without being suitable for manufacturing release.

    What product data does visual CPQ require?

    It commonly requires product families, options, components, attributes, dimensions, rules, visual assets, prices and identifiers. Engineering use cases may also require CAD templates, calculation inputs, BOM mappings and revision data.

    What rules are used in visual product configuration?

    Typical rules define compatibility, dependencies, exclusions, required components, dimensional calculations, engineering limits and commercial conditions. Rules may be represented as constraints, formulas, decision tables or scripts.

    Can visual CPQ support engineer-to-order products?

    It can support ETO by capturing requirements, creating a controlled starting configuration and passing structured data to engineering. It does not automatically eliminate engineering design work or approval.

    What is the role of CAD in visual CPQ?

    CAD can provide visualization assets, respond to configuration parameters, generate product-specific geometry or produce drawings. The role depends on whether the manufacturer needs communication-quality visuals or engineering-grade outputs.

    How does visual CPQ support configure-to-order?

    For CTO products, the system can validate selections within a predefined product model, resolve components and pass the result to order and production processes. The degree of automation depends on data quality and integration.

    Can customers use visual CPQ directly?

    Yes, some manufacturers expose visual configuration to customers, dealers or ecommerce users. The interface should limit access to appropriate options and protect pricing, engineering and product data.

    Does visual CPQ replace sales engineers?

    No. It can automate repeatable selections and reduce manual work, but sales engineers remain important for unusual applications, requirements analysis, engineering review and non-standard configurations.

    How does visual CPQ connect to ERP?

    It may send configured product identifiers, option values, prices, BOMs, documents or order data through APIs, middleware or integration services. The exact mapping depends on the ERP and the manufacturer’s process.

    How does visual CPQ connect to PLM or PDM?

    It may consume released product, CAD and revision data from PLM or PDM, or send approved configuration information back for engineering processing. System ownership and revision control must be defined explicitly.

    What is the biggest implementation risk?

    A common risk is building an attractive visual interface without a governed product model, rules, identifiers and downstream data structure. The result may look correct but still require manual engineering correction.

    How should manufacturers test visual CPQ?

    Test valid and invalid combinations, dimension boundaries, rule changes, visual accuracy, prices, BOMs, CAD outputs, approval paths and integration messages. Test complete product scenarios rather than isolated interface controls.

    Semantic map

    The relationships below summarize how visual CPQ connects configuration, visualization, engineering and manufacturing systems.

    • Visual CPQ uses product models to represent configurable products.
    • Configuration rules prevent invalid combinations.
    • Constraints validate dimensions, capacities and engineering limits.
    • Configured options update visual product representations.
    • Parametric CAD uses configuration parameters to generate product-specific geometry.
    • Configured products generate configurable BOMs or order-specific BOMs.
    • Engineering calculations validate technical requirements.
    • CPQ calculates prices from configured components and commercial rules.
    • CPQ generates quotes containing technical and commercial information.
    • CPQ exchanges configuration data with ERP.
    • CPQ may consume controlled product data from PLM or PDM.
    • CAD automation generates product-specific drawings and technical files.
    • Visual CPQ supports sales-to-engineering handoff.
    • Configure-to-order uses validated product configurations for repeatable manufacturing.
    • Engineer-to-order uses configured requirements as a starting point for engineering work.

    Conclusion

    Visual CPQ works by connecting an interactive representation of a product to a governed product model, configuration rules, engineering calculations, pricing logic and downstream systems. Its value in manufacturing comes from making the configured result understandable while preserving the structured data required for quoting, engineering and production.

    The strongest implementations do not treat visualization as a decorative front end. They map every meaningful visual choice to controlled product data, validate the configuration, distinguish visual output from engineering release, and define how the result becomes a BOM, CAD output, quote, order or engineering task. Manufacturers should therefore evaluate visual CPQ as part of the complete configuration and engineering architecture rather than as an isolated 3D viewer.

  • 3D CPQ Software: Complete Guide for Manufacturers

    3D CPQ software combines Configure, Price, Quote (CPQ) capabilities with three-dimensional product visualization and, in some implementations, CAD and engineering automation. For manufacturers, it can show customers and sales teams what a configured machine, vehicle, enclosure or assembly will look like while validating configuration rules, calculating price and producing downstream engineering data.

    The most important distinction is that 3D visualization and manufacturing CPQ are not the same thing. A 3D viewer may display selectable options without understanding engineering constraints or producing manufacturing data. A manufacturing-oriented 3D CPQ system connects the visual model to a product model, configuration rules, calculations, pricing, bills of material (BOMs), computer-aided design (CAD) outputs and enterprise systems where those capabilities are implemented.

    This guide explains how 3D CPQ works, what data it requires, how it supports the sales-to-engineering handoff, where it fits in the technology stack, and what manufacturers should verify before selecting a platform. For the broader subject, see the guide to manufacturing CPQ software.

    What is 3D CPQ software?

    3D CPQ software is a product configuration and quoting system that represents configurable products in three dimensions while applying product rules, engineering logic, pricing and quoting workflows. Depending on the architecture, the 3D model may be a visual representation only, a parametric model driven by configuration values, or a connected CAD output used to generate drawings and manufacturing data.

    A typical 3D CPQ interaction might allow a user to select a pump type, alter connection orientation, choose a motor, set dimensions and add accessories. The system can update the three-dimensional view, reject incompatible combinations, calculate price and produce a quote. More advanced implementations can also create a configurable BOM, an engineering BOM (EBOM), a manufacturing BOM (MBOM), product-specific drawings or a CAD file.

    These capabilities are not automatically included in every CPQ product. Buyers should evaluate visualization, configuration, CAD automation, BOM generation, engineering calculations and integrations as separate capabilities.

    How 3D CPQ differs from generic sales CPQ

    Generic sales CPQ usually focuses on selecting commercial products, applying discounts and producing a proposal. Manufacturing CPQ must often model the physical product and its engineering consequences. A configuration can affect dimensions, materials, structural loads, motor sizing, electrical requirements, production operations and compliance documentation.

    Capability Generic sales CPQ Manufacturing-oriented 3D CPQ
    Product selection Options and packages Options, dimensions, components, materials and engineering parameters
    Validation Commercial dependencies Commercial, geometric, mechanical, electrical and manufacturing constraints
    Visualization Optional product images Interactive 3D representation of the configured product or assembly
    Outputs Quote and proposal Quote plus BOM, configuration record, CAD outputs or engineering handoff where supported
    Downstream systems Customer relationship management (CRM) and enterprise resource planning (ERP) CRM, ERP, product lifecycle management (PLM), product data management (PDM), CAD and manufacturing systems

    The distinction matters because a visually attractive configurator can still leave engineering teams with incomplete or untrusted data. The objective is not simply to rotate a model on a web page. The objective is to connect customer intent with a valid product definition and repeatable operational outputs.

    How a 3D CPQ architecture works

    A 3D CPQ solution normally contains several related layers. They may be delivered by one platform or connected through application programming interfaces (APIs) and integration services.

    1. Product model

    The product model defines the configurable structure. It may contain product families, modules, features, options, dimensions, materials, components, accessories and dependencies. For example, an industrial air-handling unit model could include fan type, casing width, filter section, heating coil, control panel, access doors and insulation.

    The model should identify which values are customer-selectable, which are calculated, which are inherited from a product family and which are controlled by engineering. It should also distinguish commercial options from physical components. Selecting a premium warranty is not the same kind of event as selecting a larger motor.

    2. Rules and constraints

    Rules determine which combinations are valid and what the system should do when a selection changes. Rules-based configuration uses explicit conditions such as “if option A is selected, option B is required.” Constraint-based configuration represents permitted or prohibited relationships across values, ranges and dependencies. Guided selling helps a user reach a suitable product by asking questions, but it may not provide the full engineering validation required for production.

    Typical rules include:

    • Preventing a pump motor from exceeding the available electrical supply.
    • Requiring a reinforced frame when a machine exceeds a specified load.
    • Limiting enclosure dimensions based on transport or manufacturing constraints.
    • Adding a mounting kit when a selected valve requires a particular connection standard.
    • Preventing two accessories from occupying the same physical position.
    • Changing available materials based on temperature, pressure or chemical exposure.

    Good rule design is central to product configuration and configuration validation. Rules should be testable, traceable to a business or engineering requirement and assigned to an owner.

    3. 3D representation and visualization

    The visualization layer maps configuration values to geometry, colors, materials, labels and assembly states. It may hide or display components, change dimensions, substitute models, update camera views or show connection points.

    There are several common approaches:

    • Configured image or scene: pre-rendered images or simple scene changes provide visual guidance but have limited geometric intelligence.
    • Component-based 3D viewer: the system assembles reusable component models and applies visibility or placement rules.
    • Parametric 3D model: dimensions and geometry respond to configuration parameters.
    • CAD-connected configuration: the CPQ process sends validated parameters to a CAD or design automation service that generates product-specific geometry, drawings or files.

    The correct approach depends on the product and required output. A distributor may need a clear visual explanation of a standard conveyor configuration. An engineer-to-order machine builder may need validated dimensions and CAD data rather than only a visual model.

    4. Engineering calculations

    Some products require calculations before they can be quoted. Examples include pump duty and motor selection, pressure drop, structural capacity, thermal performance, cable sizing, airflow, lifting capacity and vehicle payload.

    Calculations can be embedded in the CPQ model, called from an external engineering service or performed in a connected design application. The implementation should record inputs, formulas, assumptions, units and results. A 3D view should not be treated as proof that the selected product is technically suitable.

    5. Pricing, costing and quoting

    The CPQ system can use configuration results to determine component prices, labor, services, freight assumptions, margins, discounts and approval requirements. Pricing remains a separate concern from geometric visualization. A model can look correct while a price is wrong, and a correct price does not prove that the configuration is manufacturable.

    For a deeper treatment of this data flow, see BOM generation, costing, pricing and quote automation.

    6. Downstream outputs

    A completed configuration may produce a quote, proposal, configuration summary, BOM, CAD file, drawing request, engineering task or order payload. The exact output depends on the product and the systems connected to CPQ.

    An EBOM is an engineering bill of material that describes the product from a design perspective. An MBOM is a manufacturing bill of material organized for production, including manufacturing structure, operations or assembly requirements. A configurable BOM may contain rules or placeholders that resolve into a specific product BOM after configuration. These structures should not be assumed to be interchangeable.

    Typical data flow from configuration to production

    1. Start with requirements: a customer, dealer or sales engineer enters application requirements such as capacity, dimensions, environment, voltage or material.
    2. Apply product logic: the system proposes valid options and prevents incompatible combinations.
    3. Update the 3D model: the visual representation changes to reflect selected modules, dimensions and accessories.
    4. Run calculations: sizing, performance or compliance calculations determine whether the configuration satisfies technical requirements.
    5. Calculate cost and price: component costs, labor, margins, discounts and commercial rules are applied.
    6. Generate outputs: the system creates the quote and, where supported, configuration data, BOMs, CAD outputs or engineering documents.
    7. Transfer information: approved data moves to CRM, ERP, PLM, PDM, manufacturing execution system (MES) or another production process.
    8. Release and maintain: engineering and product teams manage revisions, effective dates and rule changes.

    This process supports a controlled sales-to-engineering and order-to-production workflow. It does not eliminate the need for engineering review in every situation. Instead, it helps distinguish standard or configure-to-order work from exceptions that require engineer-to-order handling.

    Manufacturing examples of 3D CPQ

    Industrial machinery

    A machinery builder may configure frame length, guarding, conveyor width, drive package, sensors and control architecture. The 3D model can show the machine footprint and selected modules. Rules can prevent a motor or guard from conflicting with the chosen frame, while CAD automation may generate a layout drawing for customer approval.

    Pumps and valves

    A pump configuration may depend on flow, head, fluid, temperature, materials, seal type, motor, connection standard and mounting arrangement. The system may use engineering calculations to narrow compatible models, display the selected assembly and generate a component list. The visualization is useful, but hydraulic and mechanical validation remain essential.

    Electrical equipment and enclosures

    An enclosure configurator may manage width, height, depth, doors, gland plates, cooling, disconnects and internal components. Three-dimensional placement can reveal clashes and improve communication with the customer. The system may also need to calculate heat dissipation, verify space requirements and generate a panel layout or manufacturing request.

    Specialty vehicles

    A vehicle builder may configure chassis, body modules, seating, storage, lifting equipment, electrical packages and safety options. A 3D view helps stakeholders understand the final vehicle, while rules protect payload, clearance, mounting and electrical constraints. The downstream result may be a vehicle-specific BOM and engineering task rather than a fully automated production package.

    Benefits of 3D CPQ for manufacturers

    • Clearer customer communication: customers can see the effect of dimensions, modules and accessories before order approval.
    • Earlier detection of configuration issues: visual and rule-based validation can expose missing, overlapping or incompatible selections.
    • Less repetitive engineering work: standard calculations, model assembly and document generation can be automated where the product model is mature.
    • More accurate sales-to-engineering handoff: engineering receives structured configuration data instead of relying only on free-text notes or marked-up proposals.
    • Faster quoting for repeatable products: valid configurations can be priced and documented without restarting the design process for every inquiry.
    • Better dealer and distributor support: channel users can configure products consistently without needing to know every internal engineering rule.
    • Improved change control: product teams can update rules, components, geometry and pricing through governed releases.

    Limitations and risks

    3D CPQ is not a substitute for a product strategy, clean engineering data or a controlled product lifecycle. Common limitations include:

    • High modeling effort: configurable geometry, dependencies and calculations require detailed analysis and maintenance.
    • Incomplete product data: inconsistent part numbers, outdated CAD files, missing dimensions or unreliable costs undermine the result.
    • Rule complexity: unmanaged exceptions can create contradictory rules, slow performance and difficult testing.
    • Visualization gaps: a model may be visually persuasive without representing every internal component, tolerance or manufacturing process.
    • Integration boundaries: data may not transfer cleanly between CPQ, CAD, PLM, ERP or MES if identifiers, revisions and ownership are not defined.
    • Performance and usability: large assemblies and detailed models can create browser, mobile or network performance problems.
    • Over-automation: forcing unusual engineer-to-order products through a standard configurator can create risk instead of removing it.

    Manufacturers should define when a configuration is automatically released, when it requires engineering approval and when it must enter a separate design process.

    3D CPQ and CTO, ETO, MTO and ATO

    Production strategy affects the right level of automation. Configure-to-order (CTO) uses predefined modules and rules to produce a valid product after customer selection. 3D CPQ is often a strong fit when the product architecture is modular and repeatable.

    Engineer-to-order (ETO) creates or significantly changes the design for a specific order. A 3D CPQ system may capture requirements, create a preliminary model and initiate engineering work, but it may not fully automate the final design.

    Make-to-order (MTO) means production starts in response to an order, while assemble-to-order (ATO) combines stocked or predefined modules after ordering. These terms describe production and fulfillment approaches; they do not by themselves prove that a product can be configured automatically.

    Integration with enterprise systems

    3D CPQ usually sits between customer-facing processes and engineering or operational systems. The integration design should identify the system of record for each data type.

    System Typical relationship with 3D CPQ
    CRM Opportunity, account, contact, sales process and quote context
    ERP Item masters, inventory, costs, prices, orders, customers and financial processing
    PLM Product structures, revisions, lifecycle states, engineering changes and released definitions
    PDM CAD files, document metadata, versions and controlled design data
    CAD Parametric models, assemblies, drawings and design automation
    Product information management (PIM) Commercial product descriptions, attributes, media and channel content
    MES Production execution, work instructions, status and manufacturing data

    For integration patterns and ownership questions, see the guide to CPQ integration with ERP, CRM, PLM, PDM, CAD and MES. A practical design should define part-number ownership, revision behavior, configuration identifiers, error handling, security and whether data moves synchronously or through approved release events.

    How to evaluate 3D CPQ software

    Manufacturers should evaluate the complete workflow rather than judging a platform by the presence of a 3D viewer. Important questions include:

    • Can the product model represent modules, variants, dimensions, materials and optional components?
    • Can rules express cross-component, geometric, electrical and engineering constraints?
    • Is the 3D model visual-only, component-based, parametric or connected to CAD?
    • Can the system expose configuration values to CAD automation or engineering calculations?
    • What outputs are supported: quote, configuration record, configurable BOM, EBOM, MBOM, drawing or CAD file?
    • How are part numbers, revisions, units and engineering attributes managed?
    • Can users distinguish standard CTO configurations from ETO exceptions?
    • How are rule changes tested, approved, versioned and rolled back?
    • What happens when an ERP, PLM or CAD service is unavailable?
    • Can the system support sales engineers, dealers, distributors and customer self-service without exposing uncontrolled data?
    • How are large assemblies, mobile devices and high-resolution models handled?
    • Which capabilities are native, which require customization and which depend on third-party applications?

    Vendor claims should be validated with a representative product model and real outputs. A useful proof of concept should include incompatible selections, dimensional changes, a pricing change, a BOM comparison, a CAD or drawing requirement and an exception that requires engineering review. The manufacturing CPQ comparison and selection guidance can help structure this evaluation.

    Implementation approach

    Define the first product scope

    Start with a product family that has meaningful configuration volume and reasonably stable rules. Avoid beginning with the most customized product if its design logic is not yet documented.

    Establish data ownership

    Document who owns item numbers, CAD models, prices, costs, technical attributes, product rules, revisions and released BOMs. A CPQ system should not become an uncontrolled duplicate of ERP or PLM.

    Separate visual logic from engineering logic

    Some rules control what appears in the viewer; others determine whether the product is technically valid. Keep these concerns identifiable even when they are evaluated in one transaction.

    Build and test representative configurations

    Test normal, boundary, invalid, discontinued and exception scenarios. Include unit conversions, missing data, revision changes, integration failures and products with large assemblies. A visual inspection alone is not sufficient; compare expected BOMs, prices, calculations and CAD outputs.

    Define release and exception workflows

    Decide when a quote is valid, when an engineering approval is required and how a changed configuration affects an existing quote. This is especially important when a 3D CPQ system supports both CTO and ETO workflows.

    Plan ongoing governance

    Product models require maintenance as components, suppliers, prices, regulations, CAD models and manufacturing processes change. Establish release management, regression testing, rule ownership, usage monitoring and a process for retiring obsolete options. The CPQ implementation guide covers requirements, migration, testing, governance and maintenance in more detail.

    Semantic map

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

    • 3D CPQ software connects product configuration, visualization, engineering and quoting.
    • Product models define configurable products, modules, options, dimensions and components.
    • Configuration rules prevent invalid combinations and trigger dependent selections.
    • 3D visualization represents the selected product configuration.
    • Engineering calculations evaluate technical requirements such as capacity, load, flow or heat.
    • CAD automation generates product-specific geometry, drawings or design files when supported.
    • A configured product can generate a BOM, configuration record or engineering request.
    • An EBOM represents an engineering product structure.
    • An MBOM represents a manufacturing-oriented product structure.
    • CPQ exchanges customer and commercial data with CRM.
    • CPQ exchanges item, price, cost and order data with ERP.
    • CPQ exchanges released product and revision data with PLM or PDM.
    • CTO uses predefined modules and rules for repeatable products.
    • ETO requires engineering work for product-specific designs or exceptions.
    • Sales-to-engineering handoff transfers validated configuration data to downstream teams.

    Frequently asked questions

    1. What is 3D CPQ?

    3D CPQ is CPQ software that combines product configuration and quoting with three-dimensional visualization. In manufacturing, it may also connect configuration values to engineering calculations, BOMs, CAD automation and production systems.

    2. Is a 3D product configurator the same as 3D CPQ?

    No. A 3D configurator may only display product variants. 3D CPQ adds commercial and operational processes such as validation, pricing, quoting and potentially BOM or engineering outputs.

    3. Does every 3D CPQ system generate CAD files?

    No. Some systems provide visualization only, while others connect to CAD or design automation tools. CAD generation must be verified for the specific CAD system, product model and output format required.

    4. Can 3D CPQ generate a manufacturing BOM?

    Some platforms can generate or export BOM data, but not every CPQ system creates an MBOM. The buyer should verify whether the output is an EBOM, MBOM, configurable BOM or simple component list.

    5. Can a 3D model validate engineering requirements?

    Not by itself. Geometry can help identify visual or spatial issues, but technical validation usually requires configuration rules, engineering calculations, simulation or engineering review.

    6. What products benefit most from 3D CPQ?

    It is often useful for configurable machinery, equipment, vehicles, enclosures, HVAC systems, material handling products, electrical assemblies and other products where options affect geometry or customer understanding.

    7. How does 3D CPQ support sales engineers?

    It gives sales engineers a structured way to collect requirements, select valid options, explain the resulting product and produce a quote with clearer engineering information.

    8. Can dealers use 3D CPQ?

    Yes, if the platform supports dealer or distributor workflows and provides appropriate access controls. The manufacturer must decide which options, prices, technical data and outputs each channel user can access.

    9. Does 3D CPQ replace engineering?

    No. It can automate repeatable configuration and documentation, but engineering remains necessary for new products, unusual requirements, exceptions and changes outside the validated product model.

    10. How is 3D CPQ related to PLM?

    Product lifecycle management (PLM) manages product definitions, revisions and lifecycle processes. 3D CPQ uses selected product and engineering data to configure and quote products, with integration required to keep definitions aligned.

    11. How is 3D CPQ related to PDM?

    Product data management (PDM) commonly manages CAD files, documents, metadata and revisions. A 3D CPQ system may retrieve controlled models or send parameters to design automation through a PDM or CAD environment.

    12. Can 3D CPQ support engineer-to-order products?

    It can support ETO by capturing requirements, creating preliminary configurations and initiating engineering tasks. Full automated design generation is not appropriate for every ETO product.

    13. What is the difference between a 3D viewer and a parametric model?

    A viewer displays geometry, while a parametric model changes geometry according to defined parameters. A viewer may show options without being able to calculate or generate the corresponding engineering design.

    14. What data is needed to implement 3D CPQ?

    Typical inputs include product structures, options, rules, dimensions, component identifiers, CAD models, technical attributes, costs, prices, calculations, BOM logic and integration mappings.

    15. How should 3D CPQ configurations be tested?

    Test valid and invalid combinations, boundary values, dimensional changes, pricing, BOM results, CAD outputs, revision changes, integration errors and cases that should be routed to engineering.

    16. Can 3D CPQ work with ERP?

    Many manufacturing CPQ implementations integrate with ERP, but the depth varies. The integration may exchange items, prices, costs, customers, orders, inventory or configuration identifiers. These capabilities must be verified for the chosen platform.

    17. Is 3D CPQ suitable for customer self-service?

    It can be suitable for self-service when the product is sufficiently standardized and the user interface hides unnecessary engineering complexity. Products with frequent exceptions may need sales or engineering involvement.

    18. What is the biggest implementation risk?

    A major risk is attempting to automate an undocumented or unstable product model. Rule ownership, clean data, controlled CAD assets and a clear exception process are prerequisites for reliable results.

    19. How does 3D CPQ affect quote accuracy?

    It can improve accuracy by linking valid configuration selections to prices, components and calculations. It does not guarantee accuracy if source costs, rules, CAD data or integration mappings are incomplete.

    20. What should a 3D CPQ proof of concept include?

    Use a real product family with option dependencies, dimensional changes, an invalid combination, a price change, a BOM requirement, a representative 3D output and at least one engineering exception.

  • Visual Validation of Complex Product Configurations

    Visual validation of complex product configurations uses 2D drawings, 3D models, rendered assemblies or other visual outputs to confirm that a configured product is physically and functionally plausible before it is quoted, engineered or manufactured. In manufacturing Configure, Price, Quote (CPQ), visual validation is more than displaying attractive product images. It connects configuration rules, engineering parameters, computer-aided design (CAD) data and downstream manufacturing information.

    A visual CPQ workflow may show a pump with the selected motor, inlet orientation, base, materials and accessories; a material-handling machine with the chosen frame dimensions and safety guarding; or an electrical enclosure with the correct components and cable entries. The representation helps a salesperson, customer or engineer detect a wrong option, missing clearance, incompatible interface or incorrect dimension while the configuration can still be changed.

    Visual validation does not replace formal engineering review, tolerance analysis or production release. It is an additional validation layer. Its value is highest when the visual output is generated from the same product model and rules that control configuration, pricing, bill of materials (BOM) generation and CAD automation. For background, see the guides to product configuration and CAD and engineering automation.

    What visual validation means in manufacturing CPQ

    Visual validation is the process of comparing a configured product with a generated or selected visual representation to identify errors and confirm that the configuration matches the intended design. The output may be interactive 3D, a static rendering, a simplified digital mock-up, a parametric CAD view, a 2D layout or a dimensioned drawing.

    In a generic sales CPQ application, a product image may change when a user selects a color or accessory. In manufacturing CPQ, the visual output can be driven by engineering variables such as length, capacity, pressure rating, flow rate, voltage, mounting arrangement, material, connection size and orientation. It may also expose the consequences of rules that are not obvious in a list of options.

    Visual output Typical manufacturing purpose Important limitation
    Option-based image Shows selected finish, accessory or product family May not represent exact geometry
    Interactive 3D model Explores assembly structure, orientation and clearance Requires reliable geometry and performance on target devices
    Parametric CAD view Represents dimensions and engineering variants Can require CAD automation and significant model governance
    2D drawing or layout Confirms dimensions, interfaces and mounting points May omit internal components or manufacturing detail
    Rendered product image Improves customer understanding and proposal quality Visual realism does not prove technical validity

    Why visual validation matters for complex products

    Many configuration errors are spatial or geometric rather than purely logical. A rules engine may correctly determine that a motor is compatible with a pump. It may not be sufficient to show whether the selected motor, coupling guard and terminal box fit within the available base or align with the customer’s pipework.

    Visual validation helps expose issues such as:

    • an inlet or outlet facing the wrong direction;
    • an accessory occupying the same space as another component;
    • an enclosure that is too small for the selected electrical equipment;
    • a machine frame that does not provide the required access or maintenance clearance;
    • a selected motor or gearbox that changes the overall height or center of gravity;
    • a vehicle body, chassis and payload arrangement that creates an impractical layout;
    • missing brackets, adapters, guards or mounting hardware;
    • dimensions that differ from the customer’s expected arrangement;
    • an appearance that does not match the technical description in a quotation.

    These checks can reduce avoidable clarification cycles between sales and engineering. They can also improve customer confidence because the buyer sees the physical implications of a choice rather than interpreting a long option list.

    How visual CPQ works

    A visual validation workflow normally combines a product model, configuration rules, geometry, visual states and a data exchange layer. The exact architecture varies. Some systems use native 3D models and parametric CAD. Others use lightweight meshes, modular images or a dedicated visualization engine. A CPQ platform may provide these capabilities natively, through an extension or through integration with CAD, product lifecycle management (PLM) or product data management (PDM) software.

    1. The user selects requirements and options

    The process begins with a guided selling or configuration interface. The user may enter flow rate and pressure for a pump, required heating capacity for an HVAC unit, lifting height for a hoist or body length for a specialty vehicle. The interface then exposes relevant options and hides or rejects incompatible choices.

    Guided selling asks questions to recommend a product or configuration. Rules-based configuration applies explicit conditions such as “if voltage is 480 V, use the appropriate control package.” Constraint-based configuration evaluates permitted relationships and limits, such as a maximum load, dimensional range or compatibility between interfaces. These approaches can work together, but none should be confused with the visual layer itself.

    2. Rules create a valid configuration state

    The product model stores features, options, dimensions, dependencies, calculations and constraints. A configuration engine may validate that a selected pump casing supports the requested pressure, that a valve material is suitable for the specified medium, or that a control panel can accommodate the selected drives.

    Rules should identify not only whether an option is allowed, but also which geometry, metadata and downstream components it activates. Selecting a longer conveyor section, for example, may change the frame model, belt length, guarding, support spacing, motor sizing and BOM quantities.

    3. The visual representation is assembled

    The visualization layer maps configuration values to geometry. This may involve switching component variants, changing dimensions, rotating connection points, adding accessories, suppressing unused components or applying materials and finishes. A modular 3D assembly might combine a standard frame with a selected motor, pump, guard and control cabinet.

    For highly engineered products, geometry may be generated by a CAD system. A CAD integration can pass parameters to a parametric model, rebuild the model and return a lightweight 3D view, drawing or neutral file. In other architectures, the CPQ system uses pre-published geometry variants and does not generate new CAD.

    4. Visual checks and user review occur

    The system can perform automated checks, such as detecting a collision, testing a minimum clearance or verifying that a component has a corresponding visual representation. It can also display warnings and review markers. The customer or salesperson then rotates, sections, zooms or annotates the model and confirms the intended arrangement.

    Visual review should not be treated as an informal substitute for rules. A user may overlook a hidden interference, misread a perspective view or assume that a visually plausible arrangement is mechanically acceptable. Automated rules and engineering approval remain necessary for safety-critical and performance-critical decisions.

    5. Outputs are passed to quoting and engineering

    After validation, the configuration can produce a quote, product description, selected images, a configurable BOM or an engineering request. The engineering handoff should include the structured configuration data, version of the product model, rule results, customer requirements, visual reference and any unresolved warnings.

    The downstream workflow may involve an enterprise resource planning (ERP) system for item and order data, a PLM or PDM system for controlled product and CAD data, and a manufacturing execution system (MES) for production execution. These systems are not interchangeable. The CPQ integration guide explains their different roles.

    Manufacturing examples

    Configured pump skid

    A customer selects a pump capacity, casing material, motor rating, baseplate, valves, instrumentation and pipe connection orientation. A visual model should show the pump, motor, coupling guard, valves and instruments in their relative positions. It may also display dimensions and access zones.

    Configuration rules can validate pressure rating and material compatibility. Engineering calculations may size the motor or impeller. Visual validation can then reveal that a selected instrument is mounted on the wrong side for site access or that the discharge arrangement conflicts with the skid boundary. The generated BOM may include the chosen components, while a CAD process creates a layout drawing for engineering review.

    Industrial air-handling unit

    An air-handling unit may be configured by airflow, casing dimensions, fan type, filters, coils, dampers, access doors, controls and connection direction. Some choices alter the unit length or service clearance. A 3D representation can show whether the selected modules are arranged in the requested order and whether access doors are on the correct side.

    The visual output should be linked to the same parameters used for costing and BOM generation. Otherwise, the sales view might show a standard module while the quote and production data describe a different variant.

    Specialty vehicle

    A specialty vehicle configuration may include chassis, wheelbase, body length, tank or equipment modules, storage compartments, warning systems and payload options. Visual validation can help a user inspect the body layout, equipment position and door openings. However, it does not by itself validate axle loads, road regulations, structural integrity or manufacturing feasibility. Those checks require dedicated engineering rules and approval.

    Data required for visual validation

    A reliable implementation needs more than a library of images. Key data includes:

    • Product structure: families, modules, components, variants and option relationships.
    • Configuration parameters: dimensions, capacities, materials, ratings, orientations and customer requirements.
    • Rules and constraints: compatibility, minimum and maximum values, dependency, exclusion and selection rules.
    • Geometry: 2D drawings, 3D models, lightweight meshes, connection points and coordinate systems.
    • Metadata: component identifiers, revision, status, units, material, visual behavior and source system.
    • Engineering calculations: derived dimensions, sizing results, loads, performance values and calculated options.
    • Manufacturing relationships: item numbers, configurable BOM logic, routings and make-or-buy status.
    • Governance data: product model version, effective dates, approvals and ownership.

    Units and coordinate systems deserve particular attention. A mismatch between millimeters and inches, or between CAD and visualization coordinate conventions, can create apparently valid but physically incorrect results.

    Relationship between visual validation, CAD and BOM generation

    Visual validation sits between configuration and engineering output, but it should be connected to both. CAD automation can generate product-specific geometry, drawings and neutral files. BOM logic can translate the selected configuration into component and quantity data. A visual model may help verify the arrangement, but it is not itself an engineering BOM (EBOM) or manufacturing BOM (MBOM).

    An EBOM describes the product from an engineering design perspective. An MBOM describes how the product is assembled or manufactured, often including manufacturing-specific groupings, consumables and operations. A configurable BOM may contain rules that resolve into different items or quantities for each order. The visual assembly may represent the physical product while the EBOM and MBOM serve different downstream purposes.

    For a detailed treatment of these relationships, see BOM generation, pricing and quote automation. For CAD model generation, drawings and engineering calculations, see CAD and engineering automation.

    Benefits and limitations

    Benefit How it helps manufacturers
    Earlier error detection Finds visible dimensional, orientation and assembly issues before order release.
    Better customer communication Shows the physical result of technical selections and reduces ambiguity.
    Faster sales-to-engineering handoff Provides a shared visual reference and structured configuration data.
    More consistent quoting Aligns displayed options with the product model and selected components.
    Support for distributed sales Helps dealers and sales teams explain complex equipment without recreating designs manually.

    There are important limitations. A rendered model can look correct while using the wrong part number. A simplified visualization may omit fasteners, internal components, tolerances, cable routing or service requirements. Geometry can also become stale when CAD revisions are not synchronized with the CPQ product model. Large assemblies may affect browser performance and require lightweight representations.

    Visual validation is therefore one control in a broader process that includes rule validation, engineering calculations, formal design review, document control, approval and production release.

    Implementation guidance

    Start with high-value configuration risks

    Do not begin by modeling every product variant. Select a product family where visual ambiguity creates measurable rework, long engineering queues or frequent customer clarification. Identify the decisions that most affect geometry, such as orientation, dimensions, module order, mounting arrangement and access clearances.

    Define ownership of product and visual data

    Product management may own commercial options, engineering may own geometry and constraints, and manufacturing may own assembly relationships. Assign responsibility for revisions, approvals, naming, units and publication. Without clear ownership, visual models can diverge from released engineering data.

    Choose the appropriate level of fidelity

    Use lightweight geometry for interactive selection when exact CAD detail is unnecessary. Use parametric CAD or generated drawings when dimensions and interfaces must be reviewed. Decide which internal parts, fasteners, guards, service zones and hidden features need to be visible for the intended decision.

    Test visual and non-visual outputs together

    Test complete configuration scenarios, not just individual options. Confirm that the displayed model, calculated values, quote, configurable BOM, CAD output and engineering handoff describe the same product. Include boundary conditions, invalid combinations, legacy products, revisions, missing geometry and unit conversions.

    Design the handoff process

    Define when a configuration is self-service, when it requires an engineering review and when it becomes an engineer-to-order (ETO) request. A configure-to-order (CTO) product may use approved modules and automated outputs. An ETO product may need engineering work after initial configuration. Both can use visual validation, but the approval and data requirements differ. The manufacturing workflow guide covers these distinctions.

    How to evaluate visual CPQ capabilities

    When evaluating software, ask vendors to demonstrate a real product family rather than a generic catalog. The demonstration should include variable dimensions, incompatible options, accessories, connection orientation, a generated or selected 3D representation, BOM behavior and the handoff to engineering.

    • Can the system display exact configured geometry or only option images?
    • Can dimensions, orientations and component positions change dynamically?
    • Which rules control both the visual output and the product configuration?
    • Can it identify missing, obsolete or unmapped visual assets?
    • Does it integrate with CAD, PLM or PDM, and which system owns revisions?
    • Can it generate drawings or only interactive views?
    • How are configurable BOMs and visual assemblies related?
    • Can users review clearances, interfaces and service access?
    • How are performance and file sizes managed for large assemblies?
    • What happens when the visual model is unavailable or a configuration requires ETO work?
    • Can the system preserve a versioned visual snapshot with the quote?
    • How are changes tested when a product rule or CAD model is revised?

    Capability names are not enough. Some CPQ platforms support product images and interactive configuration but do not generate CAD or manufacturing BOMs. Others rely on specialist visualization or engineering systems. Buyers should verify the actual architecture, supported file types, APIs, ownership model and implementation effort.

    Semantic map

    The following relationships summarize how visual validation fits into manufacturing CPQ:

    • CPQ connects customer requirements to configurable product models.
    • Configuration rules prevent invalid combinations.
    • Engineering parameters drive product dimensions and calculated values.
    • Visual assets represent selected product variants and assemblies.
    • Visual validation exposes spatial and interface errors.
    • CAD automation generates product-specific geometry and drawings.
    • A configured product resolves into a configurable BOM.
    • An EBOM represents engineering structure.
    • An MBOM represents manufacturing structure.
    • CPQ exchanges configuration and commercial data with ERP.
    • CPQ exchanges product and revision data with PLM or PDM.
    • Visual review supports the sales-to-engineering handoff.
    • Engineering approval controls release for production.

    Frequently asked questions

    What is visual validation in CPQ?

    It is the use of generated or selected visual representations to check whether a configured product matches the intended physical arrangement before quoting, engineering or production.

    What is visual CPQ?

    Visual CPQ is a CPQ experience that uses images, 2D drawings, 3D models or CAD-derived views to help users configure and review complex products.

    Is visual CPQ the same as 3D product configuration?

    No. 3D configuration is one form of visual CPQ. Visual validation can also use 2D layouts, dimensioned drawings, rendered views or simplified assemblies.

    Does visual validation replace configuration rules?

    No. Rules determine whether choices are allowed. Visual validation helps users and systems inspect the physical result of those choices.

    Can visual validation detect every engineering error?

    No. It may reveal geometry, orientation and clearance problems, but it does not replace calculations, tolerance analysis, safety review or formal engineering approval.

    Does visual validation require CAD integration?

    Not always. A system can use pre-published images or 3D variants. CAD integration becomes more important when dimensions, drawings or product-specific geometry must be generated.

    How does visual validation improve the sales-to-engineering handoff?

    It gives both teams a shared representation of the requested product and can pass the underlying configuration, warnings, revision and supporting documents with the handoff.

    Can a visual model generate a BOM?

    The visual model itself is not a BOM. A CPQ product model may generate both a visual assembly and a configurable BOM from the same configuration state.

    What is the difference between a visual assembly and an EBOM?

    A visual assembly shows geometry or appearance. An EBOM is a controlled engineering structure of components and relationships. They may be linked but serve different purposes.

    Can visual CPQ support engineer-to-order products?

    Yes, as an early representation or review aid. ETO products still require engineering work, calculations and approval when the final design is not fully defined by standard rules.

    What types of products benefit most from visual validation?

    Products with spatial relationships, variable dimensions, modular assemblies, interfaces or many accessories benefit most. Examples include machinery, pumps, HVAC equipment, electrical enclosures and specialty vehicles.

    How should manufacturers handle missing visual assets?

    The system should flag missing or outdated assets and define a fallback, such as a generic family view or engineering review. It should not silently present an inaccurate image as exact geometry.

    What data drives a visual configuration?

    Typical inputs include options, dimensions, materials, orientations, component identifiers, geometry variants, connection points, rules, calculated values and product revisions.

    How does visual validation affect quote accuracy?

    It can reduce ambiguity and expose incorrect selections, but it does not guarantee pricing accuracy. Pricing must use controlled rules, costs, quantities and commercial policies.

    What should be tested in a visual CPQ implementation?

    Test valid and invalid combinations, dimensions, orientations, clearances, revisions, missing assets, unit conversions, BOM results, CAD outputs and the information passed to engineering.

    Can customers use visual validation in self-service configuration?

    Yes, where the product model is sufficiently standardized and the business accepts the level of automation. Complex or safety-critical configurations may still require internal review.

    How should visual CPQ handle product revisions?

    Visual assets, rules, CAD references and BOM logic should be versioned and released together or through controlled mappings. A quote should preserve the product-model version used for its validation.

    Where does visual validation fit in the CPQ architecture?

    It sits between the configuration model and user-facing or engineering outputs, while exchanging data with CAD, PLM, PDM, ERP and other systems according to the implementation design.

    For broader planning, connect visual validation to CPQ implementation and governance, and review the main manufacturing CPQ guide for the wider configuration, pricing, quoting and production context.

  • 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.