- Home
- Apps
- Specialized Solutions
- Product Configurator (CPQ for Manufacturing)
Illustrative previewA rules-based product configurator for configure-to-order manufacturers running ERPNext.
Sales engineers pick options, and the app validates compatibility, generates the variant BOM and routing, and prices the configuration in real time — then drops it straight onto a Quotation.
What is Product Configurator (CPQ for Manufacturing)?
A rules-based product configurator for configure-to-order manufacturers running ERPNext. Sales engineers pick options, and the app validates compatibility, generates the variant BOM and routing, and prices the configuration in real time — then drops it straight onto a Quotation. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.
Key Features
Built to order, done for you
No DIY setup — a working app, built, installed and supported by ECOSIRE.
- 1
You order
Start with a one-time build price. We scope it with you at kickoff.
- 2
We build & install
ECOSIRE builds, configures and installs it on your ERPNext.
- 3
Go live + support
You go live in about one working week, with two weeks of go-live support. Defects in the code we deliver are fixed free of charge.
Technical Specifications
- ERPNext Compatibility
- —
- License
- Licence confirmation required
- Python Requirement
- Python 3.10+
- Database
- MariaDB 10.6+
About this Product
Configure-to-order manufacturers hit a wall in ERPNext core: every real product family has hundreds or thousands of valid option combinations, but native Item Variant attributes only capture flat variant axes and cannot express "if frame is stainless then gasket must be PTFE" or "voltage 480V is incompatible with the 50Hz motor." Sales engineers end up maintaining spreadsheets of valid combos, hand-building a BOM per order, and re-keying prices — which is slow, error-prone, and produces quotes that manufacturing later rejects because the BOM was never actually buildable. ERPNext gives you Items, BOMs, Routings, and Quotations, but it has no rules engine to connect them.
We build a proper Frappe app — its own module, installed via bench get-app and bench install-app — that adds the configuration layer ERPNext is missing. At its core are new DocTypes: a Product Configuration Model that defines the option groups and attributes for a product family, Configurator Rule records that express compatibility, requirement, and exclusion logic, and a Price Rule set that drives CPQ math (base price, per-option adders, quantity breaks, surcharges, margin floors). Rules are evaluated by a server-side engine exposed through whitelisted methods (@frappe.whitelist()) over the Frappe REST API, so the same logic backs both the internal desk UI and the customer-facing guided-selling page. Constraint checks run as the user selects, greying out or blocking invalid combinations before a quote can ever be produced.
When a configuration is confirmed, the app generates the concrete BOM — selecting or creating the right component Items, quantities, and sub-assemblies from the chosen options — and the matching Routing/operations, then writes a fully-priced line onto a Quotation (or Sales Order) with the configuration snapshot attached for traceability. We wire this in cleanly using hooks.py doc events (for example on_submit of the Quotation to lock the configuration and validate to re-check rules server-side), Client Scripts for the interactive desk experience, and scheduler events where background recalculation is needed. Role Profiles and DocType permissions gate who can edit models and rules versus who can only configure and quote, and everything is version-safe against ERPNext/Frappe v15 and v16.
Because this is build-to-order, there is no instant download. After a short scoping call we map your product families, attributes, and pricing logic, then build and configure the app against your data on a staging bench. Typical delivery is one working week from confirmed scope. You get UAT on staging, a rollback plan, the full git repository, and a post-go-live support window — the configurator is fitted to your actual products, not a generic template you have to bend to fit.
What you get
- Installable source code for your version of the app (a proper Frappe app installable via `bench get-app` / `bench install-app`)
- Installation and configuration on your ERPNext instance, including your product families, attributes, rules, and price logic
- Technical documentation: DocType schema, rule/price model, whitelisted API endpoints, and `hooks.py` integration points
- End-user guide plus a live training session for your sales engineering and BOM/manufacturing teams
- UAT on a staging bench with sign-off, plus a documented rollback plan before production cutover
- Post-go-live support window for bug fixes and configuration adjustments
- Full git repository handover with commit history so your team (or ours) can maintain and extend it
- Sample configuration models and rules for one product family, seeded so your team can extend the pattern
Who this is for
Sales engineering lead
Owns the quote-to-order handoff and needs valid, priced configurations that manufacturing will actually accept. Wants rules to stop reps from quoting impossible combinations and CPQ math that never undercuts the margin floor.
Manufacturing / BOM engineer
Tired of hand-building a BOM and routing for every configured order. Needs the configurator to emit a genuinely buildable BOM with correct components, sub-assemblies, and work-center operations, tied to the exact options chosen.
Head of sales operations
Wants faster, consistent quoting across the team and an audit trail linking each Quotation back to the configuration and rules that produced it, so pricing and product decisions are traceable.
ERPNext administrator
Responsible for the bench and upgrades. Needs a clean Frappe app with its own module, permission-gated DocTypes, `hooks.py`-based integration, and v15/v16 compatibility — not core patches that break on `bench update`.
How Product Configurator (CPQ for Manufacturing) Compares
| Criterion | ECOSIRE | Custom Build | Competitor | ERPNext Native |
|---|---|---|---|---|
| Configuration rules (compatibility/exclusions) | Dedicated rules engine with versioned Configurator Rule DocType | Possible, but you design and maintain the rule model yourself | Often limited to basic option lists, weak constraint logic | No rules engine; flat Item Variant attributes only |
| Variant BOM & routing generation | Auto-generates buildable BOM plus matching routing per config | Whatever you scope and build | BOM support varies; routing usually not handled | Manual BOM per order; no automatic routing from options |
| CPQ pricing logic | Base + per-option adders, breaks, surcharges, margin floor | Built to spec but from scratch | Simple adders, rarely margin guardrails | Manual pricing; no configuration-driven CPQ |
| Fit to your products | Modelled on your actual families, attributes, and pricing | Fully bespoke by definition | Generic template you bend to fit | Generic ERPNext primitives only |
| Upgrade safety (v15/v16) | Standalone Frappe app via hooks.py, no core patches | Depends on your engineering discipline | Varies; some patch core | N/A — it is core |
| Guided selling UI | Internal desk plus optional customer-facing web configurator | Only if you build and maintain it | Sometimes internal-only, limited | None |
| Delivery & ownership | one working week from scope; full source + git repo handover | Long build cycle; you own and staff it | Instant install but not fitted to you | Immediate but no configurator capability |
| Support & maintenance | Post-go-live support window; optional retainer | Your team owns all support | Vendor support, often generic tiers | Community/self-support |
Frequently Asked Questions about Product Configurator
How long does delivery take?
This is a build-to-order app, so there is no instant download. After a scoping call to map your product families, attributes, rules, and pricing, typical delivery is one working week from confirmed scope. Larger option catalogs or complex rule sets may extend that, and we confirm the timeline in writing before we start.
Is this an existing Frappe Cloud Marketplace app I can download now?
No. ECOSIRE builds, installs, and supports it specifically for your product catalog and pricing logic. You receive installable source code for your version and the full git repository — it is fitted to your data, not a generic template.
How do you handle support and updates after go-live?
Every engagement includes a post-go-live support window for bug fixes and configuration adjustments. Because you get the full git repo, your team can maintain it too. We build against ERPNext/Frappe v15 and v16 and can quote a separate maintenance retainer for ongoing changes and version upgrades.
Will the generated BOM and routing actually be buildable by our production team?
Yes — that is the point. The engine resolves selected options into concrete component Items, quantities, and sub-assemblies to produce a real ERPNext `BOM`, plus a matching `Routing`/operations for costing and production. Rules block impossible combinations before a quote is ever created, so manufacturing does not reject configured orders.
How does this integrate with ERPNext without breaking upgrades?
It ships as a standalone Frappe app with its own module and DocTypes, integrating through `hooks.py` doc events, Client Scripts, whitelisted REST methods, and scheduler events. We do not patch ERPNext core, so your instance stays clean and upgrade-safe on `bench update`.
Can customers configure products themselves, or is it internal only?
Both. The same rule and price engine backs an internal guided-selling desk experience for sales engineers and an optional customer-facing configurator page served over the Frappe REST API. Server-side validation runs on both paths, so a customer can never submit an invalid or under-priced configuration.
Who can edit the rules and pricing versus just create quotes?
Access is controlled with Role Profiles and DocType permissions. Model and rule authoring (option groups, `Configurator Rule`, price rules) is separated from day-to-day configuring and quoting, so a sales engineer can build quotes without being able to alter the underlying product logic.
Related Modules

PPAP / APQP Automotive Quality Pack
An IATF 16949-aligned PPAP and APQP document-control system built as a native Frappe app on ERPNext, giving automotive and aerospace tier suppliers phase-gate tracking, element checklists and one-click PSW generation. Build-to-order: ECOSIRE scopes, builds, installs and supports it for you.

Preventive Maintenance & CMMS for ERPNext
A full computerized maintenance management system built natively inside ERPNext — asset registry, time- and usage-based preventive schedules, corrective work orders, spare-parts consumption, and MTBF/MTTR analytics. ECOSIRE scopes, builds, installs, and supports it for you.
Product Configurator
A rules-based product configurator for configure-to-order manufacturers running ERPNext. Sales engineers pick options, and the app validates compatibility, generates the variant BOM and routing, and prices the configuration in real time — then drops it straight onto a Quotation.
- Option- and attribute-driven configuration modelled as a dedicated `Product Configuration Model` DocType per product family, not flat native Item Variant axes
- Rules engine with compatibility, requirement, exclusion, and default-selection logic stored as versioned `Configurator Rule` records
- Server-side constraint validation via `@frappe.whitelist()` methods so invalid option combinations are blocked on both desk and web, never client-only
- Automatic variant `BOM` generation — components, quantities, and sub-assemblies resolved from the selected options into a buildable BOM

