Skip to main content
Self-Service Kiosk for ERPNext POS — A touchscreen self-order kiosk for QSRs, food courts and retail that lets customers plac — 1/1Illustrative preview

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.

What is 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. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

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

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

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.

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 one working week 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.

How Self-Service Kiosk for ERPNext POS Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Fit to your menu, hardware & payment providerBuilt to your exact scope, confirmed on a call before work startsFully custom but you specify and manage every detailGeneric feature set; you bend your setup to fit itNo customer-facing kiosk surface at all
Data modelFirst-class Kiosk DocTypes writing real `POS Invoice` recordsWhatever your team designs and maintainsOften shadow tables loosely mapped to POS`POS Profile`/`POS Invoice` only, cashier-operated
Unattended payment & KDSProvider adapter + `hooks.py` KDS/ticket push, idempotentBuild and harden it yourselfSometimes present, integration depth variesNot included
Delivery modelBuild-to-order, one working week from confirmed scopeOpen-ended; depends on your team's bandwidthInstant install but genericAvailable immediately, no kiosk
Version supportTargeted and tested on Frappe/ERPNext v15 & v16Whatever you build and keep currentDepends on maintainer's release cadenceCore POS ships with ERPNext
Source & ownershipFull source + git repo handover for your buildYou own it outrightUsually closed or license-restrictedOpen source, but no kiosk to own
Support & updatesPost-go-live support window + optional upgrade scopeSelf-supportedVendor tickets, shared roadmapCommunity/your ERPNext partner
Accessibility & multilingualBuilt-in a11y mode + Frappe translations from day oneOnly if you scope and build itVaries, often limitedNot applicable (no kiosk UI)

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 one working week 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.

Request a quote

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

Request a Quotation

Tell us about your Self-Service Kiosk for ERPNext 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.