Produktdetails werden auf Englisch angezeigt. Übersetzungen folgen in Kürze.
Kurze Fakten
- Preis
- $249.00 USD
- ERPNext-Versionen
- —
- Rüstzeit
- 30 Min
- Lizenz
- Einmalig und unbefristet
- Sprachen
- 11 Sprachen
Einmalkauf
Scrap, Rework & Waste Management
A build-to-order ERPNext app that captures, classifies, and costs scrap and rework across your operations, with reason-code Pareto analysis, scrap valuation, a rework re-inspection loop, and defect-to-cost reporting for continuous-improvement teams. ECOSIRE builds, installs, and supports it after we confirm scope with you.
$249.00USD
Keine Zahlung jetzt. Dies sendet eine Angebotsanfrage an unser Team – wir melden uns per E-Mail mit Preisen und nächsten Schritten.
Hauptfunktionen
`Scrap Entry` DocType captures quantity, item, warehouse, reason code, workstation, operation, and disposition as a submittable, auditable transaction
Client Script injects a 'Log Scrap / Rework' action directly into the Job Card form so operators capture events without leaving the shop-floor screen
`Scrap Reason` master built as a tree/link taxonomy (category → sub-reason) that drives consistent Pareto grouping across all sites
`hooks.py` `doc_events` on `Job Card` and `Stock Entry` validate scrap quantity against produced quantity and auto-post the linked scrap transaction on submit
Scrap valuation derived server-side from item valuation rate plus operating cost consumed to the failing operation (Job Card time logs × workstation hourly rate)
`Rework Order` DocType with a re-inspection gate — reworked quantity cannot rejoin good stock until a linked Quality Inspection passes
Defect-to-cost linkage: each scrap/rework transaction can reference a CI Project or Quality Action for Kaizen / Six Sigma tracking
`Scrap & Waste Analysis` Script/Query Report with Pareto of reason codes, scrap value by item group, and defect-to-cost trend
Whitelisted `@frappe.whitelist()` methods expose scrap capture and rework routing over the Frappe REST API for scanners, tablets, or external MES
`scheduler_events` roll up open scrap and refresh analysis reports on an hourly/daily cadence without manual runs
Role Profiles and permission rules (`Quality Manager`, `Production User`, `CI Analyst`) separate capture, rework approval, and read-only dashboard access
Automatic scrap Stock Entry posting so scrapped material leaves inventory with correct valuation and GL impact — no manual back-flush
Workspace with number cards (scrap value MTD, top reason, rework rate) and chart shortcuts for the CI team
Configurable disposition workflow (Scrap / Rework / Use-as-is / Return-to-supplier) via Frappe Workflow states with role-gated transitions
Über dieses Produkt
Most manufacturers lose real money to scrap and rework without ever seeing it clearly. In stock ERPNext you can back-flush a Job Card, post a Stock Entry of type Material Transfer for Manufacture, or hand-key a scrap line into a BOM, but there is no structured place to capture why a part was scrapped, no reason-code taxonomy tied to the operation and workstation, and no way to route a defective unit through a rework loop and re-inspect it. Quality and continuous-improvement managers end up rebuilding the picture in spreadsheets after month-end — by which point the Pareto of top defect causes is stale and the cost attribution is guesswork. ERPNext's native Quality Inspection is pass/fail against parameters; it does not cost the failure, link it to a CI project, or drive corrective action.
Warum Scrap, Rework & Waste Management wählen
`Scrap Entry` DocType captures quantity, item, warehouse, reason code, workstation, operation, and disposition as a submittable, auditable transaction
Client Script injects a 'Log Scrap / Rework' action directly into the Job Card form so operators capture events without leaving the shop-floor screen
`Scrap Reason` master built as a tree/link taxonomy (category → sub-reason) that drives consistent Pareto grouping across all sites
`hooks.py` `doc_events` on `Job Card` and `Stock Entry` validate scrap quantity against produced quantity and auto-post the linked scrap transaction on submit
Scrap valuation derived server-side from item valuation rate plus operating cost consumed to the failing operation (Job Card time logs × workstation hourly rate)
`Rework Order` DocType with a re-inspection gate — reworked quantity cannot rejoin good stock until a linked Quality Inspection passes
This app closes that gap with a proper Frappe application (scrap_management) installed onto your bench as an ERPNext dependency. We add first-class DocTypes — Scrap Entry, Rework Order, Scrap Reason (a tree/link master), and Waste Cost Line (child table) — so scrap and rework become auditable transactions instead of free-text notes. Capture happens where the work happens: a client script injects a "Log Scrap / Rework" action into the Job Card form so an operator records quantity, reason code, workstation, operation, and disposition (scrap vs. rework) without leaving the shop-floor screen. A hooks.py doc_events handler on Job Card and Stock Entry validates the scrap quantity against produced quantity and writes the linked scrap transaction on submit, and a validate hook on Rework Order enforces the re-inspection gate before the reworked quantity can rejoin good stock.
Costing is derived, not typed. Server-side controller logic values each scrap line from the item's valuation rate plus the operating cost consumed up to the failing operation (pulled from the Job Card's time logs and workstation hourly rate), so a unit scrapped at the last operation is correctly costed higher than one caught at incoming inspection. Whitelisted methods (@frappe.whitelist()) expose scrap capture and rework routing to the Frappe REST API and to Client Scripts, so barcode scanners, tablets, or an external MES can post scrap events programmatically. A scheduler event (scheduler_events in hooks.py, hourly/daily) rolls up open scrap into a Scrap & Waste Analysis Query/Script Report with a built-in Pareto view of reason codes, scrap value by item group, and defect-to-cost trend — the numbers a CI team needs for a Kaizen or Six Sigma project. Role Profiles and permission rules (Quality Manager, Production User, CI Analyst) scope who can capture, who can approve rework, and who can only read the dashboards.
Because this is build-to-order, you are not downloading a fixed marketplace app and bending your process to it. After a short scoping call we confirm your reason-code taxonomy, disposition workflow, costing rules, and which reports and roles you need, then build the app against Frappe/ERPNext v15 or v16 to match your bench. We deliver on a staging site for UAT first, then install to production with a documented rollback, and hand over the full git repository so the code is yours to keep and extend. Typical delivery is 2–4 weeks from confirmed scope.
Was Sie bekommen
- Installable source code for your Frappe/ERPNext version (v15 or v16), delivered as a proper Frappe app on your bench
- Installation and configuration on your environment, including reason-code taxonomy, disposition workflow, and role profile setup
- Technical documentation — DocType schemas, hooks/server-script logic, whitelisted REST endpoints, and scheduler events
- End-user guide plus a live training session for operators, quality managers, and CI analysts
- UAT on a staging site with a documented, tested rollback plan before production install
- Post-go-live support window for defect fixes and configuration questions
- Full git repository handover so the code is yours to keep, audit, and extend
- Data model and permission map for future integration with an MES, BI tool, or additional ERPNext modules
Für wen das ist
Continuous-Improvement / Quality Manager
Owns the waste-reduction target and needs a trustworthy Pareto of scrap reasons tied to cost, not a stale spreadsheet, so Kaizen and Six Sigma projects target the highest-impact defects first.
Production / Shop-Floor Supervisor
Needs operators to log scrap and rework at the Job Card in seconds, with disposition routing that keeps defective units out of good stock until reworked and re-inspected.
Cost / Plant Controller
Wants scrap valued correctly at the operation where it failed and posted automatically to inventory and the GL, so cost-of-poor-quality shows up in the accounts instead of being estimated later.
ERPNext System Administrator
Wants a clean, upgrade-safe Frappe app with documented DocTypes, hooks, permissions, and REST endpoints — plus the git repo — rather than brittle undocumented customizations scattered across the site.
Installationsübersicht
Von ECOSIRE herunterladen
Kaufen Sie die Lizenz auf ecosire.com und laden Sie die ZIP-Datei der Scrap, Rework & Waste Management-App von Ihrem Konto-Dashboard herunter.
Fügen Sie die App zu Ihrer Bank hinzu
Extrahieren Sie die ZIP-Datei in den Apps-Ordner Ihrer Bank oder führen Sie „bench get-app“ mit dem Pfad zur extrahierten App aus.
Installieren Sie es auf Ihrer Website
Führen Sie „bench --site SITE_NAME install-app APP_NAME“ gefolgt von „bench migrate“ aus, um Scrap, Rework & Waste Management zu installieren und sein Schema anzuwenden.
Aktivieren Sie Ihre Lizenz
Öffnen Sie die ECOSIRE-Lizenzeinstellungen auf Ihrer Website und aktivieren Sie Ihren Lizenzschlüssel. Erfordert die kostenlosen Apps ecosire_connect und ecosire_license_client.
Wie Scrap, Rework & Waste Management im Vergleich abschneidet
| Kriterium | ECOSIRE | Benutzerdefinierter Build | Konkurrent | Odoo Native |
|---|---|---|---|---|
| Scrap reason capture | Structured `Scrap Reason` taxonomy at the Job Card | Whatever you build and maintain yourself | Often a single free-text field | |
| Scrap costing | Operation-aware, derived from valuation + operating cost | Possible but you design the logic | Flat item valuation only | |
| Rework loop | `Rework Order` with re-inspection gate | Build the workflow from scratch | Rarely included | |
| Pareto / CI reporting | Reason-code Pareto + defect-to-cost trend | Custom report effort each time | Basic list views | |
| Fit to your process | Built to your confirmed scope | Fully bespoke, fully your cost | Fixed feature set, you adapt | |
| API / MES integration | Whitelisted methods + Frappe REST | You define and secure endpoints | Limited or none | |
| Delivery & risk | Staging UAT + rollback, 2–4 weeks | Timeline and QA on you | Instant install, no fit guarantee | |
| Code ownership & support | Full git handover + support window | You own and maintain everything | Vendor-locked, subscription |
Häufig gestellte Fragen zu Scrap, Rework & Waste Management
+How long does delivery take?
This is a build-to-order app, not an instant download. Typical delivery is 2–4 weeks from confirmed scope — the exact timeline depends on the complexity of your reason-code taxonomy, costing rules, and any integrations. We agree the scope and schedule with you on the scoping call before any build begins.
+How does support and updates work after go-live?
Every engagement includes a post-go-live support window for defect fixes and configuration questions. Because we hand over the full git repository, your team can also extend the app themselves. We offer ongoing support and compatibility maintenance (for example, moving from v15 to v16) as a separate arrangement if you want us to keep it current for you.
+Which Frappe/ERPNext versions are supported?
We build against Frappe/ERPNext v15 or v16 to match your bench. Tell us your current version on the scoping call and we target that exact version; if you plan a version upgrade we account for it in the build so the app installs cleanly afterward.
+How is this different from ERPNext's native scrap and Quality Inspection?
Native ERPNext lets you post scrap on a Stock Entry or BOM and run pass/fail Quality Inspections, but it has no structured reason-code capture at the Job Card, no operation-aware scrap costing, no rework re-inspection loop, and no defect-to-cost Pareto reporting. This app adds those as first-class DocTypes, hooks, and reports.
+Can it integrate with barcode scanners or an external MES?
Yes. Scrap capture and rework routing are exposed through whitelisted `@frappe.whitelist()` methods and the standard Frappe REST API, so scanners, tablets, or an external MES can post scrap events programmatically. We scope any specific integration during the requirements call.
+Will this survive future ERPNext upgrades?
We build a proper separate Frappe app rather than editing core files, using documented `hooks.py` events, Client Scripts, and custom DocTypes. This keeps your customizations upgrade-safe and clearly separated from ERPNext core, which is exactly why we hand over a clean git repository.
+Do we own the code?
Yes. We hand over the full git repository at go-live. The app is yours to keep, audit, run, and extend — there is no per-seat licensing lock-in on the source we deliver to you.
Angebot anfordern
Scrap, Rework & Waste Management
A build-to-order ERPNext app that captures, classifies, and costs scrap and rework across your operations, with reason-code Pareto analysis, scrap valuation, a rework re-inspection loop, and defect-to-cost reporting for continuous-improvement teams. ECOSIRE builds, installs, and supports it after we confirm scope with you.
- `Scrap Entry` DocType captures quantity, item, warehouse, reason code, workstation, operation, and disposition as a submittable, auditable transaction
- Client Script injects a 'Log Scrap / Rework' action directly into the Job Card form so operators capture events without leaving the shop-floor screen
- `Scrap Reason` master built as a tree/link taxonomy (category → sub-reason) that drives consistent Pareto grouping across all sites
- `hooks.py` `doc_events` on `Job Card` and `Stock Entry` validate scrap quantity against produced quantity and auto-post the linked scrap transaction on submit