Cash on Delivery & COD Manager for ERPNext

Key Features

COD as a first-class payment method mapped to a dedicated `Mode of Payment` and receivable/clearing account, not just an 'unpaid' invoice flag

OTP / phone verification via a whitelisted server method that issues and validates a one-time code through your SMS or WhatsApp gateway before order confirmation

Configurable COD surcharge (fixed, percentage, or slab-based) applied server-side as a real charge/line item via `validate` and `before_save` doc events in `hooks.py`

Per-customer, per-region and per-order-value COD limits enforced in server logic so oversized or high-risk COD orders are blocked or held for approval

`Courier Remittance` DocType that batches collected cash and reconciles it against the originating Sales Invoices

Automatic `Payment Entry` creation on remittance settlement, posting against the correct receivable and COD clearing accounts

RTO (return-to-origin), short-payment and partial-collection handling so undelivered or under-collected COD is tracked, not lost

Courier assignment and delivery-status tracking with optional polling of courier APIs through scheduler events

OTP expiry, stale-order cleanup and overdue-remittance flags driven by `scheduler_events` background jobs

Client Scripts that render COD status, OTP resend/verify actions and remittance state directly on Sales Order and Sales Invoice forms

Whitelisted REST endpoints for headless / storefront checkout consumable via the Frappe REST API and `frappe.call`

Role-based permissions and dedicated role profiles (e.g. COD Verifier, Remittance Officer) so verification and reconciliation are properly segregated

COD dashboard / report views for pending verification, cash-in-transit, delivered-not-remitted, and RTO ageing

Full audit trail via Frappe's document versioning and a per-order COD event log for compliance and dispute resolution

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

You order

Start with a one-time build price. We scope it with you at kickoff.

We build & install

ECOSIRE builds, configures and installs it on your ERPNext.

Go live + support

You go live in about 2–4 weeks, with a post-launch support window.

About this Product

In South Asian and MENA retail, Cash on Delivery is not a fringe option — it is often the majority of order volume. But out of the box, ERPNext treats COD as an afterthought: you can flag a Sales Order or Sales Invoice as "unpaid" and hope the courier collects, yet there is no native OTP verification to filter fake orders, no configurable COD surcharge, no per-customer or per-region collection limits, and no structured way to track which orders a courier has picked up, delivered, collected cash on, and remitted back to you. Finance teams end up reconciling courier remittance sheets against invoices by hand in spreadsheets, RTO (return-to-origin) losses go untracked, and the gap between "delivered" and "cash actually received" stays invisible in the general ledger.

ECOSIRE builds a proper Frappe app — a versioned module installed on your bench, not a pile of customizations — that makes COD a controlled, auditable payment method inside ERPNext. We add a COD checkout/order path with new DocTypes such as COD Order, COD Settings, and Courier Remittance, wired into the standard Sales Order and Sales Invoice lifecycle. Phone/OTP verification runs through a whitelisted server method (@frappe.whitelist()) that issues and validates a one-time code via your SMS/WhatsApp gateway before an order is confirmed, cutting fake and duplicate COD orders. COD surcharge and collection limits live in COD Settings and are applied via hooks.py doc events (before_save / validate / on_submit) so the fee lands as a real line item or charge and limits are enforced server-side — never bypassable from the client.

On the fulfilment and finance side, the app tracks the full cash journey: courier assignment, pickup, delivery status, cash collected, and remittance batches. A Courier Remittance DocType reconciles collected amounts against the originating invoices and generates the matching Payment Entry records against the correct receivable accounts, so your GL reflects cash received the moment a courier settles — with COD fees, RTO, and short-payments accounted for rather than silently lost. Scheduler events (scheduler_events in hooks.py) can auto-expire stale OTPs, flag overdue remittances, and poll courier status where an API is available. Client Scripts surface COD status and OTP actions directly on the ERPNext form, everything respects role-based permissions and role profiles, and the whitelisted endpoints are consumable from your storefront or the Frappe REST API for a headless checkout.

Because this is build-to-order, nothing ships as a blind download. We start with a short scoping call to confirm your couriers, remittance workflow, fee rules, SMS/WhatsApp provider, and whether you are on Frappe/ERPNext v15 or v16. We then build and unit-test the app against your requirements, deploy it to a staging site for UAT, and only cut over to production once you have signed off — with a documented rollback path. Typical delivery is 2–4 weeks from confirmed scope, and you receive the full git repository so the code is yours to keep, audit, and extend.

What you get

Installable source code of your version of the COD Manager app, packaged as a proper Frappe app for your bench

Installation and configuration on your site — DocTypes, `COD Settings`, Mode of Payment, accounts, role profiles and SMS/WhatsApp gateway wiring

Technical documentation: DocType schema, hooks.py doc events, whitelisted methods, scheduler events and REST endpoints

End-user guide plus a live training session for your sales, verification and finance teams

UAT on a staging site with sample orders, plus a documented rollback plan before production cutover

Post-go-live support window for bug fixes and configuration adjustments after launch

Handover of the complete git repository so the code is yours to keep, audit and extend

Compatibility validation against your Frappe/ERPNext v15 or v16 version, recorded in the release notes

Who this is for

COD-heavy online retailer (Pakistan, India, Bangladesh)

Runs an ERPNext-backed store where 60–90% of orders are Cash on Delivery. Needs OTP verification to kill fake orders, a COD fee to offset RTO cost, and a clear view of cash sitting with couriers versus cash actually banked.

GCC / MENA multi-courier merchant

Ships via several courier partners across the UAE, KSA and Egypt, each with its own remittance cycle. Needs per-courier remittance batches reconciled to invoices and automatic Payment Entries so finance stops matching PDFs by hand.

Finance / accounts controller

Owns the ledger and the receivables. Needs COD collections posted to the right clearing and receivable accounts on settlement, RTO and short-payments accounted for, and an audit trail that survives a review — not a spreadsheet reconciliation.

Operations / fulfilment manager

Coordinates verification, dispatch and courier follow-up. Needs role-segregated workflows, delivered-not-remitted and RTO-ageing reports, and status visible on the order form so nothing stalls between confirmed and collected.

How Cash on Delivery & COD Manager for ERPNext Compares

Criterion	ECOSIRE	Custom Build	Competitor	ERPNext Native
COD as a payment method	First-class Mode of Payment with clearing account and controlled lifecycle	Whatever you build; usually starts from scratch	Often just a checkout label, shallow accounting	Only an 'unpaid' invoice flag, no COD concept
OTP / phone verification	Whitelisted server-side OTP via your SMS/WhatsApp gateway, scheduler-expired	Possible but you design and maintain it	Rarely included; if so, generic	None
COD fees & limits	Configurable surcharge and per-customer/region limits enforced server-side	Hand-coded rules you own end to end	Basic flat fee at best	No surcharge or limit logic
Courier remittance tracking	Dedicated Courier Remittance DocType with batches and ageing reports	Bespoke build effort	Usually absent or single-courier	Not modeled at all
Reconciliation to accounting	Auto Payment Entries on settlement with RTO/short-pay handling	You wire the GL posting yourself	Manual or partial	Manual spreadsheet reconciliation
ERPNext v15/v16 fit & upgrades	Proper Frappe app on its own repo, upgrade-safe	Depends on your discipline	Varies; may lag versions	N/A — no such feature
Ownership & extensibility	Full git repo handover, yours to extend	You own it but also all the effort	Licensed, limited source access	Core; not COD-specific
Support & delivery	Scoped build, staging UAT, rollback plan, post-go-live window	Your team's time and risk	Vendor support of variable depth	Community forums only

Frequently Asked Questions about Cash on Delivery & COD Manager for ERPNext

Is this an existing app I can download and install today?

No. It is build-to-order. ECOSIRE designs, builds, installs and supports a version tailored to your couriers, remittance workflow, fee rules and SMS/WhatsApp provider. There is no instant download — we scope it, build it, test it on staging, and cut over once you approve.

How long does delivery take?

Typically 2–4 weeks from confirmed scope. The timeline depends on how many courier integrations, fee rules and edge cases (RTO, partial collection, multi-currency) you need, and on how quickly UAT sign-off happens. We agree the scope and timeline in writing before any build starts.

Which ERPNext versions do you support, and how are updates handled?

We build and test against Frappe/ERPNext v15 and v16, targeting your specific version. Because it is a proper Frappe app on its own git repo, it survives ERPNext upgrades cleanly. During the post-go-live support window we fix bugs and adjust config; ongoing maintenance or version-migration retainers are available separately.

How does the OTP / phone verification actually work?

When a COD order is placed, a whitelisted server method generates a one-time code and sends it via your SMS or WhatsApp gateway. The order stays in an unverified state until the customer's code is validated server-side. Codes expire on a scheduler event, and you can require verification before the Sales Order is submitted — filtering out fake and duplicate COD orders.

How is COD cash reconciled into ERPNext accounting?

Collected cash is grouped into a `Courier Remittance` batch and matched against the originating Sales Invoices. On settlement the app creates the corresponding `Payment Entry` records against the correct receivable and COD clearing accounts, with COD fees, RTO and short-payments handled explicitly — so your GL reflects cash received, not just invoices raised.

Can it work with our headless storefront or custom checkout?

Yes. COD placement, OTP issue/verify and status lookups are exposed as whitelisted methods callable through the Frappe REST API, so a Next.js, mobile or third-party storefront can drive the flow. We confirm the exact endpoints and payloads with your team during scoping.

Do we own the code?

Yes. You receive the full git repository for your version at handover — it is yours to keep, audit, self-host and extend. There is no per-seat lock-in and no obligation to keep us on retainer after the support window.