Skip to main content
Shipping Insurance & Claims for ERPNext — A build-to-order ERPNext application that adds per-shipment insurance and full dama — 1/1Illustrative preview

A build-to-order ERPNext application that adds per-shipment insurance and full damage/loss claim management

inside your existing Delivery Note and Sales workflow.

ECOSIRE scopes, builds, installs, and supports it on Frappe/ERPNext v15/v16.

What is Shipping Insurance & Claims for ERPNext?

A build-to-order ERPNext application that adds per-shipment insurance and full damage/loss claim management inside your existing Delivery Note and Sales workflow. ECOSIRE scopes, builds, installs, and supports it on Frappe/ERPNext v15/v16. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

`Auto-Insure Rule` DocType that triggers on Delivery Note `on_submit` via `hooks.py` doc events, matching by declared value threshold, item group, ship-to territory, or carrier
Configurable premium engine supporting flat fee, per-mille of declared value, and banded/tiered rate tables, evaluated server-side
`Shipment Insurance Policy` DocType linked to Delivery Note, Sales Order, and optional Shipment, with declared value, sum insured, and premium breakdown
Premium posting wired through ERPNext accounting — expense/accrual booked to nominated accounts, keeping GL consistent with each policy
`Shipping Claim` DocType with a native Frappe Workflow: Draft, Filed, Under Review by Carrier, Approved, Settled, Rejected, Closed
Role-based workflow transitions restricting who can file, approve, or settle claims via DocType permissions and a dedicated Role Profile
Evidence handling through standard Frappe File attachments and comments — damage photos, inspection reports, POD exceptions on the claim record
Carrier claim reference and external status tracking fields, so the carrier's own claim number and stage live inside ERPNext
Scheduler event (`scheduler_events`) that ages open claims, flags SLA breaches, and can send reminder notifications on stale claims
Settlement posting that records recovered amount as a credit/refund against the correct account and closes the loop back to the source policy
Whitelisted methods and Frappe REST API endpoints to file, update, and query claims from external portals or carrier integrations
Client scripts adding in-form premium calculators and validation on Delivery Note and claim forms for real-time feedback
Native ERPNext reports for loss ratio and net recovery by carrier, route, item group, and period, built on the policy and claim DocTypes
Packaged as a versioned Frappe app installable via `bench get-app`/`bench install-app`, verified on Frappe/ERPNext v15 and v16

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

High-value-goods shippers carry real financial exposure on every outbound load, yet ERPNext core has no concept of shipment insurance or a claims lifecycle. Teams end up tracking declared values in spreadsheets, calculating premiums by hand, filing carrier claims over email, and reconciling settlements as ad-hoc journal entries — with no link back to the Delivery Note, no audit trail, and no way to report loss ratios by carrier or route. When a claim drags on for weeks, nobody in ERPNext can see its status, the accrued premium expense, or the expected recovery.

ECOSIRE builds a proper Frappe app that models this end-to-end. We add a Shipment Insurance Policy DocType linked to your Delivery Note (and optionally Sales Order/Shipment), plus an Auto-Insure Rule DocType that decides which shipments must be insured based on declared value thresholds, item groups, ship-to territory, or carrier. A hooks.py on_submit doc event on the Delivery Note evaluates the active rules, calculates the premium from a configurable rate table (flat, per-mille of declared value, or banded), and either creates the policy automatically or flags the shipment for review. Premium posting is wired through ERPNext's accounting so each policy books the expense/accrual against the accounts you nominate, keeping GL and inventory movements consistent.

The claims side is a Shipping Claim DocType with a Frappe Workflow (Draft, Filed, Under Review by Carrier, Approved, Settled, Rejected, Closed) and role-based transitions. Adjusters and warehouse staff file claims against the originating policy, attach evidence — photos, inspection reports, proof-of-delivery exceptions — through the standard Frappe File attachment and comment system, and record the carrier's claim reference and status. A scheduler event (scheduler_events in hooks.py) can nudge stale open claims and refresh SLA aging. On settlement, the app posts the recovered amount as a credit/refund against the correct account and closes the loop back to the policy, so finance sees net loss per shipment, per carrier, and per route in native ERPNext reports.

Everything is exposed the ERPNext-native way: server scripts and controller hooks enforce the premium and claim logic, client scripts add in-form calculators and validation on the Delivery Note and claim forms, whitelisted methods and the Frappe REST API let external portals or carrier integrations file and query claims, and a dedicated Role Profile plus DocType permissions keep adjusters, warehouse, and finance in their lanes. It is packaged as a versioned Frappe app installable via bench get-app / bench install-app, tested on Frappe/ERPNext v15 and v16.

This is build-to-order: it is not an existing Frappe Cloud Marketplace download. We start with a short scoping call, confirm your insurance rules, premium formulas, claim workflow, and accounting treatment in writing, then build against that spec. Typical delivery is one working week from confirmed scope depending on complexity. We install it on your bench (self-hosted or Frappe Cloud), run UAT on a staging site, train your team, and hand over the git repository and documentation.

What you get

  • Installable source code for your version of the app (versioned Frappe app, no per-seat license lock-in)
  • Installation and configuration on your bench (self-hosted or Frappe Cloud), including rate tables, auto-insure rules, and account mappings
  • Technical documentation: DocType schema, `hooks.py` doc events and scheduler events, whitelisted methods, and REST API reference
  • End-user guide plus a live training session for adjusters, warehouse, and finance roles
  • UAT on a staging site with a rollback plan before touching production
  • Post-go-live support window for defect fixes and configuration questions
  • Git repository handover with full commit history so your team owns and can extend the code
  • Compatibility validation against your target Frappe/ERPNext version (v15 or v16)

Who this is for

High-value-goods logistics manager

Ships electronics, machinery, or luxury goods where a single lost or damaged load is a material loss. Needs every qualifying shipment auto-insured at dispatch and a defensible claim trail, not a spreadsheet.

ERPNext finance controller

Wants premium expense and claim recoveries posted natively to the correct accounts, with net-loss-per-shipment and loss-ratio reporting inside ERPNext rather than reconciled off-system.

Claims / operations administrator

Files and tracks claims against carriers day to day. Needs a structured workflow, evidence attached to each claim, carrier reference tracking, and reminders when a claim goes stale.

ERPNext system owner / implementation partner

Runs the bench and needs a clean, documented Frappe app that installs via bench, respects permissions and Role Profiles, and can be extended and maintained on v15/v16 after handover.

How Shipping Insurance & Claims for ERPNext Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Fit to your insurance rules & premium formulasBuilt to your confirmed rules, formulas, and accountsFully bespoke but you own all analysis and riskGeneric template; bend your process to fit itNo insurance concept at all
Claim lifecycle & workflowNative Frappe Workflow, role-based, tailored stagesWhatever you build; depends on in-house skillFixed workflow, limited configurabilityNo claim DocType or workflow
Accounting integrationPremium & recovery posted to nominated accountsMust be designed and tested yourselfOften loose or manual GL linkageManual journal entries, no linkage
ERPNext version supportBuilt & tested on v15/v16, compatibility confirmedYour team owns version compatibilityMay lag core releases; upgrade riskCore only, no added feature
Delivery timeone working week from confirmed scopeUnpredictable; hiring & ramp-up overheadInstant install but rework to fitImmediate but does nothing for this
Source code & ownershipFull source + git repo handoverYou own it; you also build it allOften closed or license-lockedN/A
Support & maintenancePost-go-live window + optional retainerSelf-supported or separate hireVendor SLA varies; may be community-onlyCommunity/self-support
Reporting (loss ratio, recovery)Native reports by carrier, route, item, periodBuild your own report layerLimited or fixed reportsNone for insurance/claims

Frequently Asked Questions about Shipping Insurance & Claims

Is this a ready-made app I can download and install today?

No. This is build-to-order. It is not an existing Frappe Cloud Marketplace download. ECOSIRE builds your version against a confirmed scope, then installs it on your bench and supports it. This lets us match your exact premium formulas, claim workflow, and accounting treatment instead of forcing a generic template.

How long does delivery take?

Typical delivery is one working week from confirmed scope, depending on complexity — the number of auto-insure rules, premium formula variations, carrier integrations, and reporting needs. We agree the scope in writing after the scoping call, and that written spec is what starts the clock. If you need carrier API integrations or unusual accounting flows, we will tell you upfront if it pushes toward the longer end.

Which ERPNext versions does it support?

We build and test against Frappe/ERPNext v15 and v16. We confirm your exact target version during scoping and validate compatibility before go-live. The app is packaged as a standard Frappe app installed via `bench get-app` and `bench install-app`, and works on both self-hosted benches and Frappe Cloud.

How is the premium calculated and posted to accounting?

The premium engine supports flat fees, per-mille of declared value, and banded/tiered rate tables — configured to your rules. When a Delivery Note is submitted, a `hooks.py` doc event evaluates the active auto-insure rules and calculates the premium server-side. The amount is posted through ERPNext accounting to the expense/accrual accounts you nominate, so your GL stays consistent with each policy.

How do claims and evidence work end to end?

Each claim is a `Shipping Claim` DocType linked to its originating insurance policy, moving through a native Frappe Workflow from Draft to Filed, Under Review by Carrier, Approved, Settled, Rejected, and Closed. Evidence — photos, inspection reports, proof-of-delivery exceptions — is attached via standard Frappe file attachments. You record the carrier's own claim reference and status, and on settlement the recovered amount is posted and the policy is reconciled.

What about support and updates after go-live?

Every build includes a post-go-live support window for defect fixes and configuration questions. Because you receive the full source and git repository, your own team or partner can extend it afterward. For ongoing enhancements, version upgrades (for example v15 to v16), or a support retainer beyond the included window, we scope that separately.

Can it integrate with our carriers or an external claims portal?

Yes, within scope. The app exposes whitelisted methods and the Frappe REST API so external systems — a customer portal, a carrier's claim system, or middleware — can file, update, and query claims and policies. Specific carrier API integrations are scoped and estimated case by case, since each carrier's endpoints and authentication differ.

Request a quote

Shipping Insurance & Claims

A build-to-order ERPNext application that adds per-shipment insurance and full damage/loss claim management inside your existing Delivery Note and Sales workflow. ECOSIRE scopes, builds, installs, and supports it on Frappe/ERPNext v15/v16.

  • `Auto-Insure Rule` DocType that triggers on Delivery Note `on_submit` via `hooks.py` doc events, matching by declared value threshold, item group, ship-to territory, or carrier
  • Configurable premium engine supporting flat fee, per-mille of declared value, and banded/tiered rate tables, evaluated server-side
  • `Shipment Insurance Policy` DocType linked to Delivery Note, Sales Order, and optional Shipment, with declared value, sum insured, and premium breakdown
  • Premium posting wired through ERPNext accounting — expense/accrual booked to nominated accounts, keeping GL consistent with each policy

Request a Quotation

Tell us about your Shipping Insurance & Claims 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.