A finite-capacity, constraint-aware production scheduler for ERPNext that turns Work Orders and Job Cards into a live, drag-and-drop Gantt plan respecting machine, labor, and material availability. Built to order, installed, and supported by ECOSIRE. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $499.00 USD; request a quote for a scoped proposal.

A finite-capacity, constraint-aware production scheduler for ERPNext that turns Work Orders and Job Cards into a live, drag-and-drop Gantt plan respecting machine, labor, and material availability. Built to order, installed, and supported by ECOSIRE.
Aucun paiement maintenant. Ceci envoie une demande de devis à notre équipe — nous vous recontacterons par e-mail avec les tarifs et les prochaines étapes.
ERPNext's native Production Plan and Work Order engine is excellent at answering "what and how much to make" — it explodes BOMs, nets against stock, and raises material requests. What it does not do is answer "when, on which workstation, in what sequence, and can we actually hit the promised date." Native scheduling assumes infinite capacity: two Work Orders needing the same CNC on the same shift are both happily "planned," and the Gantt in the desk is a static read-out, not a plan you can push, pull, and re-optimize. For a discrete or job-shop manufacturer running dozens of concurrent orders across shared workstations and skilled operators, that gap turns into missed due dates, expedite chaos, and planners maintaining the real schedule in a spreadsheet outside ERPNext.
Finite-capacity scheduling pass that respects each Workstation's real working-hours calendar, holidays, and concurrent-job limit instead of ERPNext's infinite-capacity assumption
Operator/labor availability constraint: operations are only scheduled when a qualified, non-conflicting operator is free, modeled via an APS resource-calendar DocType
New `APS Schedule` + `APS Task` DocTypes that map one-to-one onto Work Order operations and Job Cards — no forking of standard ERPNext manufacturing data
Interactive drag-and-drop Gantt board (Frappe custom page / client script) with live pan, zoom, and per-workstation swimlanes
Auto-reschedule on drag: moving one operation cascades to dependent and competing tasks and immediately revalidates capacity
Real-time conflict flagging that blocks silent double-booking of a workstation or operator and highlights the offending tasks
We build a proper Frappe app — its own installable module, not a pile of loose customizations — that layers finite-capacity, constraint-aware scheduling on top of your existing ERPNext manufacturing data. The core is a new APS Schedule DocType plus per-operation APS Task child records that map one-to-one onto your Work Order operations and Job Cards, so nothing is duplicated or forked away from standard ERPNext. A whitelisted scheduling service (exposed via frappe.whitelist() and the standard REST API) runs a finite-capacity pass over each Workstation's real working-hours calendar and operator availability, honoring setup time, run time per unit, and material readiness dates pulled from stock projected-qty and expected PO/MR receipts. The result is written back to Job Card from_time/to_time and Work Order planned_start_date, so downstream ERPNext (capacity reports, Job Card execution, timesheets) sees a schedule it already understands.
The planner works in a drag-and-drop Gantt board delivered as a Frappe client script / custom page: drag an operation and the app auto-reschedules dependent and competing tasks, flags any capacity or material conflict in real time, and refuses to silently double-book a workstation. Sequencing rules are configurable — earliest due date, priority weighting, and setup-time minimization (grouping like setups to cut changeovers) — and a what-if mode lets a planner clone the live schedule into a sandbox, simulate a rush order or a machine breakdown, see the bottleneck workstation and the knock-on late orders, then commit or discard. Server-side hooks.py doc events keep the schedule honest as reality changes (a Work Order is submitted, a Job Card completes, a Material Request is received), and a scheduler_events background job can run a nightly full re-optimization so each morning starts from a feasible plan. Role profiles and permissions gate who can plan versus who can only view, integrated with your existing ERPNext manufacturing roles.
Because this is build-to-order, we start from your actual routings, workstations, shift calendars, and scheduling rules rather than a generic template. After a scoping call we confirm the exact DocType fields, sequencing logic, and integration points, then build against Frappe/ERPNext v15 (and v16 where you are already on it), validate on a staging clone of your site under UAT, and hand over the full git repository. Typical delivery is 2–4 weeks from confirmed scope. There is no instant download — you get a version built for your plant, installed with bench get-app/bench install-app, documented, and supported.
Runs the daily plan across shared machines and skilled operators and has outgrown ERPNext's infinite-capacity Production Plan. Needs a feasible, drag-and-drop finite-capacity schedule with instant conflict feedback instead of maintaining the real plan in Excel.
Owns on-time delivery and machine utilization at a discrete or job-shop manufacturer. Needs bottleneck visibility, what-if impact analysis for rush orders and breakdowns, and confidence that promised dates are actually achievable before committing.
Maintains the ERPNext instance and wants scheduling delivered as a clean, documented Frappe app on v15/v16 — proper DocTypes, hooks, and whitelisted APIs — with git handover, not brittle customizations that break on upgrade.
Rolling out ERPNext for a make-to-order client and needs finite-capacity scheduling that native ERPNext lacks, delivered to a confirmed scope with UAT and a rollback plan they can stand behind.
Achetez la licence sur ecosire.com et téléchargez le ZIP de l'application Advanced Production Scheduling (APS) & Finite Capacity Planning 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 Advanced Production Scheduling (APS) & Finite Capacity Planning 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 |
|---|---|---|---|---|
| Capacity model | True finite capacity across machines, operators, and materials | Depends entirely on your in-house build | Often still card-based or infinite-capacity | |
| Scheduling interface | Interactive drag-and-drop Gantt with auto-reschedule | Whatever you have time to build and maintain | Usually a read-only or basic timeline view | |
| What-if / bottleneck analysis | Sandbox simulation with bottleneck and late-order impact | Rarely built — high effort to get right | Limited or absent | |
| ERPNext integration | Native DocTypes, hooks, and write-back to Job Card / Work Order | Risk of brittle customizations that break on upgrade | Varies; may sit apart from core data | |
| Fit to your process | Built to your routings, shifts, and sequencing rules | Fully bespoke but you own all the risk | Generic template — you adapt to it | |
| Delivery & timeline | 2–4 weeks from confirmed scope, UAT + rollback | Unpredictable; often months of internal effort | Instant install but generic fit | |
| Support & ownership | Post-go-live support plus full git repo handover | You maintain it alone | Vendor support, no source ownership | |
| Version support | Built for Frappe/ERPNext v15 and v16 | You track compatibility yourself | Depends on the app's maintenance |
No. This is build-to-order. We build the app around your actual routings, workstations, shift calendars, and scheduling rules, then install and support it. There is no instant download — you receive a version built for your plant, delivered with source code, docs, and a git handover.
Typical delivery is 2–4 weeks from confirmed scope. After the initial scoping call we lock the DocType fields, sequencing logic, and integration points; the timeline depends on the complexity of your routings and how many constraints (operators, tooling, materials) you want modeled. We give a firm estimate before any work starts.
It ships as a separate Frappe app with its own DocTypes, `hooks.py` doc events, and whitelisted methods, and it writes back to standard Job Card and Work Order fields rather than forking core manufacturing. We build against Frappe/ERPNext v15 (and v16 where you're already on it) so it survives upgrades far better than ad-hoc customizations.
Every build includes a post-go-live support window for bug fixes and scheduling-logic adjustments. Because you receive the full git repository, your own team can also maintain and extend it. Ongoing enhancements, new constraints, or version upgrades beyond the support window are available as a separate scoped engagement.
No. We validate everything on a staging clone of your site under UAT before touching production, and we include a documented rollback plan. The app reads your existing manufacturing data and writes back to standard fields, so native ERPNext reports and Job Card execution continue working as your team already knows them.
Server-side `hooks.py` doc events react when a Work Order is submitted, a Job Card completes, or a Material Request is received, revalidating affected tasks. A configurable `scheduler_events` background job can run a nightly full re-optimization so each shift starts from a capacity-feasible plan, and the Gantt flags any new conflict in real time.
Yes. Operations are sequenced against projected stock qty and expected receipt dates from your open Purchase Orders and Material Requests, so an operation won't be scheduled to start before its inputs are realistically available. Material readiness is treated as a first-class constraint alongside workstation and operator capacity.
A finite-capacity, constraint-aware production scheduler for ERPNext that turns Work Orders and Job Cards into a live, drag-and-drop Gantt plan respecting machine, labor, and material availability. Built to order, installed, and supported by ECOSIRE.