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