Skip to main content
Kitchen Display System (KDS) for ERPNext — A real-time kitchen display that streams ERPNext POS orders straight to cook stati — 1/1Illustrative preview

A real-time kitchen display that streams ERPNext POS orders straight to cook stations with color-coded prep

timers, bump-bar controls and multi-station routing.

ECOSIRE builds, installs and supports it as a native Frappe app after we scope your kitchen with you.

What is Kitchen Display System (KDS) for ERPNext?

A real-time kitchen display that streams ERPNext POS orders straight to cook stations with color-coded prep timers, bump-bar controls and multi-station routing. ECOSIRE builds, installs and supports it as a native Frappe app after we scope your kitchen 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

Native Frappe app installed into your bench (e.g. `ecosire_kds`) with `KDS Ticket`, `KDS Ticket Item` and `KDS Station` DocTypes — no external iframe or third-party cloud dependency
`hooks.py` `doc_events` on `POS Invoice` (`on_submit`/`on_update`) that creates and syncs tickets automatically as orders are rung up
Live order queue rendered over the Frappe realtime websocket (`frappe.realtime`) so tickets appear on screen with no refresh or polling
Color-coded prep timers that transition green→amber→red against per-item-group target times you define
Multi-station / multi-kitchen routing driven by a server script that maps ERPNext item groups to `KDS Station` records
Cloud-kitchen mode: several brands sharing a pass each get isolated station views filtered by brand/POS profile
Physical bump-bar and touchscreen support — bump item, bump ticket, and fire 'order ready' from the line
Recall (un-bump) control to reverse an accidental bump without re-firing the whole ticket
Modifier, special-instruction and allergen highlighting pulled from the POS line so the cook can't miss them
Whitelisted methods exposed over the Frappe REST API for bump/recall/ready actions and for external hardware integration
Role profiles and permissions (Kitchen Staff, Expeditor, Kitchen Manager) gating who can void, recall or reconfigure stations
`scheduler_events` reconciliation job that re-syncs any ticket whose underlying POS document changed out-of-band
Optional KOT printing fallback (via `frappe.print` / print format) that keeps the line running if a screen or network drops
Client scripts on the POS/ticket views for expo-side overrides and status corrections, plus configurable target-time and station setup in the ERPNext UI

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

Restaurants and cloud kitchens running ERPNext POS take orders cleanly, but the moment the ticket needs to reach the line it falls back to printed KOTs or shouted callouts. ERPNext core has no live kitchen screen: there is no POS Invoice fan-out to a cook display, no prep-timer state, no per-station routing, and no "order ready" acknowledgement flowing back into the system. As soon as you run more than one prep station, or a cloud kitchen with several brands sharing a pass, paper tickets stall, items get re-fired, and expo has no view of what is actually late. That gap is exactly where a purpose-built KDS earns its place.

ECOSIRE builds a proper Frappe app (for example ecosire_kds) installed into your ERPNext bench, not a bolt-on iframe. The core is a set of DocTypes — a KDS Ticket and child KDS Ticket Item that mirror each POS Invoice/POS Order, plus a KDS Station DocType defining each screen and the item groups it owns. A hooks.py doc_events handler on POS Invoice (on_submit, on_update) creates and updates tickets, and a server script applies your routing rules so a burger line, a fryer, and a drinks station each see only their own items. The screen itself is a Frappe-served page (or Frappe UI/Vue app) that subscribes over the realtime socket (frappe.realtime/websocket) so new orders appear instantly with color-coded prep timers that shift green→amber→red against your target times.

On the line, cooks drive the board with a physical bump bar or touchscreen: bump an item, bump a whole ticket, recall an accidental bump, and fire an "order ready" that writes back to the ticket status and can notify the pass or front-of-house. Modifiers and allergen notes are highlighted so nothing gets missed, and a scheduler event (a scheduler_events cron entry) reconciles any tickets whose POS document changed out-of-band, so the screen never drifts from ERPNext. State changes are exposed through whitelisted methods over the Frappe REST API, and every action is permission-gated with dedicated role profiles (Kitchen Staff, Expeditor, Kitchen Manager) so only the right people can void or recall. If a screen or the network drops, an optional KOT printing fallback keeps the line moving.

Because this is build-to-order, we start from your real kitchen: how many stations, which item groups route where, your target prep times, whether you run one brand or several under a cloud-kitchen pass. After a short scoping call ECOSIRE writes the app against Frappe/ERPNext v15 or v16, tests it on a staging copy of your site, runs UAT with your team, and then installs it on production with a rollback plan. Typical delivery is one working week from confirmed scope. You receive the full source in a git repository, so nothing about the system is locked away from you.

What you get

  • Installable source code for your version of the KDS Frappe app, built for your ERPNext bench
  • Installation and configuration on your ERPNext instance — stations, routing rules and target prep times set up with you
  • Technical documentation covering DocType schema, `hooks.py` doc events, whitelisted methods and scheduler jobs
  • User guide plus a live training session for kitchen staff, expo and managers
  • Post-go-live support window for defect fixes and adjustments after launch
  • UAT on a staging copy of your site before production, with a documented rollback plan
  • Full git repository handover so you own and can extend the source
  • Compatibility validation against your Frappe/ERPNext v15 or v16 version and POS setup

Who this is for

Multi-station restaurant operator

Runs a kitchen with separate grill, fryer, cold and drinks stations and wants each screen to show only its own items, with expo seeing the whole pass — replacing printed KOTs and shouted callouts.

Cloud kitchen / ghost kitchen manager

Operates several delivery brands out of one facility on shared ERPNext POS and needs paperless, brand-isolated ticket flow so orders from different brands never collide on the same board.

ERPNext restaurant IT / operations lead

Owns the ERPNext deployment and wants a native Frappe app — proper DocTypes, doc events, REST-accessible methods and role permissions — rather than a fragile third-party integration they can't inspect or extend.

Franchise or multi-outlet F&B owner

Needs a consistent, timer-driven kitchen workflow rolled out across outlets, with the source code in hand so the same KDS can be standardized and extended per location.

How Kitchen Display System (KDS) for ERPNext Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
POS integrationNative `POS Invoice` doc-event hooks, streamed over Frappe realtimeDepends on your team's depth in Frappe hooksOften generic sync, may not match your POS profileNo kitchen screen — printed KOT only
Multi-station routing`KDS Station` DocType maps item groups to screensBuildable but you design the schema yourselfFixed routing model, hard to bend to your layoutNot available
Prep timersColor-coded green→amber→red against your target timesWhatever you have time to implementBasic timers, limited configurabilityNone
Bump bar / order-readyPhysical bump-bar + touchscreen with recall and ready-backHardware wiring and state left to youSometimes touchscreen-only, recall variesNot applicable
Cloud-kitchen brand isolationPer-brand / POS-profile filtered station viewsPossible with significant effortUsually single-brand assumptionNot applicable
PermissionsDedicated role profiles for staff, expo and managersYou define and maintain the role modelCoarse or fixed rolesGeneric ERPNext roles only
Source ownershipFull git repo handover, you own and extend itYou own it but also carry all the build costTypically closed / license-lockedCore is open but has no KDS to own
Delivery modelBuild-to-order, tested on staging, one working weekTimeline depends on internal capacityInstant install but generic fitAlready present, but no feature

Frequently Asked Questions about Kitchen Display System (KDS)

How long does delivery take?

This is a build-to-order product, not an instant download. After a short scoping call to lock your stations, routing rules and target prep times, typical delivery is one working week from confirmed scope. That covers building the Frappe app, testing it on a staging copy of your ERPNext site, UAT with your team, and production install.

Which ERPNext versions do you support?

We build against Frappe/ERPNext v15 and v16. During scoping we confirm your exact version and POS setup so the app is written and tested for the site it will actually run on.

How does the KDS get orders from ERPNext POS?

The app hooks `POS Invoice` doc events in `hooks.py`, so when an order is submitted or updated a `KDS Ticket` is created and streamed to the right station screens over the Frappe realtime websocket — no manual re-entry and no separate order source to keep in sync.

Can it route items to different kitchen stations?

Yes. Routing is driven by `KDS Station` records that map ERPNext item groups to screens, applied by a server script. A grill line, fryer and drinks station each see only their items, and cloud kitchens can isolate views per brand or POS profile.

What about support and updates after go-live?

Every build includes a post-go-live support window for defect fixes and adjustments. Because you receive the full source in a git repository, you can also extend it yourself, and ECOSIRE can quote ongoing maintenance or version-upgrade work (for example an ERPNext v15→v16 move) separately.

What if a screen or the network goes down mid-service?

We include an optional KOT printing fallback so the line keeps moving if a display or the network drops, and a scheduler reconciliation job re-syncs any ticket whose POS document changed while a screen was offline, so the board never drifts from ERPNext.

Do we get the source code?

Yes. You receive the full app source in a git repository at handover, along with technical documentation of the DocTypes, doc events, whitelisted methods and scheduler jobs. Nothing is locked away — you own your version.

Request a quote

Kitchen Display System (KDS)

A real-time kitchen display that streams ERPNext POS orders straight to cook stations with color-coded prep timers, bump-bar controls and multi-station routing. ECOSIRE builds, installs and supports it as a native Frappe app after we scope your kitchen with you.

  • Native Frappe app installed into your bench (e.g. `ecosire_kds`) with `KDS Ticket`, `KDS Ticket Item` and `KDS Station` DocTypes — no external iframe or third-party cloud dependency
  • `hooks.py` `doc_events` on `POS Invoice` (`on_submit`/`on_update`) that creates and syncs tickets automatically as orders are rung up
  • Live order queue rendered over the Frappe realtime websocket (`frappe.realtime`) so tickets appear on screen with no refresh or polling
  • Color-coded prep timers that transition green→amber→red against per-item-group target times you define

Request a Quotation

Tell us about your Kitchen Display System (KDS) 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.