Skip to main content
QR Code Contactless Ordering for ERPNext — Per-table QR menus that let guests browse, order and pay from their phone, injecti — 1/1Illustrative preview

Per-table QR menus that let guests browse, order and pay from their phone,

injecting orders straight into ERPNext POS and the kitchen. A build-to-order Frappe app that

ECOSIRE scopes, builds, installs and supports for your restaurant.

What is QR Code Contactless Ordering for ERPNext?

Per-table QR menus that let guests browse, order and pay from their phone, injecting orders straight into ERPNext POS and the kitchen. A build-to-order Frappe app that ECOSIRE scopes, builds, installs and supports for your restaurant. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Per-table `Table QR` DocType that mints a unique signed token per table and regenerates codes on demand without breaking open sessions
Guest-facing mobile menu served from a Frappe website route — no app install, works on any phone browser
Menu items linked to your existing ERPNext `Item` records so prices, tax templates and stock stay single-source
Modifiers and variants stored in a linked child table with real per-option price deltas, priced server-side
`@frappe.whitelist(allow_guest=True)` order endpoint that validates the table token and re-prices every line against ERPNext
`Guest Order Session` DocType tracking each table from first scan through settled bill, with state machine and abandoned-session cleanup
`hooks.py` doc events that turn an accepted order into a `POS Invoice` (or approval-gated draft) plus a KDS/print ticket
Direct injection into your POS and Kitchen Display flow with Frappe real-time events so counter and kitchen screens update live
Pay-at-table via an integrated gateway of your choice, confirmed by a webhook-driven whitelisted endpoint and server-script settlement
Locked-down guest role profile and permission rules so a guest session can only read the menu and write its own order
Multilingual menus with per-language item names, descriptions and allergen tags driven by Frappe translations
Photo-rich menu cards with category grouping, out-of-stock flags and allergen/dietary badges
Scheduler event that sweeps abandoned or half-paid sessions and reconciles them against open POS invoices
Live table board panel inside ERPNext Desk built with client scripts for managers to watch orders and payment status
Built and tested against Frappe/ERPNext v15 and v16 using the standard REST API and permission model for upgrade safety

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

Dine-in restaurants running ERPNext hit a wall the moment they want guests to order from their own phones. ERPNext POS is built for a cashier or waiter standing at a terminal — there is no customer-facing menu, no per-table session, no self-service cart, and no way for a guest to trigger a POS Invoice or a Kitchen Display ticket without staff keying it in. Printed QR codes that just link to a PDF menu solve nothing: the order still gets shouted across the floor, re-typed at the till, and lost when it is busy. That gap — between a scanned table and a costed, tax-correct order sitting inside ERPNext — is exactly what this build closes.

ECOSIRE builds a proper Frappe app (installed on your bench, not a hosted third party) that adds a guest-facing ordering front end and the server-side plumbing to land every order cleanly in ERPNext. We model the domain as first-class DocTypes: a Table QR DocType generates a unique signed token per table, a Guest Order Session tracks an open table from first scan to settled bill, and menu items map to your existing Item records with modifiers stored as a linked child table so a "no onions, extra cheese" choice carries a real price delta. The scan opens a mobile web menu served from a Frappe website route; guests browse categories, photos, allergen tags and translated names, build a cart with modifiers, and submit. Submission calls a @frappe.whitelist(allow_guest=True) method that validates the table token, prices the line items server-side against ERPNext (never trusting the client), and creates the order under a locked-down role profile so a guest can write only their own session.

On the kitchen and billing side we wire the order into your real workflow with hooks.py doc events and server scripts: an accepted order emits a POS Invoice (or a draft order document you approve at the till, depending on your close-out preference) and a KDS/print ticket, updates the Guest Order Session state, and fires Frappe real-time events so the counter and kitchen screens refresh without a reload. Pay-at-table is handled by integrating a payment gateway of your choice — the guest pays from the phone, the gateway webhook hits a whitelisted endpoint, and on confirmation a server script marks the invoice paid and closes the session. A scheduler event sweeps abandoned sessions and reconciles any half-paid tables so nothing is left dangling. Client scripts and a small Frappe UI panel give your managers a live table board inside ERPNext Desk. Everything targets Frappe/ERPNext v15 and v16 and uses the standard REST API and permission system, so it survives upgrades instead of fighting them.

Because this is build-to-order, nothing ships until we agree scope. You are not downloading a generic app off a marketplace and hoping it fits — we start with a short scoping call, confirm your table layout, menu structure, tax/pricing rules, KDS setup and which payment gateway you use, then build against your ERPNext instance. Typical delivery is one working week from confirmed scope, depending on how many gateways, languages and edge cases (split bills, service charge, tips) are in play. We install and configure it on a staging site first, run UAT with your team, then cut over to production with a rollback plan and a post-go-live support window. You receive the full source, the git repository, technical and user documentation, and a training session for your floor and kitchen staff.

What you get

  • Installable source code for your version of the app, built against your ERPNext v15/v16 instance
  • Installation and configuration on your bench — DocTypes, roles, website routes, KDS/POS wiring and gateway keys
  • Technical documentation: DocType schema, whitelisted endpoints, hooks/doc events, server scripts and scheduler jobs
  • User guide plus a live training session for floor, kitchen and management staff
  • UAT on a staging site with your real menu and table layout, and a documented cutover and rollback plan
  • Post-go-live support window for bug fixes and configuration adjustments after production launch
  • Handover of the full git repository with commit history and a README for future maintainers
  • Payment gateway integration configured and webhook-tested end to end for one gateway (additional gateways scoped separately)

Who this is for

Dine-in restaurant owner on ERPNext

Already runs POS, inventory and accounting in ERPNext and wants guests to order and pay from their phones without buying a separate ordering SaaS that won't talk to their books. Needs orders and revenue to land in the same ERPNext they already reconcile.

Multi-outlet cafe or QSR operations manager

Runs several locations and wants one consistent contactless flow, per-table sessions and a live table board across outlets. Cares about staff load, table turnover and orders hitting the kitchen instantly without re-keying.

Restaurant IT lead or Frappe partner

Owns the ERPNext instance and needs a real Frappe app with clean DocTypes, whitelisted methods and permissions they can read, upgrade to v16 and maintain — not an opaque plugin. Wants the git repo and docs on handover.

Hospitality group finance/controller

Needs pay-at-table settlements to reconcile automatically against POS invoices, correct tax templates applied server-side, and no gap between what the guest paid and what ERPNext records.

How QR Code Contactless Ordering for ERPNext Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Fit to your ERPNext setupBuilt to your menu, tables, tax and KDS flowFully bespoke if you have the in-house teamGeneric, bend your process to fit itNo guest ordering concept at all
Order path into ERPNextServer-priced order → POS Invoice + KDS via hooksWhatever you build and maintainOften a separate ledger or CSV syncStaff manually key every order at the till
Pay-at-tableGateway integrated, webhook-settled to the invoiceYou wire and test the gateway yourselfFixed to their gateway list, extra feesNot supported — pay at counter only
Guest experienceNo-install web menu, photos, allergens, multilingualDepends entirely on your build effortTemplated menu, limited branding/languageNone
Code ownershipFull source + git repo handed overYou own it but also own all the riskClosed plugin, vendor lock-inN/A
Upgrade safety (v15/v16)Standard DocTypes, API and permissions, tested on bothOnly as clean as your team keeps itMay lag or break on ERPNext upgradesCore, but no ordering feature to upgrade
Time to liveone working week from confirmed scopeMonths of in-house build and testingFast install, slow to make it actually fitImmediate, but the capability isn't there
Support after launchPost-go-live support window + trainingYou are your own supportTiered SaaS support, per-seat costsCommunity forums only

Frequently Asked Questions about QR Code Contactless Ordering

How long does delivery take?

This is build-to-order, so nothing ships instantly. After a scoping call to confirm your menu, tables, tax rules, KDS setup and payment gateway, typical delivery is one working week from confirmed scope. The range depends on how many payment gateways, languages and edge cases like split bills, service charge or tips you need.

Is this a ready-made app I can download from the Frappe marketplace?

No. ECOSIRE builds, installs and supports it for your specific ERPNext instance. We write it as a proper Frappe app with its own DocTypes, whitelisted methods and hooks, tailored to your menu structure, POS/KDS flow and gateway — then hand you the source and git repo. It is not a generic marketplace download.

Which ERPNext versions do you support, and how do updates work?

We build and test against Frappe/ERPNext v15 and v16 using the standard REST API and permission model so it survives upgrades. After go-live you get a support window for bug fixes and config adjustments. Beyond that, because you own the source and git repo, we can scope ongoing maintenance or a v16 upgrade pass as a follow-on engagement.

How do guest orders reach the kitchen and the till?

When a guest submits, a whitelisted server method validates the table token, prices the order server-side against ERPNext, and via hooks.py doc events creates a POS Invoice (or an approval-gated draft, your choice) plus a KDS/print ticket. Frappe real-time events refresh the kitchen and counter screens live, and a manager table board inside ERPNext Desk shows every open session.

How does pay-at-table work and does it reconcile with our accounts?

The guest pays from their phone through a payment gateway we integrate. The gateway webhook hits a whitelisted endpoint; on confirmation a server script marks the corresponding POS Invoice paid and closes the table session. Tax templates are applied server-side against your ERPNext setup so settlements reconcile cleanly against invoices, with no separate ledger to merge.

Can guests order without installing an app, and in their own language?

Yes. Scanning the QR opens a mobile web menu served from a Frappe website route — no app install, any phone browser works. Menus are multilingual with per-language item names, descriptions and allergen tags driven by Frappe translations, plus photos, category grouping and dietary badges.

What do we actually receive at handover?

You get the installable source code for your version, installation and configuration on your bench, technical documentation covering the DocTypes, endpoints, hooks and scheduler jobs, a user guide and staff training session, UAT on staging with a rollback plan, a post-go-live support window, and the full git repository so any Frappe developer can maintain it later.

Request a quote

QR Code Contactless Ordering

Per-table QR menus that let guests browse, order and pay from their phone, injecting orders straight into ERPNext POS and the kitchen. A build-to-order Frappe app that ECOSIRE scopes, builds, installs and supports for your restaurant.

  • Per-table `Table QR` DocType that mints a unique signed token per table and regenerates codes on demand without breaking open sessions
  • Guest-facing mobile menu served from a Frappe website route — no app install, works on any phone browser
  • Menu items linked to your existing ERPNext `Item` records so prices, tax templates and stock stay single-source
  • Modifiers and variants stored in a linked child table with real per-option price deltas, priced server-side

Request a Quotation

Tell us about your QR Code Contactless Ordering 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.