Skip to main content
Product Configurator (CPQ for Manufacturing) — A rules-based product configurator for configure-to-order manufacturers runnin — 1/1Illustrative preview

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.

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

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
Automatic `Routing`/operations generation so the configured item carries the correct work-center steps and times for costing and production
Dynamic CPQ pricing: base price, per-option price adders, quantity breaks, surcharges, and margin-floor guardrails computed per configuration
Configured line written directly onto `Quotation` or `Sales Order` with a full configuration snapshot attached for audit and re-order
Guided-selling UI for internal sales engineers (Client Scripts) and an optional customer-facing configurator page served over the Frappe REST API
`hooks.py` doc events (`validate`, `on_submit`) re-run the rule and price engine server-side so a tampered payload cannot bypass constraints
Role Profiles and DocType permissions separating model/rule authors from users who only configure and quote
Reusable option libraries so shared attributes (materials, voltages, finishes) are defined once and referenced across product families
Scheduler events for background price-list refresh and bulk re-validation of saved configurations after a rule change
Configuration snapshots are re-openable and editable, producing a new priced BOM revision while preserving the original for traceability
Version-safe implementation and tested against ERPNext/Frappe v15 and v16, with the app installable via standard `bench` commands

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

  1. 1

    You order

    Start with a one-time build price. We scope it with you at kickoff.

  2. 2

    We build & install

    ECOSIRE builds, configures and installs it on your ERPNext.

  3. 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

CriterionECOSIRECustom BuildCompetitorERPNext Native
Configuration rules (compatibility/exclusions)Dedicated rules engine with versioned Configurator Rule DocTypePossible, but you design and maintain the rule model yourselfOften limited to basic option lists, weak constraint logicNo rules engine; flat Item Variant attributes only
Variant BOM & routing generationAuto-generates buildable BOM plus matching routing per configWhatever you scope and buildBOM support varies; routing usually not handledManual BOM per order; no automatic routing from options
CPQ pricing logicBase + per-option adders, breaks, surcharges, margin floorBuilt to spec but from scratchSimple adders, rarely margin guardrailsManual pricing; no configuration-driven CPQ
Fit to your productsModelled on your actual families, attributes, and pricingFully bespoke by definitionGeneric template you bend to fitGeneric ERPNext primitives only
Upgrade safety (v15/v16)Standalone Frappe app via hooks.py, no core patchesDepends on your engineering disciplineVaries; some patch coreN/A — it is core
Guided selling UIInternal desk plus optional customer-facing web configuratorOnly if you build and maintain itSometimes internal-only, limitedNone
Delivery & ownershipone working week from scope; full source + git repo handoverLong build cycle; you own and staff itInstant install but not fitted to youImmediate but no configurator capability
Support & maintenancePost-go-live support window; optional retainerYour team owns all supportVendor support, often generic tiersCommunity/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.

Request a quote

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

Request a Quotation

Tell us about your Product Configurator requirements and we'll send pricing, licensing options and a tailored proposal — usually within one business day.

No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.