Quick facts
- Price
- $349.00 USD
- ERPNext versions
- —
- Setup time
- 30 min
- License
- One-time perpetual
- Languages
- 11 languages
One-time Purchase
Customer Loyalty & Points Program
A configurable points, tiers and rewards loyalty engine built as a proper Frappe app and wired into your ERPNext sales, POS and customer records. Build-to-order: we design, install and support it for your business.
$349.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
Dedicated Frappe app with its own module, installable via `bench get-app` / `bench install-app` on your ERPNext v15 or v16 bench
`Loyalty Rule` DocType engine supporting earn-on-spend, earn-on-action (signup, review, birthday, first purchase) and earn-on-referral logic
`Loyalty Tier` DocTypes with escalating point multipliers, threshold-based auto-promotion and per-tier benefit configuration
`Reward Catalog` of redeemable SKUs, vouchers and discounts with point cost, stock limits and validity windows
Immutable per-customer `Points Ledger Entry` model — every accrual, redemption and expiry traceable to a source document
Points accrual driven by `hooks.py` doc events (`on_submit` on `Sales Invoice` and `POS Invoice`), consistent with ERPNext's ledger pattern
Whitelisted server methods (`@frappe.whitelist()`) for balance quote, redemption and reversal, callable from POS and storefront
Frappe REST API endpoints so headless e-commerce and mobile apps can earn and burn points at checkout
Client scripts on Sales Invoice and POS forms showing points earned, current balance and available rewards in real time
Configurable points expiry with FIFO ageing via a nightly `scheduler_events` job plus balance-reminder notifications
Referral tracking that links a referred customer's first qualifying invoice back to the referrer's ledger
Real-time balance and tier fields linked to the standard ERPNext `Customer` DocType via custom fields
Role profiles and DocType-level permissions isolating rule config, manual adjustments and catalog management with full audit trail
Frappe query reports and a workspace dashboard for points liability, redemption rate and tier distribution
About this Product
Retail, POS and B2C teams running on ERPNext hit a wall when they try to run a real retention program. ERPNext ships a native Loyalty Program DocType with a single earn rate and a fixed redemption factor per tier, but it stops short of the mechanics modern loyalty needs: no rules for earning on specific actions or referrals, no true reward catalog with redeemable SKUs or vouchers, no configurable expiry buckets, and no clean earn/burn experience at the e-commerce checkout. Most teams end up tracking points in spreadsheets or bolting on a disconnected third-party app that never reconciles back to the customer ledger.
Why Choose Customer Loyalty & Points Program
Dedicated Frappe app with its own module, installable via `bench get-app` / `bench install-app` on your ERPNext v15 or v16 bench
`Loyalty Rule` DocType engine supporting earn-on-spend, earn-on-action (signup, review, birthday, first purchase) and earn-on-referral logic
`Loyalty Tier` DocTypes with escalating point multipliers, threshold-based auto-promotion and per-tier benefit configuration
`Reward Catalog` of redeemable SKUs, vouchers and discounts with point cost, stock limits and validity windows
Immutable per-customer `Points Ledger Entry` model — every accrual, redemption and expiry traceable to a source document
Points accrual driven by `hooks.py` doc events (`on_submit` on `Sales Invoice` and `POS Invoice`), consistent with ERPNext's ledger pattern
We build a dedicated Frappe app that lives inside your ERPNext instance and treats loyalty as first-class data. The app introduces its own module and DocTypes — a Loyalty Rule engine (earn on spend, on defined actions such as signup, review or birthday, and on successful referrals), Loyalty Tier definitions with escalating multipliers and benefits, a Reward Catalog of redeemable items or vouchers, and a per-customer Points Ledger Entry that is the single source of truth for balance, accrual and expiry. Points accrual is driven by hooks.py document events: on_submit handlers on Sales Invoice and POS Invoice evaluate the active rules, compute earned points against the tier multiplier, and write immutable ledger entries — mirroring how ERPNext's own GL and stock ledgers work, so every point is traceable to a source document.
Redemption and balance logic is exposed through whitelisted server methods (@frappe.whitelist()) callable from the POS and from your storefront over the Frappe REST API, so a cashier or a web checkout can quote a balance, apply a burn, and post the redemption atomically without letting a customer overspend. Client scripts surface points earned and available on the Sales Invoice and POS forms; a scheduler event (a nightly scheduler_events cron) ages and expires points according to your configured windows and can trigger balance-reminder notifications. Role profiles and DocType permissions keep rule configuration, manual point adjustments and catalog management scoped to the right staff, with every adjustment captured for audit.
Because this is build-to-order, nothing is a generic download. We start with a short scoping call to map your earning rules, tier structure, expiry policy and the exact POS and e-commerce touchpoints, then build against your ERPNext version (v15 or v16). You get the app installed on a staging bench first for UAT, a documented rollback path, and a defined post-go-live support window. Typical delivery is 2-4 weeks from confirmed scope, and the full git repository is handed over so the app is yours to run and extend.
What you get
- Installable source code for your version of the loyalty app, pinned to your ERPNext v15 or v16 bench
- Installation and configuration on your environment, including hooks, custom fields, scheduler events and role profiles
- Technical documentation: DocType reference, API/whitelisted-method contract, and hook/event map
- End-user guide plus a live training session for POS staff and loyalty administrators
- Post-go-live support window for defect fixes and configuration questions
- UAT on a staging bench with sign-off checklist, plus a documented rollback plan
- Handover of the complete git repository so the app is fully yours to run, host and extend
- Sample loyalty rules, tiers and reward catalog pre-loaded as configurable starting fixtures
Who this is for
Retail & POS operations manager
Runs one or more retail outlets on ERPNext POS and needs points to earn and burn at the counter without slowing checkout or breaking reconciliation against the customer ledger.
E-commerce / D2C growth lead
Runs a storefront backed by ERPNext and wants points earned and redeemed at web checkout via the REST API, with tiers that reward repeat buyers and referrals.
ERPNext administrator / systems owner
Owns the ERPNext instance and needs a clean Frappe app with proper DocTypes, permissions, scheduler jobs and a git repo they can maintain — not an opaque black box or spreadsheet hack.
Marketing & CRM manager
Designs the retention program — earning rules, tier benefits, expiry policy and reward catalog — and needs reporting on points liability and redemption to prove ROI.
Installation overview
Download from ECOSIRE
Buy the license on ecosire.com and download the Customer Loyalty & Points Program 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 Customer Loyalty & Points Program 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 Customer Loyalty & Points Program Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Earning rules | Spend, action and referral rules via a configurable `Loyalty Rule` engine | Whatever you scope and code yourself, from scratch | Usually spend-only with limited configurability | |
| Tiers & benefits | Multiple tiers with escalating multipliers and auto-promotion | Build tier logic and thresholds yourself | Basic tiers, often fixed benefits | |
| Reward catalog | Redeemable SKUs, vouchers and discounts with point cost and limits | Design and build the catalog model yourself | Rarely included; discounts only | |
| POS & e-commerce earn/burn | Wired to POS and web checkout via doc events, whitelisted methods and REST API | Integrate each channel by hand | POS support varies; web often absent | |
| Points expiry | Configurable FIFO ageing via nightly scheduler job plus reminders | Write and schedule your own expiry logic | Basic or no expiry handling | |
| Auditability | Immutable ledger entry per accrual, redemption and expiry | Depends entirely on your implementation | Often opaque point balances | |
| Ownership | Full git repo handover; standard Frappe app on your bench | You own it but carry all build cost and risk | Vendor-hosted or licensed; limited access | |
| Time to live | 2-4 weeks build-to-order with staging UAT and rollback | Months of internal build and QA | Fast install but frequent rework to fit |
Frequently Asked Questions about Customer Loyalty & Points Program
+How long does delivery take?
This is a build-to-order product, not an instant download. Typical delivery is 2-4 weeks from confirmed scope. After a short scoping call we agree the earning rules, tiers, expiry policy and POS/e-commerce touchpoints, then build, test on staging, and deploy. Complex catalog or storefront integrations can extend the timeline, which we confirm before we start.
+Isn't there already a Loyalty Program in ERPNext?
Yes, but ERPNext's native Loyalty Program is deliberately minimal: one earn rate, a fixed redemption factor per tier, and no rules for actions or referrals, no real reward catalog, and no configurable expiry buckets. We build a dedicated Frappe app that adds a rule engine, tiered multipliers, a redeemable reward catalog, an auditable points ledger and clean POS/web earn-and-burn — while still linking to the standard `Customer` and invoice documents.
+Does it work with ERPNext POS and our online store?
Yes. Accrual is triggered by `on_submit` doc events on both `Sales Invoice` and `POS Invoice`, and redemption is exposed through whitelisted methods and the Frappe REST API, so a cashier at the POS and a web/mobile checkout both quote balances and post redemptions through the same validated logic. We wire the exact touchpoints you use during scoping.
+Which ERPNext versions are supported?
We build and test against Frappe/ERPNext v15 and v16. Tell us your exact version and bench setup on the scoping call and we pin the app to it. If you plan to upgrade, we account for that in the design.
+How do support and updates work after go-live?
Every build includes a defined post-go-live support window for defect fixes and configuration questions. Because you receive the full git repository, your own team can maintain and extend the app. We also offer optional ongoing support and enhancement retainers if you'd rather we keep evolving it as your program grows.
+Do we own the code?
Yes. We hand over the complete git repository for your version of the app. It is a standard Frappe app you can host on your own bench, audit, and extend. There is no runtime lock-in or per-seat licensing on the code itself.
+How do you make sure points and balances stay accurate?
Every accrual, redemption and expiry writes an immutable `Points Ledger Entry` tied to its source document, the same pattern ERPNext uses for its GL and stock ledgers. Redemptions post atomically through whitelisted methods with overspend guards, and a nightly scheduler job ages and expires points on your configured windows so the customer balance is always reconcilable.
Related Modules
Request a quote
Customer Loyalty & Points Program
A configurable points, tiers and rewards loyalty engine built as a proper Frappe app and wired into your ERPNext sales, POS and customer records. Build-to-order: we design, install and support it for your business.
- Dedicated Frappe app with its own module, installable via `bench get-app` / `bench install-app` on your ERPNext v15 or v16 bench
- `Loyalty Rule` DocType engine supporting earn-on-spend, earn-on-action (signup, review, birthday, first purchase) and earn-on-referral logic
- `Loyalty Tier` DocTypes with escalating point multipliers, threshold-based auto-promotion and per-tier benefit configuration
- `Reward Catalog` of redeemable SKUs, vouchers and discounts with point cost, stock limits and validity windows