Skip to main content
Waiter Ordering App for ERPNext — A handheld tableside ordering app for ERPNext that lets servers fire orders to the kitchen  — 1/1Illustrative preview

A handheld tableside ordering app for ERPNext that lets servers fire orders to the kitchen the moment they take them from the floor.

ECOSIRE builds, installs, and supports it against your ERPNext v15/v16 instance after we scope it with you.

What is Waiter Ordering App for ERPNext?

A handheld tableside ordering app for ERPNext that lets servers fire orders to the kitchen the moment they take them from the floor. ECOSIRE builds, installs, and supports it against your ERPNext v15/v16 instance after we scope it with you. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Mobile-first tableside interface for phones and tablets, served from your own ERPNext site — no separate login or third-party cloud
Floor-map table picker backed by a `Restaurant Table` DocType, with open/occupied/needs-attention state per table
Live item capture against the ERPNext Item master, variants, and active Price List — servers only ever fire what you actually sell
`Waiter Order` header + `Waiter Order Item` child DocTypes persist seat number, course, modifiers, and special instructions so nothing is lost between floor and kitchen
Instant fire-to-kitchen via a whitelisted `frappe.whitelist()` REST method — one tap sends the order the moment it's taken
Seat-level and course-level item assignment so appetizers, mains, and desserts pace correctly per guest
Real-time item status (new / preparing / ready / served) pushed back to the handheld through `frappe.publish_realtime`, no manual refresh
Modifier and special-instruction entry with server-script validation enforcing required/allowed modifier rules on the child table
Order edits, item voids, and re-fires with an audit trail — changes flow to the kitchen without re-keying the whole ticket
KDS/KOT integration driven off the same realtime channel and `hooks.py` doc events, so the kitchen display and handheld never drift apart
Maps completed orders onto POS Invoice / Sales Order so tax templates, revenue, and the stock ledger stay native in ERPNext
Role profile and permission rules scoping waiter, kitchen, and manager access to the right DocTypes and actions
Scheduler event to sweep stale/abandoned orders and reconcile any open tickets left at close
Built and tested for Frappe/ERPNext v15 and v16, installed alongside your existing customizations without forking core

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

Full-service restaurants lose money and goodwill in the walk between the table and the terminal. A server takes an order on a paper pad, crosses the floor to the ERPNext POS, keys it in, and only then does the kitchen see it. Every trip is a delay, and every re-keying is a chance to drop a modifier, mis-seat an item, or fire the wrong course. ERPNext ships a capable POS and a Sales Invoice / POS Invoice backbone, but out of the box it assumes a stationary cashier at a screen — there is no native handheld tableside flow, no seat-level item assignment, no kitchen-display fire, and no course pacing. Once you have more than a few tables turning, that gap is where the errors and the wait times live.

ECOSIRE builds a proper Frappe app (waiter_ordering) that installs into your existing ERPNext site rather than bolting on a disconnected third-party system. Servers open a mobile-first interface on a phone or tablet, pick a table from the floor map, and capture items straight against your live ERPNext Item master and Item Price / Price List — so what they tap is exactly what you sell, at the price ERPNext already knows. Orders are held in dedicated DocTypes (a Waiter Order header with Waiter Order Item child rows carrying seat number, course, modifiers, and special instructions) so nothing is lost between capture and the kitchen. A whitelisted REST method fires the order to the kitchen the instant the server hits send; hooks.py doc events and Frappe realtime (frappe.publish_realtime) push each item's status — new, preparing, ready, served — back to the handheld so the server knows what to run without walking to the pass.

Technically the app is grounded in ERPNext's own primitives. It reads Items, variants, and Price Lists directly; it maps completed orders onto POS Invoice / Sales Order so revenue, tax templates, and stock ledger stay in ERPNext with no reconciliation. Modifiers and course logic are enforced with server scripts and validation on the child table; a role profile and permission rules scope what waiters, kitchen staff, and managers can see and do. A scheduler event sweeps stale or abandoned orders, and the kitchen display is driven off the same realtime channel so KDS/KOT and handheld never drift apart. Everything targets Frappe/ERPNext v15 and v16, respects your existing customizations, and is delivered as clean, reviewable source in a git repository — no obfuscated blobs.

Because this is build-to-order, there is no instant download. We start with a short scoping call to confirm your floor layout, menu structure, modifier rules, KDS/printer setup, and ERPNext version, then hand you a fixed scope and quotation. Typical delivery is one working week from confirmed scope. We build on a staging copy of your site, run UAT with your team, keep a documented rollback plan, and only then install into production — followed by a post-go-live support window while your floor staff settle into it.

What you get

  • Installable source code for your version of the app, delivered as a clean Frappe app (`waiter_ordering`)
  • Installation and configuration on your ERPNext instance (staging first, then production)
  • Technical documentation: DocType schema, whitelisted methods, hooks, permissions, and realtime channels
  • User guide plus a live training session for floor, kitchen, and management staff
  • UAT on a staging copy of your site with a documented, tested rollback plan
  • Post-go-live support window to stabilize the app while your team adopts it
  • Git repository handover with full commit history and no obfuscated code
  • Configuration of role profiles, permissions, and menu/price-list mappings tailored to your setup

Who this is for

Full-service restaurant owner / operator

Runs one or more sit-down venues on ERPNext and wants faster table turns and fewer order errors. Needs servers to fire orders from the floor without walking to a terminal, while keeping all revenue and stock native in ERPNext.

Restaurant / F&B operations manager

Owns floor efficiency and service consistency. Wants seat- and course-level control, real-time kitchen status, and clean audit trails on edits and voids so shift performance and comps are accountable.

IT / ERPNext administrator

Maintains the ERPNext site and its customizations. Needs a proper Frappe app that installs cleanly on v15/v16, respects existing permissions and DocTypes, and ships as reviewable git source rather than a black-box integration.

Multi-outlet hospitality group

Operates several venues and standardizes on ERPNext for POS and inventory. Wants one consistent handheld ordering flow rolled out per site, mapped onto POS Invoice / Sales Order with per-location price lists and roles.

How Waiter Ordering App for ERPNext Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Tableside handheld orderingPurpose-built mobile flow served from your ERPNext sitePossible but you design and build it from scratchSometimes offered, often a separate app/cloudNone — POS assumes a stationary cashier terminal
ERPNext data integrationNative: reads Item master/Price List, posts POS Invoice/Sales OrderDepends entirely on your build qualityVaries; often syncs or duplicates dataFully native but no tableside layer to feed it
Seat, course & modifier controlPer-line seat/course/modifiers with validationWhatever you have time to build and testPartial; rarely matches your exact rulesNot supported at line level
Instant kitchen fire (KDS/KOT)Realtime fire + status back to handheldYou build the realtime channel yourselfSometimes, but often genericNo native KDS fire from POS
Fit to your menu & workflowScoped to your floor, menu, and rules before buildFully yours, at full cost and riskYou adapt to their assumptionsGeneric — no restaurant floor model
Delivery modelBuild-to-order, one working week from confirmed scopeOpen-ended timeline and budgetInstant install but generic fitAlready there, but the feature isn't
Code ownership & handoverFull source + git repo handover, no obfuscationYou own it because you wrote itUsually licensed, often closedCore code, not tailored to you
Support & version upgradesPost-go-live window + scoped v15/v16 update packagesYou maintain it foreverVendor SLA, variable qualityFrappe community/your admin

Frequently Asked Questions about Waiter Ordering App

How long until we can use it? Can I download it now?

No — this is build-to-order, not an instant marketplace download. We first run a scoping call to confirm your menu, floor layout, modifier rules, and ERPNext version, then send a fixed scope and quotation. Typical delivery is one working week from confirmed scope, including a staging build and UAT before we touch production.

Which ERPNext and Frappe versions does it support?

We build and test against Frappe/ERPNext v15 and v16. During scoping we confirm your exact version and any customizations so the app installs cleanly alongside them. If you're on an older version, we'll advise on the upgrade path or what a backport would involve.

How does it connect to our existing ERPNext POS and inventory?

It reads your live Item master, variants, and Price Lists directly, and maps completed orders onto POS Invoice / Sales Order. That means tax templates, revenue posting, and the stock ledger all stay native in ERPNext — there's no separate system to reconcile and no double entry.

How do orders actually reach the kitchen instantly?

When a server taps send, a whitelisted Frappe REST method commits the `Waiter Order` and fires it over `frappe.publish_realtime` to the kitchen display and any KOT printers. Item status changes (preparing, ready, served) push back to the handheld the same way, so no one walks to the pass to check a ticket.

What do we get at handover, and do we own the code?

You receive installable source for your version delivered as a proper Frappe app, technical documentation (DocTypes, whitelisted methods, hooks, permissions), a user guide, a training session, and a git repository with full history. It's your code — no obfuscated blobs and no per-seat lock-in on the app itself.

What happens after go-live for support and updates?

Every build includes a post-go-live support window to stabilize the app while your floor and kitchen staff adopt it. Beyond that, we offer ongoing support and update packages — including compatibility work when you upgrade ERPNext — which we scope with you rather than assume.

Can it handle seats, courses, and modifiers, not just a flat ticket?

Yes. The order child table carries seat number, course, modifiers, and special instructions per line, with server-script validation for required or allowed modifier rules. Courses can be paced so appetizers, mains, and desserts fire in the right order for each guest at the table.

Request a quote

Waiter Ordering App

A handheld tableside ordering app for ERPNext that lets servers fire orders to the kitchen the moment they take them from the floor. ECOSIRE builds, installs, and supports it against your ERPNext v15/v16 instance after we scope it with you.

  • Mobile-first tableside interface for phones and tablets, served from your own ERPNext site — no separate login or third-party cloud
  • Floor-map table picker backed by a `Restaurant Table` DocType, with open/occupied/needs-attention state per table
  • Live item capture against the ERPNext Item master, variants, and active Price List — servers only ever fire what you actually sell
  • `Waiter Order` header + `Waiter Order Item` child DocTypes persist seat number, course, modifiers, and special instructions so nothing is lost between floor and kitchen

Request a Quotation

Tell us about your Waiter Ordering App 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.