Skip to main content
Supermarket & Grocery POS for ERPNext — A high-speed grocery checkout for ERPNext with weight-embedded (EAN-13) barcode parsi — 1/1Illustrative preview

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.

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

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
High-speed multi-item scanning lane tuned for continuous scan-gun input without focus loss or per-item confirmation dialogs
PLU and quick-key produce grid (client-script driven, backed by a PLU field on `Item`) for loose goods that never carry a barcode
Mix-and-match, buy-X-get-Y and bulk-tier discounts enforced through `hooks.py` doc events on the POS invoice rather than manual cashier entry
Check-digit and rule validation on every scanned label so a malformed or foreign barcode is rejected instead of mispriced
Role profiles and permission rules separating cashier, supervisor and back-office rights for price overrides and rule editing
Scheduler-event jobs for end-of-day reconciliation exports and scale-drift / unresolved-barcode reporting
Posts as standard POS Invoice / Sales Invoice rows so stock ledger, inventory valuation and accounting remain native ERPNext
Barcode-rule and PLU configuration shipped as Frappe fixtures for repeatable deploy across lanes and stores
Manager override flow (price change, void, discount above threshold) with audit trail on the invoice
Compatible with Frappe/ERPNext v15 and v16, delivered as a versioned app in its own git repository

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

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

CriterionECOSIRECustom BuildCompetitorERPNext Native
Weight-embedded EAN-13 parsingBuilt in, configurable per scale prefixPossible but you build the parser and rule engine yourselfOften fixed to one label format or absentNo concept of embedded-weight barcodes
Live weighing-scale integrationSerial/network bridge to your confirmed scale modelBespoke integration you specify and maintainRarely included; usually manual weight entryNot supported
PLU quick-key produce entryClient-script grid backed by an Item PLU fieldBuild from scratch on the POS UIVaries; frequently a basic favorites listManual item search only
Mix-and-match / bulk discountsEnforced via hooks.py doc events on the invoiceYou design and code the discount engineLimited to the app's fixed pricing rulesBasic pricing rules, no embedded-label logic
Fit with ERPNext corePosts as standard POS/Sales Invoice, stock & GL nativeDepends entirely on developer disciplineMay diverge from core document flowNative but lacks grocery checkout features
Ownership & maintainabilityOwn the git repo, fixtures and versioned appYou own it but carry all the build riskVendor-controlled, closed roadmapNo custom code to own
Delivery modelBuild-to-order, one working week from confirmed scopeOpen-ended project timeline and costInstant install but generic fitAvailable immediately, missing capabilities
Support after go-livePost-go-live support window + optional maintenanceWhoever built it, if still availableForum or paid support, feature-dependentCommunity/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.

Request a quote

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

Request a Quotation

Tell us about your Supermarket & Grocery POS 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.