Manufacturing configurators let B2B customers specify exact product requirements (dimensions, materials, finishes) and receive instant pricing and lead times. The right platform saves your sales team 10+ hours per week and reduces configuration errors by 80%.
Manufacturing sales is a paperwork sport. A customer calls requesting "a steel enclosure, 24 inches wide, stainless steel finish, mounting bracket, four cable ports." Your sales engineer spends 2 hours assembling quotes from multiple systems: spec sheets, pricing tables, lead time calculators, CAD models. Email it back. Customer requests a revision. Repeat.
A product configurator collapses this workflow into 15 minutes of self-service. Customer selects base product. Chooses dimensions. Selects materials. Sees price instantly. Downloads a quote. Sales team reviews it, adds volume discount, sends order.
The leverage: your A-players (experienced sales engineers) stop doing data entry and start closing deals. Junior sales staff become effective immediately. Customers buy faster because they don't wait for human engineering time.
We've implemented configurators for K&N Engineering's automotive components, Pepsi's beverage dispensing equipment, and manufacturers managing 50+ configurable options per product line.
The Configurator Spectrum
Rule-based (simplest): Customer selects from predefined combinations. Size = Small/Medium/Large. Material = Steel/Aluminum/Stainless. Finish = Powder/Polished/Anodized. Price updates based on matrix lookup. Mostly works for 10-20 options.
Limitation: can't handle "if Material=Stainless, then PolishingOption is unavailable" rules or complex dependencies.
Parametric (mid-complexity): Customer inputs precise dimensions and properties. System calculates pricing, lead time, and manufacturing constraints in real-time. Weight is calculated. Shipping cost is estimated. Lead time is pulled from production calendars.
Limitation: requires deep integration with your manufacturing data (specifications, lead times, constraints). Can't handle multi-SKU assemblies or true customization.
** 3D visualization (high-complexity):** Customer sees a 3D model that updates in real-time as they configure. Dimensions are verified against physical constraints. Interference checking prevents invalid combinations (e.g., mounting bracket can't fit if width < 18 inches). Customer downloads a PDF with final specifications.
This is what Bemeir builds for large manufacturers. It's complex, valuable, and almost always justified.
Core Technical Decisions
Configuration Engine: Where does the logic live?
Option A: Backend microservice (Python/Node). Customer selections are POSTed to the engine. The engine returns pricing, lead time, and design rules. Frontend displays results. Advantage: logic is centralized, auditable, versioned. Disadvantage: latency (network round-trip).
Option B: Frontend engine (JavaScript). Configuration rules and pricing matrices are downloaded to the browser. Customer's selections are processed locally, instantly. Advantage: instant feedback, no latency. Disadvantage: all pricing logic is exposed in the frontend (security risk if you have complex margins).
Recommendation: Hybrid. High-level rules (dependencies, constraints) run on the backend. Instant feedback (price preview, lead time estimate) runs on frontend. User selects "confirm" and the backend validates the final configuration.
3D Visualization: How do you render the product?
Option A: Three.js or Babylon.js (WebGL frameworks). You load a 3D model (GLTF, FBX) and update materials/dimensions in JavaScript. Pros: full browser compatibility, responsive. Cons: requires 3D modeling expertise.
Option B: AR preview (WebAR). Customer sees the product in their physical space via phone camera. Pros: wow factor, engagement. Cons: requires WebAR device support, adds complexity.
Option C: 2D configurator with static images. Show product at different angles, update materials via CSS overlays. Pros: simple, fast. Cons: less immersive.
For manufacturers: Three.js is the sweet spot. 90% of buyers don't need AR; they want to verify dimensions and finishes.
Data Integration: Where does your product data live?
Most manufacturers have:
- PIM (Product Information Management): specs, descriptions, images, dimensions
- ERP (Enterprise Resource Planning): inventory, lead times, pricing rules, cost structures
- CAD system: 3D models, design specifications
Your configurator needs to pull from all three. A dimension change in the PIM flows through to the configurator. A lead time change in the ERP updates instantly. A new 3D model in CAD is ready to display.
This integration is where most projects get stuck. No two manufacturers have the same ERP or PIM. You're building custom connectors.
Pricing Strategy: The Hardest Part
Here's what nobody expects: pricing logic is more complex than visualization.
Simple: Product A costs $100 base, +$10 per inch of width, +$25 per material, +$15 for special finish. Total = $100 + (Width * $10) + MaterialCost + FinishCost.
Complex: If Material=Stainless, then FinishCost is $0 (stainless doesn't need finishing). If Width > 36, then specialized tooling applies (+$200). If OrderQuantity > 100, volume discount of 15%. If Finish=Mirror, then only available for Aluminum (not Steel). If Width < 12, then PolishingOption is unavailable (too small to polish).
These rules live in your ERP or a pricing system (like a spreadsheet someone updates quarterly, which is a nightmare).
The right approach: Version your pricing rules in code. Use a rules engine (like Drools or a custom JavaScript engine) to evaluate them. Version the rules like you version source code. Deploy updates confidently. Test them before they're live.
The wrong approach: Hard-code pricing in JavaScript. Change it by editing the frontend. Ship it without testing. Customers see $100 prices that should be $150.
Bemeir implements pricing as a versioned service: you send a configuration to the backend, the backend evaluates all applicable pricing rules, and returns the price. The frontend never calculates price—it only displays what the backend returns.
Platform Options
Cerpro (3D Product Configurator):
- Strengths: Strong 3D visualization, rule engine for complex configurations, supports multiple CAD formats
- Weaknesses: Expensive ($40K+ initial build), limited ecosystem (you're building custom integrations)
- Cost: $40-80K implementation + $2-5K/month SaaS
- Bemeir use: When 3D visualization is essential and budget allows
Configit (Rule Engine):
- Strengths: Powerful rule engine, supports complex product hierarchies, good for multi-level assemblies
- Weaknesses: Backend tool (no frontend included), requires you to build the UI
- Cost: $30-60K + $1-3K/month
- Bemeir use: When you already have a frontend and need a rock-solid rules engine
Shopify Configuration Apps (Option Monster, Endobuild):
- Strengths: Quick setup, integrated with Shopify storefront
- Weaknesses: Limited to Shopify ecosystem, basic rules, no true 3D visualization
- Cost: $200-500/month
- Bemeir use: Rarely. Better for simple B2C customization (t-shirt color picker). Not for complex manufacturing.
Custom Build (Bemeir's approach):
- Strengths: Total control, rules exactly match your business logic, integrates with your exact systems
- Weaknesses: Takes 3-6 months to build, requires ongoing maintenance
- Cost: $60-150K initial + $3-8K/month maintenance
- Bemeir use: When existing platforms don't fit your product complexity or your ERP/PIM is unique
For manufacturing: custom build is often the right answer. Off-the-shelf tools assume generic rule patterns. Your business logic is specific.
Real Implementation Example: Enclosure Manufacturing
Client: 180-person manufacturer of industrial steel and stainless steel enclosures.
Configuration options: 47 total.
- Width: 12-48 inches (1-inch increments)
- Height: 24-60 inches (2-inch increments)
- Depth: 6-24 inches (2-inch increments)
- Material: Steel, Stainless 304, Stainless 316
- Finish: Powder coat (8 colors), Anodized (4 colors), Mirror polish, Brushed finish
- Hardware: Mounting brackets (4 styles), cable ports (0-6), latches (2 styles)
- Special options: Fan mount, thermostat, cable management, custom labeling
Possible combinations: >100,000. But 95% are invalid (e.g., mirror polish isn't available for steel, only stainless).
Rules implemented:
- If Material=Steel, then Finish options are Powder coat only
- If Material=Stainless 304 or 316, then Finish options include Powder, Anodized, Mirror, Brushed
- If Width > 42, then add $200 tooling surcharge
- If Depth < 8, then CablePortCount max is 2 (physical constraint)
- If all dimensions (Width, Height, Depth) are custom and Quantity > 50, then lead time adds 4 weeks
The configurator rendered these rules. Customer selects: Width=36, Height=48, Depth=10, Material=Stainless 304, Finish=Mirror Polish, 4 CablePorts, MountingBracket=Heavy Duty.
Configuration engine validated: mirror polish available for stainless (OK), 4 cable ports fits in depth 10 (OK), no tooling surcharge, standard lead time 3 weeks.
Price calculated: Base ($1,200) + Width premium ($36 * $8 = $288) + Height ($48 * $5 = $240) + Stainless surcharge ($400) + Mirror finish ($600) + Cable ports ($100) + Bracket ($75) = $2,803.
Quote generated, emailed to customer, sales team reviewed it, applied 10% volume discount ($2,523), sent PO.
Without configurator: Sales engineer would have spent 3-4 hours assembling spec sheets, calling manufacturing to verify lead time, cross-referencing pricing. With configurator: 15 minutes, customer self-served.
Integration with Your Systems
The configurator is usually the front-end to your existing infrastructure.
Typical flow:
- Customer configures product in web interface
- Browser POSTs configuration to backend API
- Backend loads rules from Rules Engine
- Rules Engine queries PIM for specifications
- Backend calculates lead time from ERP
- Backend calculates price from Pricing Rules
- Backend returns quote JSON
- Frontend displays quote, offers "Request Quote" button
- Customer clicks "Request Quote"
- Order created in ERP, assigned to sales team
- Sales team reviews, adds volume discount, sends to customer for approval
This is where Bemeir's 60+ technology partnerships matter. We've built integrations with: Sage, NetSuite, Plex (cloud ERP), Tekla (3D design), Autodesk (CAD), Teamcenter (PLM), and dozens of PIM systems.
Implementation Timeline and Cost Reality
Scope clarification: 2 weeks. Understand your rules, options, constraints, data sources. Document in a specification.
Rules engine build: 4-6 weeks. Implement pricing, lead time, constraint logic. Unit test extensively.
Frontend build: 4-6 weeks. React component for configuration, quote display, cart integration.
3D visualization (optional): 4-8 weeks. Load CAD models, texture mapping, real-time updates.
ERP/PIM integration: 2-4 weeks per system. API connections, data synchronization, error handling.
Testing: 2-3 weeks. Edge cases (what if customer selects impossible combinations?), performance (can it handle 1,000 concurrent users?), usability testing.
Total: 14-35 weeks depending on scope.
Cost range: $80K (basic rule-based) to $200K+ (full 3D with complex integrations).
Success Metrics
After launch, measure:
- Quote turnaround time: before and after
- Sales team time spent on configuration: measure via Salesforce or Hubspot
- Quote accuracy: errors or revisions needed
- Customer satisfaction: do they prefer the configurator to calling sales?
- Conversion rate: do configuration users buy at higher rates?
At the enclosure manufacturer above, we measured:
- Quote turnaround: 3 hours (average) to 15 minutes (configurator)
- Sales team time: 6 hours/week before to 1.5 hours/week after
- Quote accuracy: 92% accuracy before to 98% after (fewer errors due to rules enforcement)
- Customer preference: 68% of customers used configurator for new orders (after 3 months)
- Conversion: 34% of configured quotes converted to orders (vs. 28% for manual quotes)
