Skip to main content
Table & Reservation Management for ERPNext — A build-to-order Frappe app that turns ERPNext into a full-service reservation a — 1/1Illustrative preview

A build-to-order Frappe app that turns ERPNext into a full-service reservation and floor-management system with

a drag-and-drop floor plan, online bookings, waitlists and turn-time analytics.

ECOSIRE scopes, builds, installs and supports it for you.

What is Table & Reservation Management for ERPNext?

A build-to-order Frappe app that turns ERPNext into a full-service reservation and floor-management system with a drag-and-drop floor plan, online bookings, waitlists and turn-time analytics. ECOSIRE scopes, builds, installs and supports it for 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

Drag-and-drop visual floor plan editor built as a Frappe Page + client script, persisting layout as JSON on a `Floor Plan` DocType
Dedicated `Restaurant Table` DocType with capacity, min/max covers, zone, merge-able flag and live status
`Table Reservation` DocType with a server-enforced state machine (Requested/Confirmed/Seated/Completed/No-Show/Cancelled) via `hooks.py` doc events
Guest-accessible online booking widget backed by a `@frappe.whitelist(allow_guest=True)` availability-and-create method
Availability engine that checks requested slots against confirmed reservations and configurable turn-time rules before allowing a booking
`Waitlist Entry` DocType with position tracking and quoted-wait estimates driven by live table status
SMS/WhatsApp-ready 'table ready' notifications via ERPNext's Notification framework dispatched through a queued background job
Deposit / prepayment capture on bookings that posts against ERPNext accounting and auto-voids or applies on arrival
`scheduler_events` cron sweep that releases expired holds and auto-flags no-shows on a defined interval
Table-turn and dwell-time capture with Script/Query Reports for average turn time, peak-hour utilisation and no-show rate by zone
Table merge/split support for combining adjoining tables into a single party without breaking capacity checks
Reservation linked to the ERPNext `Customer` record so booking history, deposits and covers reconcile with sales data
Role profiles and DocType permissions scoping host, server and manager access to the floor and reservation data
REST-API-driven live floor refresh so the host screen reflects seat/clear actions in near real time
Built and tested against Frappe/ERPNext v15 and v16 as a standalone, upgrade-friendly custom 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

Full-service restaurants live and die by their floor. ERPNext gives you POS, items, customers and accounting, but out of the box it has no concept of a physical table, a reservation held for 7:30pm, a party waiting at the door, or the turn-time that decides whether you seat two covers or four on a Friday night. Hosts end up managing all of that in a paper book or a disconnected SaaS tool, so walk-ins, no-shows and covers never reconcile against the sales and customer data already sitting in ERPNext. That gap is exactly where the native platform runs out of road.

We build a proper Frappe app — table_reservation — that installs cleanly onto your existing ERPNext v15 or v16 site and adds first-class DocTypes for the restaurant floor: Restaurant Table (capacity, min/max covers, zone, merge-able flag, status), Floor Plan (a JSON layout consumed by a drag-and-drop editor built as a Frappe Page + client script), Table Reservation (party size, requested time, deposit, source, linked Customer), and Waitlist Entry. Reservation state transitions (Requested → Confirmed → Seated → Completed / No-Show / Cancelled) are driven by hooks.py doc events (validate, on_update, on_submit) and server-side Python so double-bookings and capacity overflows are rejected at the source, not just hidden in the UI. A client script renders the live floor: drag a table to move it, tap it to seat a party, and colour reflects real-time status pulled over the Frappe REST API.

Online reservations come in through a whitelisted method (@frappe.whitelist(allow_guest=True)) that backs a lightweight booking widget you embed on your website or Frappe Website page; it checks availability against confirmed reservations and turn-time rules before it will create a Table Reservation, and can require a deposit or prepayment that posts against ERPNext accounting. Waitlist entries are SMS/WhatsApp-notification-ready via ERPNext's Notification framework and a queued background job, so a "your table is ready" message fires without blocking the host. A scheduler_events hook sweeps for expired holds and no-shows on an interval, and every table-turn and dwell-time metric is captured so a Query/Script Report can show you average turn time by zone, peak-hour utilisation and no-show rates. Role profiles and permissions are configured so hosts, managers and servers each see only what they should.

Because this is build-to-order, nothing is a black-box download. After a short scoping call we confirm your exact floor zones, turn-time rules, deposit policy and notification channels, then build against a staging copy of your site. You get the installable app source for your version, install and configuration on your environment, UAT on staging with a rollback plan, a training session for your hosts and managers, and a post-go-live support window. Typical delivery is one working week from confirmed scope. Everything is handed over as a git repository you own, tested on Frappe/ERPNext v15/v16, so you are never locked to us.

What you get

  • Installable Frappe app source code (`table_reservation`) built for your ERPNext v15/v16 version
  • Installation and configuration on your environment (floor zones, turn-time rules, deposit policy, notification channels)
  • UAT on a staging copy of your site with a documented rollback plan before any production change
  • Technical documentation: DocType schemas, doc-event hooks, whitelisted methods, scheduler events and permission model
  • User guide plus a live training session for hosts, servers and managers
  • Post-go-live support window for defect fixes and configuration adjustments
  • Full git repository handover so you own and can maintain the code
  • Notification templates (SMS/WhatsApp/email) wired to ERPNext's Notification framework

Who this is for

Full-service restaurant operator

Runs a reservation-heavy dining room and needs walk-ins, bookings and floor utilisation managed inside ERPNext instead of a paper book or a disconnected SaaS tool, so covers reconcile with sales and customer data.

Front-of-house / host manager

Needs a live visual floor to seat parties, run a waitlist with accurate quoted waits, and fire 'table ready' notifications without leaving the host stand or double-booking a slot.

Multi-outlet hospitality group

Operates several venues on one ERPNext instance and wants consistent floor plans, turn-time analytics and no-show tracking per zone and per outlet to benchmark utilisation across the group.

Restaurant IT / ERPNext administrator

Owns the ERPNext deployment and wants a proper custom Frappe app with clean DocTypes, hooks, permissions and a git repo they can maintain and upgrade to v16 — not a fragile customisation or a locked-in black box.

How Table & Reservation Management for ERPNext Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Fit to your floor & rulesBuilt to your exact zones, turn-times and deposit policyWhatever you spec, if you get it rightGeneric; bend your process to the appNo concept of tables or reservations
Delivery timeone working week from confirmed scopeMonths of in-house dev and iterationInstant install, then long configurationAvailable now but missing the capability
Online booking widgetGuest whitelisted method + embeddable widget with depositsMust design and secure it yourselfOften present but not deposit-awareNone
Turn-time & no-show analyticsDwell-time capture + reports by zone and peak hourOnly if you build the reportingBasic or add-on tierNot tracked
ERPNext integrationNative DocTypes, hooks, links to Customer & accountingDepends on your team's Frappe depthVaries; may sit loosely on topN/A
Code ownershipFull git repo handover, you own itYou own it, and all its bugsLicensed; you rarely get the sourceCore code, not yours to change
v15/v16 support & upgradesBuilt and tested for your version, upgrade retainers availableYou maintain compatibility yourselfDepends on vendor's release cadenceFollows ERPNext releases
Support after go-liveIncluded support window + optional retainerYour team is the supportTiered support ticketsCommunity / your ERPNext partner

Frequently Asked Questions about Table & Reservation Management

How long does delivery take?

This is a build-to-order app, not an instant download. Typical delivery is one working week from confirmed scope. After the initial scoping call we agree the exact floor zones, turn-time rules, deposit policy and notification channels, then build, UAT on staging and go live within that window. Complex multi-outlet setups may extend it, which we flag before you commit.

Is this a ready-made Frappe Cloud Marketplace app I can just install?

No. ECOSIRE designs, builds, installs and supports it specifically for your ERPNext site. You receive the installable source and a git repository you own, built and tested for your version (v15 or v16), rather than a generic marketplace listing you configure yourself.

Which ERPNext versions are supported?

The app is built and tested against Frappe/ERPNext v15 and v16. We confirm your exact version during scoping and build against a staging copy of your site so the app matches your environment and upgrade path.

How do the SMS and WhatsApp notifications work?

Notifications are wired through ERPNext's native Notification framework and dispatched via a queued background job so the host UI never blocks. The app is SMS/WhatsApp-ready; you provide (or we help you connect) a gateway such as an SMS provider or WhatsApp Business API, and we configure the templates for confirmations, reminders and 'table ready' alerts.

Can guests book online from our website?

Yes. A lightweight booking widget backed by a guest-accessible whitelisted method (`@frappe.whitelist(allow_guest=True)`) embeds on your website or Frappe Website page. It checks live availability against confirmed reservations and turn-time rules, and can require a deposit or prepayment before creating the reservation.

What support and updates do we get after go-live?

Every engagement includes a post-go-live support window for defect fixes and configuration adjustments. Because you receive the full git repository, your own team can maintain it, and ECOSIRE offers ongoing support and version-upgrade retainers (for example when you move from v15 to v16) as a separate arrangement.

Will it interfere with our existing ERPNext POS and accounting?

No. It installs as a separate custom app with its own DocTypes and links cleanly to existing `Customer` records; deposits post against ERPNext accounting. We test the full install on a staging copy with a rollback plan before touching production, so your POS, items and ledgers are unaffected.

Request a quote

Table & Reservation Management

A build-to-order Frappe app that turns ERPNext into a full-service reservation and floor-management system with a drag-and-drop floor plan, online bookings, waitlists and turn-time analytics. ECOSIRE scopes, builds, installs and supports it for you.

  • Drag-and-drop visual floor plan editor built as a Frappe Page + client script, persisting layout as JSON on a `Floor Plan` DocType
  • Dedicated `Restaurant Table` DocType with capacity, min/max covers, zone, merge-able flag and live status
  • `Table Reservation` DocType with a server-enforced state machine (Requested/Confirmed/Seated/Completed/No-Show/Cancelled) via `hooks.py` doc events
  • Guest-accessible online booking widget backed by a `@frappe.whitelist(allow_guest=True)` availability-and-create method

Request a Quotation

Tell us about your Table & Reservation Management 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.