- Home
- Apps
- SaaS Tools
- Supermarket & Grocery POS for ERPNext
Illustrative previewA high-speed grocery checkout for ERPNext with weight-embedded (EAN-13) barcode parsing,
live weighing-scale integration and fast multi-item scanning.
ECOSIRE builds, installs and supports it on your bench after we agree the scope.
What is Supermarket & Grocery POS for ERPNext?
A high-speed grocery checkout for ERPNext with weight-embedded (EAN-13) barcode parsing, live weighing-scale integration and fast multi-item scanning. ECOSIRE builds, installs and supports it on your bench after we agree the scope. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.
Key Features
Built to order, done for you
No DIY setup — a working app, built, installed and supported by ECOSIRE.
- 1
You order
Start with a one-time build price. We scope it with you at kickoff.
- 2
We build & install
ECOSIRE builds, configures and installs it on your ERPNext.
- 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
Grocery and supermarket checkout is where stock ERPNext POS runs out of road. The default POS profile expects one scan to equal one sellable unit at a fixed rate, but a produce aisle sells loose apples, deli meats and repackaged goods priced by weight, printed on the shelf scale as a 13-digit label where the last digits encode grams or price, not a catalog SKU. Cashiers end up keying weights by hand, PLU lookups happen on paper taped to the register, and a Saturday rush exposes every extra keystroke as a queue. ERPNext core has no concept of a weight-embedded barcode, no serial link to a counter scale, and no quick-key produce grid — so the checkout becomes the bottleneck the rest of the ERP was supposed to remove.
ECOSIRE builds a proper Frappe app (its own module, versioned in a git repo) that installs onto your existing erpnext bench rather than a bolt-on you have to reconcile later. The core is a parser for weight- and price-embedded EAN-13 symbologies (the common 2xxxxx in-store prefixes): a Store Barcode Rule DocType lets you define, per prefix, whether the trailing digits carry weight, price or count and where the check digit and item code sit, so the same lane reads a Bizerba, Avery or Mettler label without hard-coded assumptions. A whitelisted server method (@frappe.whitelist()) resolves the scanned string against Item and the rule table and returns the resolved item plus computed quantity to the POS in one round trip over the Frappe REST API, so a scan of a weighed label lands as a priced line with no cashier keystroke. Live counter scales are handled by a small Weighing Scale config DocType plus a bridge that reads the serial/network stream and pushes the stable weight into the active cart. On top of that we add a PLU and quick-key produce grid (client script driven, backed by an Item-linked PLU field), and mix-and-match, buy-X-get-Y and bulk-tier pricing enforced through hooks.py doc events on the POS invoice so the discount logic lives in the app, not in a cashier's head.
Everything stays inside the ERPNext object model so your accounting, inventory valuation and stock ledger keep working untouched. Discounts, weighed lines and PLU sales post as normal POS Invoice / Sales Invoice rows; role profiles and permissions gate who can define barcode rules, override a price or open a manager function; and any recurring work (end-of-day reconciliation exports, scale-drift checks) is wired to Frappe scheduler events. We target Frappe/ERPNext v15 and v16, keep customizations as fixtures and code rather than manual UI changes, and layer client scripts only where the checkout genuinely needs faster interaction than the standard POS gives.
Because this is build-to-order, there is no instant download. We start with a short scoping call to confirm your barcode symbology, scale hardware, PLU list and discount rules, then quote against that fixed scope. Typical delivery is one working week from confirmed scope. We build on a staging copy of your bench, run UAT with your team against real shelf labels and a real scale, and only then cut over to production with a documented rollback. You receive the installable source for your version, install and configuration, technical and user documentation, a training session, and a post-go-live support window — plus the git repository so the code is yours to keep.
What you get
- Installable source code for your ERPNext version (v15 or v16), packaged as a proper Frappe app
- Installation and configuration on your bench, including barcode rules, PLU list and scale setup
- Technical documentation: DocTypes, whitelisted methods, hooks, scheduler events and configuration reference
- User guide and a live training session for cashiers and supervisors
- UAT on a staging copy of your bench against real shelf labels and a real scale, with a documented rollback plan
- Post-go-live support window for defect fixes and configuration adjustments
- Handover of the git repository so the code is yours to keep and extend
- Fixtures for barcode rules and PLU data for repeatable rollout across additional lanes or branches
Who this is for
Independent supermarket owner
Runs one or a few full-line grocery stores on ERPNext and needs a checkout that reads shelf-scale weight labels and clears Saturday queues without cashiers keying weights by hand.
Grocery chain operations manager
Manages multiple lanes and branches and needs consistent, fixture-driven barcode and PLU configuration, role-based overrides and reliable end-of-day reconciliation across every register.
Mini-market / convenience owner
Sells a mix of barcoded packs and loose produce, wants a fast multi-item scan lane plus a quick-key PLU grid so a single cashier can move a line quickly.
ERPNext implementation partner
Delivering ERPNext to a retail client and needs a maintainable weight-aware POS app — clean DocTypes, whitelisted methods and a git repo — instead of building embedded-barcode parsing from scratch.
How Supermarket & Grocery POS for ERPNext Compares
| Criterion | ECOSIRE | Custom Build | Competitor | ERPNext Native |
|---|---|---|---|---|
| Weight-embedded EAN-13 parsing | Built in, configurable per scale prefix | Possible but you build the parser and rule engine yourself | Often fixed to one label format or absent | No concept of embedded-weight barcodes |
| Live weighing-scale integration | Serial/network bridge to your confirmed scale model | Bespoke integration you specify and maintain | Rarely included; usually manual weight entry | Not supported |
| PLU quick-key produce entry | Client-script grid backed by an Item PLU field | Build from scratch on the POS UI | Varies; frequently a basic favorites list | Manual item search only |
| Mix-and-match / bulk discounts | Enforced via hooks.py doc events on the invoice | You design and code the discount engine | Limited to the app's fixed pricing rules | Basic pricing rules, no embedded-label logic |
| Fit with ERPNext core | Posts as standard POS/Sales Invoice, stock & GL native | Depends entirely on developer discipline | May diverge from core document flow | Native but lacks grocery checkout features |
| Ownership & maintainability | Own the git repo, fixtures and versioned app | You own it but carry all the build risk | Vendor-controlled, closed roadmap | No custom code to own |
| Delivery model | Build-to-order, one working week from confirmed scope | Open-ended project timeline and cost | Instant install but generic fit | Available immediately, missing capabilities |
| Support after go-live | Post-go-live support window + optional maintenance | Whoever built it, if still available | Forum or paid support, feature-dependent | Community/partner support only |
Frequently Asked Questions about Supermarket & Grocery POS
Is this an instant download from the Frappe marketplace?
No. This is build-to-order. ECOSIRE builds the app against your confirmed scope — your barcode symbology, scale hardware, PLU list and discount rules — then installs and supports it on your bench. You are not downloading a pre-existing marketplace app.
How long does delivery take?
Typical delivery is one working week from confirmed scope. The clock starts once we have agreed the barcode rules, scale model, PLU data and discount logic on the scoping call and you have approved the quote. Larger multi-branch rollouts can run longer and we will say so upfront.
Which weighing scales and barcode formats are supported?
We support weight- and price-embedded EAN-13 labels using configurable per-prefix rules, so common in-store `2xxxxx` formats from scales like Bizerba, Avery and Mettler are handled as data rather than hard-coded. For live weighing we integrate the specific scale model you confirm during scoping via its serial or network output.
Which ERPNext versions does it work with?
We target Frappe/ERPNext v15 and v16. Tell us your exact bench version on the scoping call and we build and test against it. The app installs as its own module alongside `erpnext` and posts through standard POS/Sales Invoice, so your accounting and stock ledger stay native.
What about support and updates after go-live?
Every build includes a post-go-live support window for defect fixes and configuration adjustments. Because you receive the git repository, the code is yours to keep and extend. We can also quote a longer maintenance arrangement covering version upgrades and new features separately.
Will this interfere with our existing ERPNext accounting and inventory?
No. Weighed lines, PLU sales and discounts post as ordinary POS Invoice / Sales Invoice rows, so the stock ledger, inventory valuation and general ledger keep working exactly as ERPNext expects. The app adds parsing, scale integration and pricing logic without replacing core financial documents.
How do you deploy without risking our live store?
We build and test on a staging copy of your bench, run UAT with your team against real shelf labels and a real scale, and only then cut over to production behind a documented rollback plan. Customizations ship as code and fixtures, so a lane or a whole branch can be reprovisioned repeatably.
Related Modules

Stripe Payments & Subscriptions for ERPNext
A build-to-order Frappe app that connects ERPNext to Stripe for hosted Checkout, Payment Links, recurring subscription billing, and webhook-driven reconciliation. ECOSIRE builds, installs, and supports it on your ERPNext v15/v16 site.

Stripe POS Terminal for ERPNext
A build-to-order Frappe app that connects Stripe Terminal card readers (BBPOS WisePOS E, M2) and Tap to Pay to ERPNext POS, so in-person and online card payments settle to one unified ledger. ECOSIRE scopes, builds, installs, and supports it — no marketplace download.

Tabby BNPL for ERPNext
A build-to-order Frappe app that adds Tabby Buy-Now-Pay-Later as a first-class ERPNext payment method — Pay in 4, monthly installments, eligibility pre-scoring, and product/cart promo messaging. ECOSIRE scopes, builds, installs, and supports it on your ERPNext v15/v16 instance.

Table & Reservation Management for ERPNext
A build-to-order Frappe app that turns ERPNext into a full-service reservation and floor-management system with a drag-and-drop floor plan, online bookings, waitlists and turn-time analytics. ECOSIRE scopes, builds, installs and supports it for you.
Supermarket & Grocery POS
A high-speed grocery checkout for ERPNext with weight-embedded (EAN-13) barcode parsing, live weighing-scale integration and fast multi-item scanning. ECOSIRE builds, installs and supports it on your bench after we agree the scope.
- Weight- and price-embedded EAN-13 parsing for in-store `2xxxxx`-prefix labels, with the trailing digits decoded to grams, units or line price
- Configurable `Store Barcode Rule` DocType so each scale prefix (Bizerba, Avery, Mettler, etc.) is defined as data, not hard-coded
- Whitelisted `@frappe.whitelist()` resolver that turns a scanned label into a priced, quantity-computed POS line in a single REST round trip
- Live weighing-scale integration via a `Weighing Scale` config DocType plus a serial/network bridge that pushes stable weight into the active cart