Skip to main content
PLM & Engineering Change Orders (ECO/ECR) — A build-to-order ERPNext application that adds real Product Lifecycle Management: — 1/1Illustrative preview

A build-to-order ERPNext application that adds real Product Lifecycle Management:

versioned BOMs with full revision history, formal Engineering Change Request and Change Order workflows, side-by-side revision diffing, and effectivity-dated rollout to production.

ECOSIRE builds, installs, and supports it after a scoping call.

What is PLM & Engineering Change Orders (ECO/ECR)?

A build-to-order ERPNext application that adds real Product Lifecycle Management: versioned BOMs with full revision history, formal Engineering Change Request and Change Order workflows, side-by-side revision diffing, and effectivity-dated rollout to production. ECOSIRE builds, installs, and supports it after a scoping call. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Dedicated Frappe app and module with `Engineering Change Request` and `Engineering Change Order` DocTypes linked to core `Item` and `BOM`
BOM version control with an immutable revision-history DocType recording every version and the ECO that authorized it
Native Frappe Workflow for ECR/ECO with role-profile transitions (Engineer, Reviewer, Approver, Release) enforced by ERPNext permissions
Server-side whitelisted method that computes a side-by-side BOM revision diff — components, quantities, operations, and routing changes as add/change/remove
Effectivity-date-driven controlled rollout: a scheduler event activates the new revision at the scheduled date, not at submit time
`hooks.py` doc events (`on_submit`, `validate`, `on_update_after_submit`) that block BOM activation unless authorized by a released ECO
Client scripts for the in-form revision picker, inline diff viewer, and impact summary on the ECO form
Per-revision drawing and specification attachments via Frappe File, so each BOM version carries its own controlled document set
Full change lineage query: from any item/BOM, trace which revision was released, by whom, under which ECO, and when it took effect
Impact assessment fields linking affected items, open work orders, and material stock to surface WIP built against superseded revisions
Frappe REST API and whitelisted endpoints for MES/CAD-vault integration to push change requests and pull released revisions
Configurable numbering series and naming for ECR/ECO records to match your existing engineering change numbering
Audit-ready trail: every workflow transition, approval, and effectivity change captured in Frappe's document timeline and version log
Targets Frappe/ERPNext v15 and v16 with a clean migration path and no forked core doctypes

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

Discrete and engineer-to-order manufacturers live and die by how well they control design changes. In stock ERPNext, a BOM is versioned in a shallow way — you can amend a submitted BOM or create a new BOM against the same item, but there is no formal change-request stage, no approval gate before a change reaches production, no structured diff between two revisions, and no effectivity window that tells the shop floor exactly when the new design takes over. Engineers end up managing change control in spreadsheets and email threads, WIP is built against superseded drawings, and nobody can answer "which revision was released, by whom, and against which ECO?" during an audit. This is exactly where native ERPNext runs out of road for a serious engineering organization.

We build a proper Frappe app — its own module, not a pile of customizations bolted onto core doctypes — that layers a real PLM change-control process on top of ERPNext's existing Item and BOM. New DocTypes model the process end to end: an Engineering Change Request captures the proposed change, affected items, reason, and impact assessment; an Engineering Change Order groups approved changes, links the outgoing and incoming BOM revisions, carries effectivity dates, and drives the release. A revision-history DocType keeps an immutable record of every BOM version with the ECO that authorized it, so the full lineage is queryable. Approvals run on Frappe's native Workflow engine with role-profile-based transitions (Engineer, Reviewer, Approver, Release), so who-can-do-what is enforced by ERPNext permissions rather than convention.

The technical mechanics are grounded in Frappe primitives you can inspect and extend. hooks.py document events (on_submit, before_save, on_update_after_submit) enforce that a BOM only becomes active through a released ECO and that effectivity dates are respected. Server-side whitelisted methods produce the side-by-side revision diff — comparing components, quantities, operations, and routing between two BOM versions and rendering an add/change/remove report inside the ECO. Client scripts drive the in-form experience (revision picker, diff viewer, impact summary), while a scheduler event checks for ECOs whose effectivity date has arrived and flips the controlled rollout so the new revision becomes the default at the right moment — not the moment someone clicks submit. Everything is reachable over the Frappe REST API and the whitelisted methods, so your MES, PLM/CAD vault, or drawing system can push and pull change data programmatically. Drawings and specification documents attach per revision via Frappe's File attachments, so every BOM version carries its own controlled document set.

Because this is build-to-order, nothing is a generic download you self-install and hope fits. We start with a scoping call to map your change-control process, roles, and effectivity rules onto the app, then build against your actual ERPNext instance and BOM structure. Typical delivery is one working week from confirmed scope. You receive the full installable source for your version, a UAT pass on a staging bench with a rollback plan, and a support window after go-live. The app targets Frappe/ERPNext v15 and v16, and the git repository is handed over to you so you own what you paid for.

What you get

  • Installable source code for your commissioned version of the PLM & ECO app
  • Installation and configuration on your ERPNext instance, including workflow, role profiles, and numbering series
  • Technical documentation covering DocTypes, doc events, whitelisted methods, and scheduler behavior
  • User guide plus a live training session for engineering and approver roles
  • UAT on a staging bench with a documented rollback plan before production cutover
  • Post-go-live support window for defect fixes and configuration adjustments
  • Git repository handover so you own the source and its full history

Who this is for

Engineering / R&D Manager

Owns the change-control process at an ETO or discrete manufacturer with frequent design changes. Needs formal ECR-to-ECO approval gates, revision diffing, and a defensible record of who released what and when — not spreadsheets and email threads.

Manufacturing / Production Manager

Needs the shop floor to always build against the currently effective revision. Relies on effectivity dates and controlled rollout to know exactly when a design change takes over and to avoid WIP built against superseded drawings.

Quality / Compliance Lead

Responsible for audit readiness in regulated or contract-manufacturing environments. Needs full change lineage, immutable revision history, and role-enforced approvals traceable in the ERPNext document timeline.

ERP / IT Administrator

Owns the ERPNext platform and wants a clean Frappe app with its own module rather than forked core doctypes. Values REST API access for CAD/MES integration, v15/v16 support, and a git repo handover for maintainability.

How PLM & Engineering Change Orders (ECO/ECR) Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Change-request workflow (ECR/ECO)Formal ECR-to-ECO stages on native Frappe Workflow with role-based approvalsPossible but you design and build the whole state machine yourselfOften a fixed workflow you can't fully align to your processNo change-request concept; amend BOM or create a new one
BOM revision historyImmutable revision-history DocType tied to the authorizing ECOWhatever your team has time to build and maintainBasic version list, rarely linked to a change orderAmended-doc trail only; no engineering-change lineage
Revision diff / comparisonServer-side side-by-side diff of components, quantities, operations, routingMust be written from scratch and kept in sync with BOM schemaLimited or absent; often a manual side-by-sideNone — compare two BOMs by eye
Effectivity dates & controlled rolloutScheduler-driven activation on the planned effectivity dateRequires custom scheduler jobs and guard logicRarely supports date-based effectivityNot available; changes are effective on submit
Fit to your processBuilt to your roles, numbering, and effectivity rules from a scoping callFully bespoke but you carry all design and QA riskYou adapt your process to the app's assumptionsConstrained to core BOM behavior
Integration (API)REST API plus whitelisted methods for CAD/MES push and pullDepends entirely on what you implementVaries; often no dedicated change-control endpointsGeneric Frappe REST on core doctypes only
Delivery & timelineBuild-to-order, typically one working week from confirmed scopeUnpredictable; depends on in-house capacityInstant install but generic fitAlready present, but only core capability
Ownership & supportFull source, git handover, and a post-go-live support windowYou own it and you maintain it entirelyVendor-locked; updates on their scheduleCovered by your ERPNext maintenance only

Frequently Asked Questions about PLM & Engineering Change Orders

How long does delivery take?

This is a build-to-order app, not an instant download. Typical delivery is one working week from confirmed scope. We begin with a scoping call to map your change-control process, roles, and effectivity rules, then build against your actual ERPNext instance. The exact timeline is fixed once scope is agreed.

How is this different from ERPNext's built-in BOM versioning?

Native ERPNext lets you amend a submitted BOM or create a new BOM against the same item, but it has no formal change-request stage, no approval gate before a change reaches production, no structured diff between revisions, and no effectivity window. This app adds ECR/ECO workflows, an immutable revision history, side-by-side diffing, and scheduler-driven effectivity rollout on top of the BOMs you already have.

Which versions of ERPNext do you support?

We build for Frappe/ERPNext v15 and v16. The app is delivered as a proper Frappe app with its own module and does not fork core doctypes, so it migrates cleanly with `bench migrate`. Tell us your current version at the scoping call and we target it precisely.

What kind of support and updates do I get after go-live?

Every engagement includes a post-go-live support window for defect fixes and configuration adjustments. Because you receive the full git repository, your own team can extend the app too. Longer-term maintenance, version upgrades (for example v15 to v16), and enhancements can be arranged as an ongoing support agreement.

Can it integrate with our CAD vault or MES?

Yes. All ECR/ECO and revision data is reachable over the Frappe REST API and dedicated whitelisted methods, so external systems can push change requests and pull released revisions programmatically. We scope the specific integration touchpoints during the scoping call.

Do we own the code, or is it locked to you?

You own it. We hand over the installable source and the git repository with its full history. There is no per-seat lock-in and no dependency on us to keep the app running — the support window exists to help, not to hold the code hostage.

How do effectivity dates control the rollout to production?

An ECO carries effectivity dates linking the outgoing and incoming BOM revisions. A Frappe scheduler event checks daily for ECOs whose effectivity date has arrived and activates the new revision as the default at that point — so the shop floor switches to the new design on the planned date, not the moment someone clicks submit.

Request a quote

PLM & Engineering Change Orders

A build-to-order ERPNext application that adds real Product Lifecycle Management: versioned BOMs with full revision history, formal Engineering Change Request and Change Order workflows, side-by-side revision diffing, and effectivity-dated rollout to production. ECOSIRE builds, installs, and supports it after a scoping call.

  • Dedicated Frappe app and module with `Engineering Change Request` and `Engineering Change Order` DocTypes linked to core `Item` and `BOM`
  • BOM version control with an immutable revision-history DocType recording every version and the ECO that authorized it
  • Native Frappe Workflow for ECR/ECO with role-profile transitions (Engineer, Reviewer, Approver, Release) enforced by ERPNext permissions
  • Server-side whitelisted method that computes a side-by-side BOM revision diff — components, quantities, operations, and routing changes as add/change/remove

Request a Quotation

Tell us about your PLM & Engineering Change Orders 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.