CPQ Guide

Tag: event brokers

  • Webhooks and Event-Driven CPQ Integrations

    Webhooks and event-driven integrations connect a manufacturing Configure, Price, Quote (CPQ) system to the wider product and production technology stack. Instead of relying only on users or scheduled data transfers, systems publish events when important actions occur, such as a configuration being validated, a quote being approved, a product model changing or a manufacturing bill of materials becoming available.

    In a manufacturing environment, this can connect product configuration with customer relationship management (CRM), enterprise resource planning (ERP), product lifecycle management (PLM), product data management (PDM), computer-aided design (CAD), manufacturing execution systems (MES) and ecommerce platforms. The objective is not simply to move sales data faster. It is to keep configuration, engineering, commercial and production processes coordinated while preserving data ownership in each system.

    A webhook is an HTTP callback sent from one application to another when a defined event occurs. An event-driven CPQ integration uses events as the basis for communication and workflow orchestration. For example, a CPQ platform might publish a quote.approved event. An ERP integration can use that event to create or update an order, while a document service generates a proposal and a manufacturing workflow starts a review of the resulting bill of materials (BOM).

    Webhooks are useful, but they are not a complete integration architecture. Reliable manufacturing integrations also require clear event definitions, ownership of product data, stable identifiers, version control, authentication, retry handling, monitoring and rules for resolving failures.

    What are webhooks in CPQ integration?

    A webhook is a notification sent automatically from a source system to a destination URL when something happens. The source system usually sends an HTTP request containing an event name, timestamp, identifier and relevant data. The receiving system accepts the request and starts an action or passes the event to another service.

    For example, after a sales engineer configures an industrial pump, the CPQ system may emit an event containing the quote identifier, configuration identifier, product model version, selected options, calculated price and workflow status. A downstream service can then retrieve the full configuration through an application programming interface (API), rather than relying on the webhook payload to contain every field.

    Webhooks normally support near-real-time notification. They differ from a traditional polling integration, in which a receiving system repeatedly asks whether anything has changed. Polling can be adequate for low-frequency processes, but it may create unnecessary traffic, delay updates or miss changes when polling logic is poorly designed.

    Webhook example for a configurable machine

    Suppose a manufacturer sells a configurable conveyor system. The CPQ product model includes conveyor length, belt material, motor size, frame finish, guarding and control-voltage options. After the configuration passes validation, CPQ publishes configuration.validated.

    1. A configuration service records the valid configuration and its model version.
    2. A pricing service calculates the commercial price using the selected motor, length and options.
    3. A CAD automation service creates a product-specific layout or drawing if supported by the implementation.
    4. A BOM service produces a configurable engineering bill of materials or passes the configuration to an engineering system.
    5. When the customer accepts the quote, CPQ publishes quote.accepted.
    6. ERP creates the sales order or requests confirmation from an order-management workflow.

    The event does not mean that every receiving system must immediately create production data. Each subscriber applies its own business rules and confirms whether the event is relevant.

    What is event-driven CPQ architecture?

    Event-driven architecture is an integration approach in which systems communicate through business events. An event records that something happened, such as a product model being published, a quote being approved or an engineering review being required. Other systems subscribe to events they need.

    A simple implementation may use direct webhooks from CPQ to ERP, CRM or a document service. A larger implementation may place an event broker or message bus between the systems. The broker receives events, stores or routes them, and delivers them to multiple consumers. This reduces direct point-to-point dependencies and allows new consumers to subscribe without changing the CPQ application.

    Integration approach How it works Manufacturing use Important limitation
    Polling A system repeatedly asks another system for changes. Checking periodically for new approved quotes or updated product records. Can introduce delay, unnecessary traffic and duplicate processing.
    Direct API call One system synchronously requests data or an action from another. CPQ requests current material cost or creates an ERP customer record. The source may be blocked by downtime or a slow response.
    Direct webhook A source sends an event notification to a subscribed endpoint. Notify ERP when a quote is accepted or notify CAD when a design job is ready. Requires reliable delivery, security and retry management.
    Event broker Events are published to a managed topic or queue for multiple consumers. Distribute configuration, approval and engineering events across ERP, PLM, MES and analytics. Adds architecture, operations and governance requirements.

    Event-driven integration is usually complementary to APIs. An event can notify a system that a change occurred, while an API provides the authoritative details. This separation is useful when configurations contain large option sets, calculated values, drawings or versioned BOM structures.

    Where webhooks fit in the manufacturing CPQ stack

    Manufacturing CPQ is broader than generic sales quoting. A generic sales CPQ system may focus mainly on selecting products, applying discounts and generating a proposal. Manufacturing CPQ may also validate engineering constraints, perform calculations, create a configurable BOM, trigger CAD automation and hand production-ready information to downstream systems. Not every CPQ platform provides all of these capabilities, so the integration design must reflect the actual product scope.

    System Typical ownership Useful CPQ events
    CRM Accounts, opportunities, contacts and sales activity Configuration started, quote created, quote submitted and quote accepted
    ERP Items, customers, inventory, purchasing, orders, financial data and manufacturing transactions Quote accepted, order released, item unavailable and price update
    PLM Product structures, revisions, change processes and lifecycle status Product model published, revision released and engineering change approved
    PDM CAD files, metadata, document relationships and design revisions CAD job requested, drawing generated and file revision released
    CAD Parametric geometry, assemblies, drawings and design outputs Configuration ready for design automation and output completed
    MES Shop-floor execution, work instructions, routing and production status Order released to production and manufacturing data available
    PIM Commercial product content, descriptions, images and channel data Option content published and product information updated

    Data ownership should be explicit. For example, CPQ may own the selectable product model and configuration rules, while PLM owns released engineering revisions, ERP owns item and order records, and CAD or PDM owns design files. A webhook should not silently make one system the master of data it does not govern.

    Common manufacturing CPQ events

    Event names should describe business facts rather than technical implementation details. The exact names depend on the platform and integration design, but common event categories include:

    • Product model events: product-model.draft-created, product-model.published and product-model.retired.
    • Configuration events: configuration.started, configuration.validated, configuration.invalidated and configuration.revised.
    • Engineering events: engineering-review.required, cad-generation.requested, cad-generation.completed and bom.generated.
    • Commercial events: quote.created, quote.recalculated, quote.submitted, quote.approved and quote.expired.
    • Order events: quote.accepted, order.requested, order.created and order.released.
    • Integration events: erp-synchronization.failed, plm-revision.changed and customer-data.updated.

    An event should identify the business object, its version and the source of truth. A useful event envelope may include an event identifier, event type, occurrence time, source application, schema version, tenant or business unit, correlation identifier and object identifiers.

    {  "eventType": "configuration.validated",  "eventId": "evt-12345",  "occurredAt": "2025-01-15T10:30:00Z",  "source": "manufacturing-cpq",  "schemaVersion": "1.0",  "configurationId": "cfg-7842",  "quoteId": "q-3109",  "productModelVersion": "pump-series-4.2",  "correlationId": "quote-q-3109"}

    The example is illustrative. A production schema must be agreed by the participating systems and documented as part of the integration contract.

    How configuration, pricing, BOM and CAD events relate

    Configuration, pricing, quoting and engineering output are related but distinct processes. A valid configuration does not automatically mean that a final price, engineering BOM or production order exists.

    Configuration validation

    The product model defines features, options, dependencies, constraints and calculations. Rules may prevent incompatible combinations, such as selecting a motor that cannot provide the required torque or choosing a material unsuitable for the specified temperature range. Learn more in the guide to product configuration and rules.

    Pricing and costing

    A pricing event may trigger list-price lookup, customer-specific pricing, discount approval, freight calculation, currency conversion or cost-margin validation. Cost data may come from ERP, purchasing or a costing service. A configuration can be technically valid while still requiring commercial approval because the margin is below a threshold.

    BOM generation

    A bill of materials (BOM) lists components and quantities for a product or assembly. An engineering bill of materials (EBOM) represents the engineering product structure, while a manufacturing bill of materials (MBOM) represents how the product is assembled or produced. A configurable BOM may contain rules that select components based on the configuration.

    CPQ may generate a BOM directly, generate a preliminary structure, or pass configuration data to PLM or ERP for authoritative BOM creation. These alternatives must not be treated as equivalent. The BOM, pricing and quoting guide explains the relationship in more detail.

    CAD and engineering automation

    Some manufacturing CPQ implementations trigger parametric CAD generation, drawing creation, sizing calculations or engineering review. Others only send selected options to an external engineering system. An event such as cad-generation.requested should therefore represent a workflow request, not an assumption that the CPQ platform itself creates CAD files. See the guide to CAD and engineering automation.

    Webhook and event-driven workflow example

    Consider a configurable centrifugal pump. The user selects flow rate, head, fluid properties, materials, seal type, motor voltage and mounting arrangement.

    1. CPQ evaluates configuration rules and engineering calculations.
    2. If the selection is valid, CPQ emits configuration.validated.
    3. A pricing service obtains material and motor costs and returns a commercial calculation.
    4. CPQ emits quote.recalculated with the pricing version and margin status.
    5. If the pump requires a product-specific drawing, CPQ emits cad-generation.requested.
    6. The CAD service generates a drawing or returns an engineering-review requirement.
    7. A BOM service creates an EBOM or sends the configuration to PLM for structure resolution.
    8. The salesperson submits the quote and an approval workflow evaluates discount, risk and margin rules.
    9. After customer acceptance, CPQ emits quote.accepted.
    10. ERP creates or updates the order and returns an ERP order identifier.
    11. MES receives production-relevant information only after the order is released and the required engineering data is approved.

    This sequence supports configure-to-order (CTO) when the product is selected from an established product model. If the pump requires new engineering work, the same architecture may support engineer-to-order (ETO), but an engineering review and design release must be explicit. Make-to-order (MTO) concerns production triggered by a customer order, while assemble-to-order (ATO) uses stocked modules assembled after the order. These workflows can share events but have different data and approval requirements. The manufacturing workflows guide provides further context.

    Benefits of event-driven CPQ integrations

    • Faster handoffs: An approved configuration can notify engineering, ERP or document generation without manual re-entry.
    • Lower duplication: Systems exchange identifiers and structured data instead of relying on emailed spreadsheets or copied quote lines.
    • Better process visibility: Events reveal where a configuration is waiting, such as pricing approval, CAD generation or PLM release.
    • Selective processing: Each subscriber receives only the events relevant to its responsibility.
    • Looser coupling: A CPQ system does not need synchronous connections to every downstream application for every action.
    • Improved auditability: Event identifiers, timestamps and correlation identifiers help reconstruct the path from configuration to order.
    • Support for multiple channels: Direct sales, dealers, distributors and ecommerce applications can use the same event contracts where appropriate.

    Limitations and risks

    Event-driven integration does not remove complexity; it moves some complexity into message delivery, data contracts and operational control.

    • Events can be duplicated: Receiving applications must be idempotent, meaning processing the same event more than once does not create duplicate orders, BOMs or customers.
    • Events can arrive out of order: A quote acceptance event may arrive before a related customer update. Consumers need sequence information, dependency checks or reconciliation logic.
    • Delivery is not the same as completion: A webhook accepted by an endpoint does not prove that an ERP order or CAD file was successfully created.
    • Payloads can become stale: Product rules, prices and engineering revisions may change between event creation and processing. Version identifiers are essential.
    • Failures may be invisible: Without dead-letter queues, alerts and operational dashboards, failed integrations can remain unnoticed.
    • Security exposure increases: Public webhook endpoints require authentication, signature validation, encryption, rate controls and careful payload handling.
    • Distributed transactions are difficult: A quote may be accepted while ERP is temporarily unavailable. The business must define retry, compensation or manual recovery procedures.

    Implementation considerations

    Define ownership and integration boundaries

    Document which system owns each object and field. For example, CRM may own the opportunity, CPQ may own the active configuration, PLM may own the released product structure, ERP may own the sales order and PDM may own the CAD document. Do not use webhooks to create competing masters without a clear reconciliation process.

    Design stable event contracts

    Use durable identifiers rather than display names. Include product model version, configuration version, currency, unit system and relevant revision information. Separate stable business events from internal implementation details. Version schemas when fields or meanings change.

    Use event notification with API retrieval where appropriate

    A compact webhook can notify a system that a configuration changed and provide a link or identifier for retrieving the authoritative record. This reduces payload size and avoids embedding large CAD, BOM or document structures in every message.

    Plan for retries and idempotency

    Transient failures should be retried with controlled backoff. Permanent failures should be placed in a dead-letter queue or exception worklist. Each consumer should record processed event identifiers and use business keys to prevent duplicate ERP orders, repeated CAD jobs or multiple approval records.

    Secure the endpoints

    Use transport encryption, authentication, signed requests, allowlists where practical and least-privilege access. Validate the event source and schema before processing. Do not include unnecessary customer, pricing or engineering data in a webhook payload.

    Test business scenarios, not only connectivity

    Integration testing should include invalid configurations, price changes, product-model revisions, withdrawn components, ERP downtime, duplicate messages, rejected quotes, partial CAD failures and engineering-review exceptions. Test both the normal path and the recovery path.

    Implementation planning should also cover data migration, governance, deployment and maintenance. The CPQ implementation guide and manufacturing CPQ integrations guide provide related planning topics.

    How to evaluate webhook support in a CPQ platform

    Buyers should verify documented capabilities rather than assume that an API automatically includes event-driven integration. Useful questions include:

    • Which business events are available, and can administrators define custom events?
    • Are events available for product-model publication, configuration validation, pricing, quote approval, BOM generation and order acceptance?
    • Does the platform support outbound webhooks, inbound webhooks, event subscriptions or an event broker?
    • Are event schemas documented and versioned?
    • Are retries, signatures, delivery logs and replay supported?
    • Can events include product-model, configuration and revision identifiers?
    • Can the platform distinguish quote acceptance from order creation and production release?
    • Does the system generate BOMs or only transmit configuration data to another system?
    • Does it support CAD or PLM workflows directly, through an integration platform or through custom APIs?
    • How are failed integrations monitored and reconciled?
    • Can dealer, distributor and ecommerce channels subscribe without exposing internal engineering data?

    These questions should be evaluated alongside configuration depth, rules maintenance, BOM behavior, CAD automation, ERP integration and governance. A feature checklist alone does not show whether the event model can support the manufacturer’s actual order-to-production workflow.

    Semantic map

    The following relationships summarize the main entities and dependencies discussed in this article:

    • CPQ publishes business events about configurations, quotes and product models.
    • Webhooks deliver event notifications between CPQ and connected applications.
    • Configuration rules prevent invalid combinations of product options.
    • Validated configurations can trigger pricing, engineering and BOM workflows.
    • ERP owns many order, inventory, item and financial transactions.
    • PLM owns released product structures, revisions and engineering change processes.
    • PDM manages CAD documents and design metadata.
    • CAD automation can generate product-specific drawings when supported by the architecture.
    • EBOM represents an engineering product structure.
    • MBOM represents a manufacturing-oriented assembly structure.
    • Event brokers distribute CPQ events to multiple subscribing systems.
    • Idempotency prevents duplicate processing of webhook deliveries.
    • Correlation identifiers connect configuration, quote, engineering and order records.

    Frequently asked questions

    1. What is a webhook in a CPQ system?

    A webhook is an HTTP notification sent when a CPQ event occurs, such as configuration validation, quote approval or customer acceptance. The receiving application uses the notification to start processing or retrieve more data.

    2. Are webhooks the same as APIs?

    No. An API usually supports a request initiated by a client, while a webhook pushes a notification from the source system. Manufacturing integrations often use both: the webhook signals a change and the API returns authoritative configuration, BOM or quote details.

    3. What is event-driven CPQ integration?

    It is an integration model in which CPQ publishes business events and connected systems respond to the events they subscribe to. It can coordinate CRM, ERP, PLM, CAD, PDM and MES workflows.

    4. Can webhooks create an ERP sales order?

    They can trigger an ERP order-creation process, but the webhook itself does not guarantee that the order was created. The integration should return an outcome, store the ERP identifier and provide recovery handling for failures.

    5. Should CPQ send the complete BOM in a webhook?

    Not necessarily. A webhook may provide the configuration and BOM identifiers while the receiving system retrieves the detailed structure through an API. The correct approach depends on payload size, ownership and whether CPQ or another system is authoritative for the BOM.

    6. How do webhooks support configure-to-order manufacturing?

    After a standard product configuration is validated and accepted, events can trigger pricing, order creation, BOM resolution and production preparation. The workflow should still distinguish a valid configuration from an approved and released order.

    7. Can event-driven integrations support engineer-to-order products?

    Yes, if engineering review, design generation, change approval and release states are modeled explicitly. An ETO workflow usually requires more than a simple quote-accepted webhook because new engineering work may be required.

    8. What is an idempotent webhook consumer?

    It is a receiving process that can safely handle the same event more than once without creating duplicate business records. This is important for ERP orders, CAD jobs, BOM releases and approval tasks.

    9. How should duplicate webhook messages be handled?

    Record the event identifier and business object version before completing processing. If the identifier has already been processed, return a successful response or perform a safe no-op rather than creating another transaction.

    10. What happens if ERP is unavailable when CPQ publishes an event?

    The integration should queue the event, retry according to defined rules and alert an operator if delivery continues to fail. It should not silently mark the order as complete merely because the webhook was accepted.

    11. Can a webhook trigger CAD automation?

    It can request a CAD job where the implementation supports CAD automation. The result may be a drawing, model, error or engineering-review request. CPQ should not be assumed to generate CAD files unless that capability is documented and implemented.

    12. What is the difference between an EBOM and an MBOM in event-driven workflows?

    An EBOM describes the engineering product structure, while an MBOM describes how manufacturing assembles or produces the product. A CPQ event may trigger either process, but the receiving system and approval rules may be different.

    13. Are webhooks suitable for price updates?

    They can notify CPQ or downstream systems that a price, cost or customer agreement changed. Price recalculation should use the applicable effective date, currency, contract and product-model version rather than blindly applying the latest value.

    14. What security controls are needed for CPQ webhooks?

    Use encrypted transport, authentication, request-signature validation, input validation, access controls, rate limiting and monitoring. Payloads should contain only the data needed by the receiving system.

    15. What should a CPQ event schema contain?

    Useful fields include event type, unique event identifier, timestamp, source, schema version, object identifiers, product-model version and correlation identifier. Additional fields depend on the event and data-ownership rules.

    16. Should every CPQ event be sent to every connected system?

    No. Subscribers should receive only events relevant to their responsibilities. Filtering reduces unnecessary coupling and limits exposure of commercial, customer or engineering information.

    17. How do webhooks differ from polling for manufacturing data?

    Webhooks notify a system when a change occurs, while polling repeatedly checks for changes. Webhooks can reduce delay and unnecessary requests, but polling may remain useful for reconciliation or systems that cannot receive callbacks.

    18. What should manufacturers test before deploying webhook integrations?

    Test normal processing, duplicate messages, out-of-order events, product-model revisions, invalid configurations, ERP downtime, CAD failures, rejected quotes, partial transactions and manual recovery. Connectivity testing alone is not sufficient.