Product details are displayed in English. Translations coming soon.
Quick facts
- Price
- $499.00 USD
- ERPNext versions
- —
- Setup time
- 30 min
- License
- One-time perpetual
- Languages
- 11 languages
एक बार की खरीदारी
Self-Service Kiosk for ERPNext POS
A touchscreen self-order kiosk for QSRs, food courts and retail that lets customers place orders and pay unattended, writing straight into ERPNext POS. ECOSIRE builds, installs and supports it for your menu, hardware and payment provider.
$499.00USD
अभी कोई भुगतान नहीं। यह हमारी टीम को एक कोटेशन अनुरोध भेजता है — हम कीमत और अगले चरणों के साथ ईमेल द्वारा संपर्क करेंगे।
प्रमुख सुविधाएँ
Custom Frappe app installed on your bench beside `erpnext`, with `Kiosk Session`, `Kiosk Order`, `Kiosk Payment Attempt` and `Kiosk Device` DocTypes rather than ad-hoc customizations
Touch-first guest front end (bundled Frappe page or Vue/React build) that writes only through `@frappe.whitelist()` methods and the Frappe REST API — no direct DB writes
Server-side cart pricing that reuses ERPNext Pricing Rules, tax templates and `Item` variants so kiosk prices always match the POS
Menu, modifier and combo modeling via `Item` attributes/variants and item groups, with per-item availability toggles
Upsell and cross-sell prompts (suggested add-ons, meal upgrades, combos) configurable per item group without code changes
On successful payment, creates a submitted `POS Invoice` against the session's `POS Profile` — full accounting, stock and reporting for free
`hooks.py` doc events (`on_submit`/`on_update`) that fire order-number ticket print and KDS payload push atomically with the sale
Payment adapter for card terminal, wallet or dynamic QR, reconciled to a `Mode of Payment`; card data never touches ERPNext
Idempotent order and payment handling (client + server tokens) so double-taps, retries or dropped networks never double-charge or double-fire the kitchen
Kitchen Display (KDS) push and printed order-number ticket so guests are called by number, staff work from a queue
Dedicated `Kiosk Device` role profile and restricted API user scoping the kiosk to only the methods and DocTypes it needs
`scheduler_events` background jobs to reap abandoned sessions, release held stock and run end-of-day session close
Multilingual menus via Frappe translations plus an accessibility mode: large-tap targets, high-contrast, screen-reader labels, reachable layout
Kiosk-to-cashier fallback: sessions carry a cashier-of-record so a supervisor can void, refund or assist from standard ERPNext POS
Built and tested for Frappe/ERPNext v15 and v16, delivered as a versioned, upgrade-aware app
इस उत्पाद के बारे में
Queues kill throughput. At peak, a QSR or food-court counter can only take orders as fast as staff can tap them into ERPNext POS — so customers walk, average ticket drops because nobody has time to upsell, and you pay for cashiers whose job is really just data entry. ERPNext ships a capable cashier-facing POS Profile and POS Invoice flow, but it assumes a trained operator behind the screen. There is no customer-facing, hardware-locked, self-order surface: no kiosk session lifecycle, no modifier/upsell prompts a guest can drive, no unattended payment capture, and no clean handoff of a paid order to the kitchen. That is exactly the road where ERPNext native runs out.
Self-Service Kiosk for ERPNext POS क्यों चुनें
Custom Frappe app installed on your bench beside `erpnext`, with `Kiosk Session`, `Kiosk Order`, `Kiosk Payment Attempt` and `Kiosk Device` DocTypes rather than ad-hoc customizations
Touch-first guest front end (bundled Frappe page or Vue/React build) that writes only through `@frappe.whitelist()` methods and the Frappe REST API — no direct DB writes
Server-side cart pricing that reuses ERPNext Pricing Rules, tax templates and `Item` variants so kiosk prices always match the POS
Menu, modifier and combo modeling via `Item` attributes/variants and item groups, with per-item availability toggles
Upsell and cross-sell prompts (suggested add-ons, meal upgrades, combos) configurable per item group without code changes
On successful payment, creates a submitted `POS Invoice` against the session's `POS Profile` — full accounting, stock and reporting for free
ECOSIRE builds a proper Frappe application — a custom app installed on your bench alongside erpnext, not a pile of manual customizations — that adds a locked-down, touch-first ordering front end backed by your existing ERPNext instance. We model the kiosk domain as first-class DocTypes: a Kiosk Session (device, POS Profile, cashier-of-record, opening state), a Kiosk Order staging document that maps to items, Item variants and a modifier/attribute structure, and a Kiosk Payment Attempt that records each terminal interaction. A dedicated Kiosk Device role profile and restricted API user keep the kiosk's permissions to exactly what it needs. The guest UI is a self-contained web front end (Frappe page / bundled assets, or a Vue/React build served by the app) that talks to the backend only through @frappe.whitelist() methods and the Frappe REST API — never direct DB access — so every write is validated and auditable.
Technically, order build-up and payment run server-side. Whitelisted methods assemble the cart, price it through ERPNext's own pricing rules and taxes, and on payment success create a submitted POS Invoice against the session's POS Profile. hooks.py document events (on_submit, on_update) fire the downstream actions: push an order-number ticket, emit the kitchen-display (KDS) payload, and update session totals. Payment is integrated to your chosen provider (card terminal, wallet, or dynamic QR) via a thin adapter, with the terminal result reconciled to a Mode of Payment — we never ask the kiosk to hold card data. Client scripts and the front end handle idempotency and timeouts so a double-tap or a dropped network never double-charges or double-fires the kitchen. A scheduler_events job reaps abandoned sessions, releases held stock, and closes the day. Multilingual menus and an accessibility mode (large-tap, high-contrast, screen-reader labels, wheelchair-height layout) are built in from the DocType translations and front-end config. It is targeted and tested on Frappe/ERPNext v15 and v16.
Because this is build-to-order, nothing is a generic download. We start with a short scoping call to lock your menu structure, modifiers, hardware (kiosk shell, card terminal, printer, KDS), payment provider and languages, then build against that spec. You get the installable source for your version, a staging deployment for UAT, and a documented go-live with a rollback plan. Typical delivery is 2 to 4 weeks from confirmed scope, depending on how many payment and hardware integrations are in play.
What you get
- Installable source code for your version of the kiosk app, pinned to Frappe/ERPNext v15 or v16
- Installation and configuration on your bench, including `POS Profile`, role profile, payment adapter and hardware wiring
- Technical documentation: DocType schema, whitelisted API methods, `hooks.py` events, scheduler jobs and configuration reference
- Operator/manager user guide plus a live training session for staff and supervisors
- UAT on a staging site with a signed-off test checklist before go-live, and a documented rollback plan
- Post-go-live support window for defect fixes and configuration tuning after launch
- Git repository handover with full commit history and tagged release for your build
- Payment provider and hardware integration notes (terminal, printer, KDS) specific to your deployment
Who this is for
QSR & fast-casual operators
Multi-lane counters where peak-hour queues cap revenue. They need guests to self-order and pay so cashiers move to expediting, and every order still lands in ERPNext POS with correct pricing, tax and stock.
Food-court & multi-brand operators
Sites running several concepts on one ERPNext instance who want a consistent self-order surface per stall, each mapped to its own `POS Profile`, KDS and payment terminal, with number-based pickup.
Retail & convenience managers
Stores adding unattended checkout or grab-and-go lanes who need barcode/`Item` lookup, integrated card/QR payment, and full audit trail through standard `POS Invoice` documents.
ERPNext-standardized IT / operations leads
Teams that run ERPNext as their system of record and refuse bolt-on POS silos. They want a maintainable Frappe app with proper DocTypes, permissions and REST APIs that upgrades cleanly across v15/v16.
Installation overview
Download from ECOSIRE
Buy the license on ecosire.com and download the Self-Service Kiosk for ERPNext POS 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 Self-Service Kiosk for ERPNext POS 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 Self-Service Kiosk for ERPNext POS Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Fit to your menu, hardware & payment provider | Built to your exact scope, confirmed on a call before work starts | Fully custom but you specify and manage every detail | Generic feature set; you bend your setup to fit it | |
| Data model | First-class Kiosk DocTypes writing real `POS Invoice` records | Whatever your team designs and maintains | Often shadow tables loosely mapped to POS | |
| Unattended payment & KDS | Provider adapter + `hooks.py` KDS/ticket push, idempotent | Build and harden it yourself | Sometimes present, integration depth varies | |
| Delivery model | Build-to-order, 2-4 weeks from confirmed scope | Open-ended; depends on your team's bandwidth | Instant install but generic | |
| Version support | Targeted and tested on Frappe/ERPNext v15 & v16 | Whatever you build and keep current | Depends on maintainer's release cadence | |
| Source & ownership | Full source + git repo handover for your build | You own it outright | Usually closed or license-restricted | |
| Support & updates | Post-go-live support window + optional upgrade scope | Self-supported | Vendor tickets, shared roadmap | |
| Accessibility & multilingual | Built-in a11y mode + Frappe translations from day one | Only if you scope and build it | Varies, often limited |
Frequently Asked Questions about Self-Service Kiosk for ERPNext POS
How long does delivery take?
This is build-to-order, not an instant download. After a short scoping call to confirm your menu, hardware, payment provider and languages, typical delivery is 2 to 4 weeks from confirmed scope. The range depends mainly on how many payment and hardware integrations are involved. You review and sign off on a staging site before we go live.
Is this an existing app I can just install from the Frappe marketplace?
No. ECOSIRE builds it for your deployment as a custom Frappe app installed on your bench beside `erpnext`. You receive the source code, a git repository handover and documentation for your version, rather than a shared marketplace download.
Which ERPNext versions are supported?
We build and test against Frappe/ERPNext v15 and v16. During scoping we confirm your exact version and target the app to it so it installs and upgrades cleanly. If you are on an older version we will advise on the upgrade path before starting.
How does payment actually work, and is card data safe?
Payment runs through a thin adapter to your chosen provider — card terminal, wallet or dynamic QR. The kiosk never stores or processes raw card data; the terminal or gateway handles the sensitive part and returns a result, which we reconcile to an ERPNext `Mode of Payment` and record as a `Kiosk Payment Attempt`. On success the app creates a submitted `POS Invoice`.
What happens to the order after payment — how does the kitchen see it?
On payment success, `hooks.py` document events fire atomically with the sale: an order-number ticket is printed and the order payload is pushed to your Kitchen Display (KDS). Guests are called by number. Because the sale is a real `POS Invoice`, stock, tax and reporting all update through standard ERPNext.
Do you offer support and updates after go-live?
Yes. Every engagement includes a post-go-live support window for defect fixes and configuration tuning. Because you own the source and git repository, you can also extend it yourself or contract ECOSIRE for later enhancements and version upgrades (for example moving from v15 to v16) under a separate scope.
Can one kiosk build handle multiple brands or stalls?
Yes. Each kiosk session is tied to a `POS Profile`, so a food court can run several concepts on one ERPNext instance, each with its own menu, KDS, terminal and pickup numbering. We confirm the exact multi-profile layout during scoping.
Related Modules
कोटेशन का अनुरोध करें
Self-Service Kiosk for ERPNext POS
A touchscreen self-order kiosk for QSRs, food courts and retail that lets customers place orders and pay unattended, writing straight into ERPNext POS. ECOSIRE builds, installs and supports it for your menu, hardware and payment provider.
- Custom Frappe app installed on your bench beside `erpnext`, with `Kiosk Session`, `Kiosk Order`, `Kiosk Payment Attempt` and `Kiosk Device` DocTypes rather than ad-hoc customizations
- Touch-first guest front end (bundled Frappe page or Vue/React build) that writes only through `@frappe.whitelist()` methods and the Frappe REST API — no direct DB writes
- Server-side cart pricing that reuses ERPNext Pricing Rules, tax templates and `Item` variants so kiosk prices always match the POS
- Menu, modifier and combo modeling via `Item` attributes/variants and item groups, with per-item availability toggles