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 $799.00 USD; request a quote for a scoped proposal.

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.
Aucun paiement maintenant. Ceci envoie une demande de devis à notre équipe — nous vous recontacterons par e-mail avec les tarifs et les prochaines étapes.
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.
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
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 2–4 weeks 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.
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.
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.
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.
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`.
Achetez la licence sur ecosire.com et téléchargez le ZIP de l'application Product Configurator (CPQ for Manufacturing) depuis le tableau de bord de votre compte.
Extrayez le ZIP dans le dossier d'applications de votre banc ou exécutez « bench get-app » avec le chemin d'accès à l'application extraite.
Exécutez `bench --site SITE_NAME install-app APP_NAME` suivi de `bench migrate` pour installer Product Configurator (CPQ for Manufacturing) et appliquer son schéma.
Ouvrez les paramètres de licence ECOSIRE sur votre site et activez votre clé de licence. Nécessite les applications gratuites ecosire_connect et ecosire_license_client.
| Critère | ÉCOSIRE | Construction personnalisée | Concurrent | Odoo natif |
|---|---|---|---|---|
| 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 | |
| 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 | |
| CPQ pricing logic | Base + per-option adders, breaks, surcharges, margin floor | Built to spec but from scratch | Simple adders, rarely margin guardrails | |
| Fit to your products | Modelled on your actual families, attributes, and pricing | Fully bespoke by definition | Generic template you bend to fit | |
| Upgrade safety (v15/v16) | Standalone Frappe app via hooks.py, no core patches | Depends on your engineering discipline | Varies; some patch core | |
| Guided selling UI | Internal desk plus optional customer-facing web configurator | Only if you build and maintain it | Sometimes internal-only, limited | |
| Delivery & ownership | 2–4 weeks from scope; full source + git repo handover | Long build cycle; you own and staff it | Instant install but not fitted to you | |
| Support & maintenance | Post-go-live support window; optional retainer | Your team owns all support | Vendor support, often generic tiers |
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 2–4 weeks from confirmed scope. Larger option catalogs or complex rule sets may extend that, and we confirm the timeline in writing before we start.
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.
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.
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.
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`.
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.
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.
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.