Quick facts
- Price
- $299.00 USD
- ERPNext versions
- —
- Setup time
- 30 min
- License
- One-time perpetual
- Languages
- 11 languages
One-time Purchase
ERPNext Pharma Distribution & Batch Compliance
A build-to-order ERPNext app that adds pharma-grade batch/expiry FEFO, drug license tracking, schedule-drug compliance, and cold-chain handling on top of ERPNext Stock and Selling. ECOSIRE scopes, builds, installs, and supports it for your v15/v16 site.
$299.00USD
No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.
Key Features
FEFO batch selection enforced via a `hooks.py` doc event on `Delivery Note`/`Sales Invoice` `validate`, overriding ERPNext auto-batch to pick strictly by earliest `expiry_date`
Hard block on manual batch picks that would ship stock nearer expiry than an available alternative, raising a `frappe.ValidationError`
`Drug License` DocType per Customer/Supplier: license number, issuing authority, schedule scope, valid-from/valid-to, and expiry alerts
Schedule-drug sales gating in a `before_submit` hook — verifies the buyer holds an active, unexpired license covering the item's schedule before the document can post
`Schedule Drug Classification` field on Item (Schedule H/H1/X or your jurisdiction's equivalents) driving compliance rules
Daily `scheduler_events` job that flags batches inside a configurable shelf-life window and emails the Compliance Officer role
Auto-quarantine workflow: near-expiry stock moves to a blocked warehouse via a generated `Stock Entry` (material transfer), removing it from FEFO picking
`Cold Chain Log` DocType linked to `Batch` and `Delivery Note` for time-stamped temperature capture and excursion history
Whitelisted REST method (`@frappe.whitelist()`) so IoT sensors or a mobile app can POST temperature readings against a batch and trigger holds on excursion
`Compliance Officer` role profile with permission-level and row-level access on `Drug License` and `Cold Chain Log`, separating warehouse from compliance duties
Client scripts on Sales Order/Delivery Note that surface live license status and batch expiry to the picker in real time
Batch-and-expiry-stamped Print Formats for the tax invoice plus a regulatory dispatch/sales register for inspections
Expiry and near-expiry dashboards and Query Reports (batch aging, schedule-drug movement, license expiry watchlist)
Built and tested for Frappe/ERPNext v15 and v16, packaged as a standard installable Frappe app with fixtures for roles and custom fields
About this Product
Pharmaceutical distributors live and die by batch discipline. A wholesaler moving thousands of SKUs across schedule drugs, cold-chain lines, and multiple drug-license jurisdictions cannot afford to pick a near-expiry batch first, ship a schedule-H drug to an unlicensed retailer, or lose the temperature log a regulator asks for at audit. ERPNext ships strong foundations here: Batch and Serial No DocTypes, Stock Ledger Entry, and auto-batch selection with a FEFO option. But native runs out of road at the compliance edge — there is no first-class drug-license register per customer, no schedule-drug gating on the Sales Order, no expiry quarantine workflow, and no cold-chain excursion capture tied to the batch you actually shipped. Teams end up bolting this onto custom fields and spreadsheets that break at scale.
Why Choose ERPNext Pharma Distribution & Batch Compliance
FEFO batch selection enforced via a `hooks.py` doc event on `Delivery Note`/`Sales Invoice` `validate`, overriding ERPNext auto-batch to pick strictly by earliest `expiry_date`
Hard block on manual batch picks that would ship stock nearer expiry than an available alternative, raising a `frappe.ValidationError`
`Drug License` DocType per Customer/Supplier: license number, issuing authority, schedule scope, valid-from/valid-to, and expiry alerts
Schedule-drug sales gating in a `before_submit` hook — verifies the buyer holds an active, unexpired license covering the item's schedule before the document can post
`Schedule Drug Classification` field on Item (Schedule H/H1/X or your jurisdiction's equivalents) driving compliance rules
Daily `scheduler_events` job that flags batches inside a configurable shelf-life window and emails the Compliance Officer role
ECOSIRE builds a proper Frappe app that closes those gaps as native ERPNext, not a bolt-on. We add DocTypes such as Drug License (number, authority, schedule scope, valid-from/valid-to, linked Customer/Supplier), Schedule Drug Classification on the Item, and Cold Chain Log linked to Batch and Delivery Note. FEFO is enforced in a hooks.py doc event on Delivery Note and Sales Invoice validate — a server script that overrides auto-batch selection to pick strictly by earliest expiry_date and hard-blocks any manual batch pick that would ship stock closer to expiry than an available alternative. Schedule-drug sales are gated the same way: a before_submit hook checks the customer's active Drug License covers the item's schedule and is not expired, throwing a frappe.ValidationError otherwise, so a non-compliant dispatch cannot be posted.
The rest is wired to ERPNext's own primitives so it stays upgrade-safe. Expiry management runs on a scheduler_events daily job that flags batches inside a configurable shelf-life window, auto-creates a quarantine Stock Entry (material transfer to a blocked warehouse), and emails the compliance role. Cold-chain excursions are captured via client scripts and a whitelisted REST method (@frappe.whitelist()) so IoT sensors or a mobile app can POST readings against a batch; an out-of-range reading raises an alert and can hold the batch. Everything respects Frappe permissions — a Compliance Officer role profile with row-level permission on Drug License and Cold Chain Log, so warehouse staff see stock but only compliance can override a quarantine. Print formats produce the batch-and-expiry-stamped invoice and the regulatory dispatch register your inspectors expect.
Because this is build-to-order, nothing is a generic download. We start with a scoping call to map your schedules, license jurisdictions, warehouse layout, and cold-chain SLAs, then build against your ERPNext v15 or v16 site. You get installable source for your version, deployment on your bench, UAT on a staging site, and a git repo handover — delivered typically in 2 to 4 weeks from confirmed scope, with a post-go-live support window so the first real regulatory cycle is covered.
What you get
- Installable Frappe app source code, versioned and built for your ERPNext v15 or v16 site
- Installation and configuration on your bench (custom fields, role profiles, and print formats loaded via fixtures)
- Technical documentation: DocType schemas, hooks and server scripts, whitelisted API methods, and scheduler events
- End-user guide plus a live training session for warehouse, sales, and compliance staff
- UAT on a staging site with sign-off, and a documented rollback plan before go-live
- Post-go-live support window covering the first regulatory/expiry cycle after launch
- Git repository handover with full commit history so your team owns the codebase
- Data-model mapping of your schedules, license jurisdictions, and cold-chain SLAs from the scoping call
Who this is for
Pharma distribution / wholesale operations lead
Runs a multi-SKU pharma wholesale on ERPNext and needs FEFO enforced automatically so near-expiry stock never ships first, plus a clean batch-aging view across warehouses.
Compliance / regulatory officer
Owns drug-license validity and schedule-drug rules. Needs sales to a given retailer blocked when their license is expired or out of scope, and an audit-ready register when inspectors arrive.
Cold-chain / warehouse manager
Responsible for temperature-sensitive lines. Needs excursions captured against the exact batch and delivery, with automatic holds so a compromised batch cannot be dispatched.
ERPNext administrator / IT lead
Maintains the Frappe site and must keep it upgrade-safe. Wants a proper app with fixtures, hooks, and whitelisted APIs rather than ad-hoc custom fields, plus a git repo their team can maintain.
Installation overview
Download from ECOSIRE
Buy the license on ecosire.com and download the ERPNext Pharma Distribution & Batch Compliance app ZIP from your account dashboard.
Add the app to your bench
Extract the ZIP into your bench's apps folder, or run `bench get-app` with the path to the extracted app.
Install on your site
Run `bench --site SITE_NAME install-app APP_NAME` followed by `bench migrate` to install ERPNext Pharma Distribution & Batch Compliance and apply its schema.
Activate your license
Open the ECOSIRE License settings on your site and activate your license key. Requires the free ecosire_connect and ecosire_license_client apps.
How ERPNext Pharma Distribution & Batch Compliance Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| FEFO enforcement | Hard-enforced via validate hooks; blocks near-expiry manual picks | Possible, but you design and test the logic yourself | Often just ERPNext's optional FEFO flag, not enforced | |
| Drug license register | First-class `Drug License` DocType per customer with expiry gating | Build a DocType from scratch and wire the checks | Rarely included; general-purpose apps skip pharma licensing | |
| Schedule-drug gating | `before_submit` block when license is expired or out of scope | Feasible with your own server scripts and testing | Not covered by generic marketplace stock apps | |
| Cold-chain capture | `Cold Chain Log` tied to batch/delivery, sensor-ready holds | You build the DocType, API, and hold logic yourself | Typically absent or a disconnected temperature note | |
| Expiry quarantine | Daily scheduler auto-moves near-expiry stock to a blocked warehouse | Write and schedule your own job | Usually just an expiry report, no automated action | |
| Fit to your process | Scoped to your schedules, jurisdictions, and SLAs | Fully bespoke but you carry all design and QA effort | Fixed feature set; you adapt to it | |
| Upgrade safety | Standard app: hooks, fixtures, whitelisted APIs — no core edits | Depends on your team's discipline | Varies; some apps patch core and break on upgrade | |
| Support & ownership | Post-go-live window + full git repo handover | Your team owns and supports everything | Vendor support tiers; source often not handed over |
Frequently Asked Questions about ERPNext Pharma Distribution & Batch Compliance
How long does delivery take?
This is build-to-order, not an instant download. Typical delivery is 2 to 4 weeks from confirmed scope. After the scoping call we agree the exact DocTypes, schedule rules, and cold-chain requirements, then build, test on staging, and deploy to your site. Complex multi-jurisdiction license logic can extend the timeline, which we flag up front.
Does this work with our existing ERPNext version?
Yes. We build and test for Frappe/ERPNext v15 and v16. Tell us your exact version and whether you are on Frappe Cloud, a self-hosted bench, or another host during scoping, and we build against that target so the app installs cleanly on your site.
How are batch/expiry and schedule-drug rules actually enforced?
FEFO is enforced in `hooks.py` doc events on `Delivery Note` and `Sales Invoice` `validate`, overriding auto-batch selection to pick by earliest expiry and blocking non-compliant manual picks. Schedule-drug sales are gated in a `before_submit` hook that checks the customer's active `Drug License` before the document can be submitted, so a non-compliant dispatch cannot post.
Will this survive ERPNext upgrades?
We build a standard Frappe app using hooks, server scripts, whitelisted methods, custom DocTypes, and fixtures — not core-file edits. This is the upgrade-safe pattern. We still recommend testing on a staging bench before any major version upgrade, and our support window can cover that first upgrade.
What support and updates come after go-live?
Every build includes a post-go-live support window covering the first regulatory/expiry cycle, so real-world issues are handled while the app beds in. Because you receive the full git repository, your team can maintain it themselves, or we can quote an ongoing support and enhancement retainer separately.
Can it integrate with cold-chain sensors or a mobile app?
Yes. We expose a whitelisted REST method (`@frappe.whitelist()`) so IoT temperature sensors or a mobile app can POST readings against a specific batch. Out-of-range readings raise alerts and can automatically hold the affected batch. We scope the exact integration and payload format with you during discovery.
Do we own the code?
Yes. You receive the installable source for your version and a full git repository handover with commit history. There is no per-seat lock-in on the app itself — your team owns and can extend the codebase.
Related Modules
Request a quote
ERPNext Pharma Distribution & Batch Compliance
A build-to-order ERPNext app that adds pharma-grade batch/expiry FEFO, drug license tracking, schedule-drug compliance, and cold-chain handling on top of ERPNext Stock and Selling. ECOSIRE scopes, builds, installs, and supports it for your v15/v16 site.
- FEFO batch selection enforced via a `hooks.py` doc event on `Delivery Note`/`Sales Invoice` `validate`, overriding ERPNext auto-batch to pick strictly by earliest `expiry_date`
- Hard block on manual batch picks that would ship stock nearer expiry than an available alternative, raising a `frappe.ValidationError`
- `Drug License` DocType per Customer/Supplier: license number, issuing authority, schedule scope, valid-from/valid-to, and expiry alerts
- Schedule-drug sales gating in a `before_submit` hook — verifies the buyer holds an active, unexpired license covering the item's schedule before the document can post