A busy restaurant does not work through one task at a time. An order affects the kitchen, the table, the payment, the stock and eventually the figures a manager relies on at the end of the day. Yet those activities are often handled by separate tools or disconnected parts of the same system. I wanted RestMan to be one connected product rather than a better-looking point-of-sale terminal. It needed to serve people with different responsibilities: a waiter working under pressure, a chef managing preparation, a manager reviewing operations and an owner overseeing multiple branches. The challenge was to make each experience straightforward without losing consistency behind the scenes. As the product grew into a multi-tenant SaaS platform, every added capability risked making the day-to-day work harder. I had to decide where the complexity belonged, and where it needed to disappear from view.

I started with the working day, not a list of features. I traced an order from creation through kitchen preparation, service, payment and completion, then looked at what each step meant for tables, stock, permissions and reporting. One question kept changing the design: what does the next person need to know to act confidently? For a waiter that meant an unmistakable order state. For the kitchen it meant clear tickets and hand-off signals. For managers it meant the right operational detail without crowding the service interface. That work led to separate, purpose-built experiences for POS and floor staff, the Kitchen Display System, restaurant administration, customer ordering and SaaS management. They share the same product model but do not share one generic interface. I owned the product concept, feature planning, UX, UI and development direction. AI-assisted coding tools generated the implementation under my direction. I reviewed behaviour, identified faults, directed corrections and worked through QA with collaborators. The aim was not to make each screen appear complete, but to make connected operations behave consistently. RestMan uses Go and Gin, Next.js and TypeScript, PostgreSQL, Redis and WebSockets. The stack supported the implementation; the design decisions came from the operational problems we needed to solve.

Key Decisions
Design for the person doing the work
A waiter needs quick, touch-friendly actions and a reliable picture of an order. A chef needs high-contrast tickets, preparation progress and a clear hand-off. Managers need denser views for stock, finance and staffing, while customers need a simpler mobile experience.
I could have given everyone the same interface with different menus. Instead, I designed purpose-built environments around the decisions each person makes during a shift. The POS, KDS, Admin and customer journeys share a product system without forcing everyone into the same workflow.

Different working environments: staff service and kitchen preparation.
Treat payment and completion as separate events
Recording a payment is not the same as completing service. A customer can settle a bill while still occupying the table. Automatically freeing it would make the software simpler to build but less dependable during service.
I kept payment, order completion and table release as distinct states, rather than folding them into a single Done action. This let the interface represent what had actually happened and what was still waiting. The distinction became part of the connected workflow tested during the internal rehearsal.

Floor and table states remain part of the operational journey beyond payment.
Make downstream consequences understandable
Finishing an order affects more than the POS. In the tested core workflow, recipe-linked sales trigger ingredient stock deduction; payments contribute to reconciliation and operational activity feeds reporting.
The design challenge was to keep those consequences visible where a manager needs them without asking floor staff to understand the underlying data model. I prioritised trustworthy states, clear confirmations and focused management views over exposing every system relationship on every screen.


Stock management and operational reporting provide visibility beyond the order screen.
Make permissions part of the experience
Different restaurants give the same job title different responsibilities. A manager in a single-site café may need access that a manager in a restaurant group does not. Role labels alone could not be the security model.
The product therefore needed configurable permissions and appropriate navigation for each user. Hiding an unavailable action can reduce confusion, but it is not authorisation. Access to operational data and actions must be enforced by the backend, including across tenant boundaries.

Staff roles and management context; backend permission enforcement is not visible in this screenshot.
RestMan progressed from an initial concept to a functioning release candidate across the restaurant floor, kitchen, administration and customer experiences. The core operational journey was tested in a controlled rehearsal with internal team members and collaborators. It covered creating an order, progressing it through the Kitchen Display System, recording payment, explicitly completing the order, releasing the table and deducting recipe-linked ingredients from inventory. These checks support the connected workflow in a controlled environment, not its performance during a live restaurant shift. The wider platform includes menu management, purchasing, reporting, staff operations, customer management and SaaS administration. Not every module or integration has reached the same level of validation. Live restaurant use, external payment-provider certification and physical hardware checks remain separate steps. There are no claimed adoption figures or operational efficiency gains here. Those will require measured use in real restaurants. The achievement at this stage is a connected, testable product foundation with working core flows and a clear basis for further validation.


I would have validated the core restaurant workflow in a real shift earlier, before expanding so much of the SaaS management layer. Multi-tenant administration was a sensible long-term requirement, but building surrounding capabilities first added dependencies and kept pushing live observation further away. If I were starting again, I would draw a firmer line around one restaurant, one shift and the order-to-completion journey. Watching staff use that experience under real service pressure would give the next phase better evidence than even a careful internal rehearsal. The lesson was about sequencing: build the connected foundation, but let real operational use determine what grows next.
