Complex product configurators for manufacturing – Checklist

Manufacturing product configurators require: CPQ (Configure Price Quote) engine integration, rules-based logic for valid configurations, visual 3D rendering, intelligent pricing based on selections, bill-of-materials (BOM) generation, ERP system sync, and validation workflows. Implementation spans 10–14 weeks and typically involves Magento/Shopify Plus frontend with a specialized CPQ backend (3D-CT, Configure, Configit, or custom).

Complex Product Configurator Implementation Checklist for Manufacturers

A product configurator is the difference between a customer clicking "Buy Now" and a customer clicking "Design My Part" and arriving at a quote in 20 minutes. For manufacturers, this is a revenue multiplier. Instead of "contact sales," you're qualified leads.

Bemeir has built configurators for parts suppliers, 3D printing services, modular furniture makers, and heavy equipment OEMs. Here's the real checklist—not the happy-path version, but what actually ships.

Phase 1: Requirements & Design (Weeks 1–2)

Product Complexity Assessment

• Map all configurable attributes (size, material, color, finish, hardware, etc.)
• Identify attribute dependencies (if customer picks "stainless steel," does it unlock "mirror polish" finish?)
• List forbidden combinations (can you order a product smaller than 5cm? Larger than 200cm?)
• Calculate total possible SKU combinations (is it 10? 10,000? 10 million?)
• Identify which combinations are actually manufacturable (not all are)
• Document lead times per configuration (simple config = 2 days, complex = 30 days?)
• Map pricing logic (do different materials cost differently? Volume discounts?)
• Identify variants that change tooling or manufacturing process

Why it Matters: If you have 10 million possible SKUs but only 5,000 are actually buildable, a naive configurator will let customers design nightmares. You need business rules, not free-form design.

Use Case & Workflow Definition

• Define primary use case (quoting? Shopping? Design collaboration?)
• Map customer journey (search → configure → quote → order → fulfillment)
• Identify decision points (when does customer need sales input? Engineering review?)
• Document approval workflows (does an engineer need to sign off before production?)
• Define what happens after configuration (download PDF quote? Add to cart? Send to sales?)
• Identify integration points (does customer config data go into CRM? ERP?)
• Define revision handling (can customer come back and modify a quote?)
• Map for mobile (does configurator need to work on phones/tablets?)

Common Insight: Most Bemeir clients discover that their "simple configurator" actually needs a 3-step approval workflow (designer → engineer → production). Front-load this discovery.

Visualization Requirements

• Decide on visualization method: 2D drawings, 3D models, AR, or hybrid
• If 3D: identify which dimensions/angles matter (end view? Exploded view?)
• Define whether visualization is marketing (nice-to-have) or critical (customers won't proceed without it)
• Check if you have 3D models already (CAD files, step models?) or need to build
• Plan for real-time updates (as customer adjusts size, does 3D model update instantly?)
• Assess rendering performance (can your hardware render complex models 60 FPS on a laptop?)
• Check if customers want to download/3D-print the model (technical requirement)
• Identify which attributes affect visuals vs. which don't (color changes visual, lead time doesn't)

Cost Reality: Professional 3D visualization (Babylon.js, Three.js, Unreal) adds $30–80K to a project. Static 2D drawings: $5–15K. Most manufacturers start with 2D + real-time spec sheet updates, add 3D later.

Data & System Integration Audit

• Map where product data currently lives (ERP, CAD, spreadsheet?)
• Check if you have a product information management (PIM) system (SAP MDM? custom?)
• Document current quoting process (Salesforce, dedicated CPQ tool, email chains?)
• Identify ERP system (SAP, NetSuite, Plex, or custom?)
• Check if ERP can calculate BOM (bill of materials) programmatically
• List manufacturing systems (MRP, job shop, lean, make-to-stock?)
• Map pricing system (is pricing in ERP or separate tool?)
• Check inventory/capacity visibility (can you see manufacturing capacity in real-time?)

Typical Surprise: Manufacturers often think their pricing logic is simple ("size × $X per unit") until they actually audit it. Then they find: volume discounts, material upcharges, rush fees, tooling costs, and edge cases. Bemeir typical clients discover 40–60 pricing rules hidden in spreadsheets.

CPQ Tool Selection

• Evaluate CPQ platforms: 3D-CT, Configure, Configit, DreamWorks, or custom build
• Assess ease of configuration rule authoring (can non-developers write rules?)
• Check API maturity (can it integrate with your ERP? Your quoting system?)
• Evaluate pricing engine (can it handle complex calculations? Volume, quantity, lead time tiers?)
• Assess visualization capabilities (built-in 3D? Integration with CAD?)
• Check for BOM generation (can CPQ auto-generate a bill of materials?)
• Evaluate quote generation (can it output PDF, email, CRM?)
• Plan for training (how steep is the learning curve?)

Market Reality: Enterprise CPQ tools (SAP CPQ, Salesforce CPQ) run $100K–300K+ annually and take 6 months to implement. Boutique tools (3D-CT, Configure) run $20–60K and take 8–12 weeks. Custom builds: $80–200K and take 10–16 weeks, but give you maximum flexibility.

Phase 2: Core Architecture & Configuration (Weeks 3–6)

Configuration Rules Engine

• Define attribute data model (which attributes? What data types? Enums or continuous values?)
• Build validation rules (if size < 5cm, show error; if material = "titanium," add 40% upcharge)
• Set up dependency graph (which attributes depend on which? Is it a DAG or are there cycles?)
• Implement constraint satisfaction (what's the best algorithm for your problem: SAT solver, custom rules, heuristic?)
• Test rule performance (can you validate 100,000 configurations per second?)
• Plan for rule versioning (as rules change, do old quotes still validate?)
• Build conflict resolution (if two attributes conflict, which wins? Or do both disable?)
• Document rule priorities (material selection triggers finish options; finish selection can't override material)

Implementation Tip: Most Bemeir custom builds use a declarative rules engine (JSON-based or DSL) rather than procedural code. Why? Because manufacturing rules change often, and non-developers need to update them. A JSON rule looks like:

Procedural code would require redeployment every time. Avoid it.

Pricing Engine

• Create SKU-less pricing model (calculate price from attributes, not from hardcoded SKU)
• Build base pricing tier (what's the minimum unit price for each product family?)
• Implement material upcharges (aluminum vs. stainless vs. titanium?)
• Add size/dimension pricing (per kg? Per linear meter? Per sq meter?)
• Layer on complexity charges (how much more for tight tolerances? Custom finish?)
• Build volume discounts (does 100 units cost less per unit than 10?)
• Add lead time pricing (rush fee for 3-day delivery?)
• Implement tooling costs (first-time setup? Can it be amortized?)
• Plan for bulk/quote scenarios (at-scale pricing vs. one-off?)
• Test price accuracy (do calculated prices match what your factory actually costs to produce?)

Critical: Pricing logic is the #1 source of disputes. A customer configures a quote, the system shows $5,000, they place an order, but your factory says it actually costs $6,200 because of hidden complexity. Validate your pricing engine relentlessly. Bemeir typically runs pricing validations against historical orders (does calculated price match invoiced price? 95%+ should match).

BOM (Bill of Materials) Generation

• Map configuration attributes to component part numbers
• Build BOM template per product family
• Implement conditional BOM (if customer picks "stainless," which fasteners get used?)
• Set up quantity calculations (if customer orders 10 units, does BOM get multiplied by 10?)
• Connect to supplier master data (which components come from which vendors?)
• Plan for component availability checks (is component X in stock? Lead time?)
• Build capacity simulation (if customer orders 100 units, can factory produce by promised date?)
• Integrate with procurement (once quote is accepted, does BOM auto-create purchase orders?)

Typical Workflow:

1. Customer configures product → Configurator validates
2. System calculates BOM → checks supplier lead times
3. System simulates production schedule → determines lead time
4. System calculates price based on BOM cost + labor + overhead
5. Quote generated and shown to customer
6. Customer accepts → Order created → BOM triggers procurement

Visual Configuration

• Choose rendering engine: Three.js, Babylon.js, Verge3D, or Unreal (if high-end)
• Decide on asset management (where do 3D models live? How do you version them?)
• Build model parameterization (can a single 3D model render with different dimensions? Different colors?)
• Test real-time updates (as customer drags a slider to change size, does the model update instantly?)
• Implement color/material previews (customer picks "anodized red" and sees accurate preview)
• Plan for annotation (can customer add notes/dimensions to the visual?)
• Test performance across devices (does it work on iPhone? Old laptop?)
• Build model caching (don't regenerate a 100MB model every time)

Performance Gotcha: A 50,000-polygon 3D model renders fine on a desktop but crashes on mobile. You'll need model LOD (level of detail): high-quality for desktop, simplified for mobile. Bemeir typically uses Babylon.js with automatic LOD generation.

Phase 3: Integration & Workflows (Weeks 7–10)

ERP Integration

• Build API for ERP connectivity (does your ERP expose APIs? If not, file browser-based integration)
• Sync product master data (pull attributes, lead times, costs from ERP)
• Implement inventory checks (real-time check: are components in stock?)
• Sync capacity data (manufacturing calendar: when is the factory busy? When can we deliver?)
• Build quote-to-order conversion (customer accepts quote → creates order in ERP)
• Implement order tracking (customer can check order status in configurator)
• Sync production data back (ERP tells web platform: order is now on production line)
• Plan for data freshness (how often to sync? Real-time or batch?)

Integration Architecture: Bemeir typically uses:

• REST APIs if ERP supports (SAP APIs, NetSuite OpenSuite)
• Message queue (Kafka, RabbitMQ) for async sync (order created → queue → ERP processes)
• Fallback: nightly batch if real-time isn't feasible

CRM & Sales Integration

• Capture customer profile (who's configuring? New customer or returning?)
• Route qualified leads (when does a quote get handed to sales? When is it ready to order?)
• Send lead/quote to CRM (Salesforce, HubSpot)
• Track quote-to-order conversion (did the quoted lead convert to revenue?)
• Implement sales notifications (when new high-value quote, notify sales team)
• Build quote revision tracking (customer modified quote 3 times; show sales the evolution)
• Sync customer feedback (if customer abandons configurator, log abandonment event)

Frontend Implementation

• Choose eCommerce platform: Magento, Shopify Plus, or custom (WooCommerce typically too light)
• Integrate configurator UI (where does the configurator widget sit on your website?)
• Build navigation (how does customer move from product page to configurator?)
• Implement mobile responsiveness (full feature parity on phones or simplified config?)
• Add configurator linking (can customer share a configured product with colleagues?)
• Build quote PDF export (can customer download their quote as PDF?)
• Implement saved configurations (can returning customer "remember" their last config?)
• Plan for "configure from existing order" (if repeat customer, pre-populate config from prior order)

Bemeir Approach: We typically build the configurator as a React component embedded in your eCommerce platform. This way, it lives in your domain, uses your customer session, integrates with your cart/checkout seamlessly.

Order Processing & Fulfillment

• Build configured order handling (ERP knows this isn't a standard SKU; it's custom)
• Plan for artwork/documentation (does customer get technical drawings? 3D CAD file?)
• Implement quality checks (before sending to factory, does someone review the config?)
• Build shipping/logistics integration (complex items often need white-glove delivery)
• Plan for returns/warranty (can customer return a custom product? For what reason?)
• Implement tracking (can customer see production progress in real-time?)
• Plan for change requests (after order placed but before production, customer wants to modify—what's your process?)

Phase 4: Testing & Launch (Weeks 11–14)

Configuration Testing

• Test all valid configurations (at least 100 random valid configs)
• Test boundary conditions (minimum/maximum values; size=1cm vs. size=500cm)
• Test invalid combinations (attempt forbidden configs; verify system rejects)
• Test rule interactions (pick attribute A → B becomes disabled → user tries B → verify rejection)
• Test pricing accuracy (100+ random configs → manual price validation; verify ±2%)
• Test BOM generation (for 20 sample configs, validate BOM against ERP reality)
• Test performance (can system handle 10 simultaneous users configuring? 100?)
• Test edge cases (what if a component goes out of stock during quote creation?)

Integration Testing

• Test ERP sync (configurator changes → ERP reflects change within 5 minutes)
• Test CRM sync (quote created → Salesforce shows lead within 2 minutes)
• Test quote PDF generation (20 random configs → PDF output valid and accurate)
• Test quote expiration (quote expires in 30 days; verify email sent at day 25)
• Test quote-to-order conversion (customer accepts quote → order appears in ERP)
• Test payment (if collecting payment in configurator, test with test credit card)
• Test mobile experience (full config flow on iPhone 12, Android phone, iPad)
• Test accessibility (screen reader compatible? Keyboard navigable?)

Production Readiness

• Perform security audit (SQL injection, XSS, CSRF tests)
• Set up monitoring (alert if configurator API errors exceed 1%, or response time exceeds 2s)
• Plan for disaster recovery (how do you restore if database goes down?)
• Set up automated backups (database, configuration rules, customer quotes)
• Document runbooks (if something breaks at midnight, what's the troubleshooting guide?)
• Establish SLA targets (99.5% uptime? 99.9%?)
• Set up customer support workflows (if customer gets stuck configuring, who helps?)
• Plan for quiet launch (go live with 5% of traffic first; scale to 100% over 2 weeks)

Training & Documentation

• Create sales team training (how to demo configurator to prospects?)
• Create customer documentation (help articles, video tutorials)
• Create support playbook (common issues: what's the fix?)
• Document configuration rule maintenance (how to update rules without breaking things?)
• Train product managers on analytics (how to monitor configurator usage?)
• Create business decision log (why did we choose this CPQ tool? This architecture? Ref. for future decisions)

Configurator Post-Launch: Quick Wins