Originally published at muhammadmoiz.dev.

A kitchen display system for a restaurant is a set of screens in the kitchen that show orders in place of paper tickets. When a server or cashier rings up an order on the POS, the KDS sends each item to the screen of the station that cooks it. The cooks mark items as done, and the front of house sees the update straight away. I built one as part of Oscar, an offline-first restaurant POS, so this guide covers how a KDS works and what decides whether it helps or gets in the way.

What is a kitchen display system?

Without a KDS, a ticket prints in the kitchen, someone reads it out, and it gets pinned to a rail. A KDS replaces that rail with a screen. Each order shows up as a card with its items, modifiers ("no onions", "extra spicy"), table number or order type, and a timer showing how long it has been waiting.

A typical setup has three parts:

  • The POS, where the order is created. Orders can also arrive from online ordering, kiosks, QR menus or delivery apps, as long as they feed into the same system.
  • Prep station screens, one per station (grill, fryer, cold side, bar), showing only the items that station makes.
  • An expediter screen (often called "expo"), showing the whole order so one person can check it is complete before it goes out.

Staff move orders along by tapping the screen or pressing a "bump bar", which is a small physical keypad that survives grease and wet hands better than a touchscreen.

How does a KDS work with a restaurant POS?

The KDS is only as useful as its link to the POS. Here is the life of a single order:

  1. Order entry. A cashier rings up two burgers, fries and a lemonade for table 7.
  2. Routing. Each menu item has one or more prep stations assigned. The burgers go to the grill screen, the fries to the fryer, the lemonade to the bar.
  3. Display. Each station sees only its own items, while expo sees the full order with a status for each line.
  4. Bumping. When the grill finishes, the cook bumps the burgers. Expo sees them turn ready.
  5. Completion. Once every line is ready, expo bumps the order. The POS marks it ready, and in some setups a pickup screen or text message tells the customer.
  6. Reporting. Timestamps from each step feed reports on ticket times and slow stations.

Routing is the step most people underestimate. In Toast's documentation, for example, prep stations are assigned at the menu or menu group level and inherited by the items inside, with overrides per item. Each station can send to its own screen and expo, to expo only, or to the station only (a bar outside the kitchen is the usual example). That kind of setting decides whether your expo screen is useful or flooded.

A team of chefs working side by side at prep stations in a restaurant kitchen

Photo: JC Gellidon on Unsplash

What a KDS order looks like as data

If you are building a KDS rather than buying one, the data model matters more than the screens. Here is a simplified version of how I'd model it, written for this post:

type Station = "grill" | "fryer" | "cold" | "bar"; type LineStatus = "queued" | "cooking" | "ready" | "voided"; interface OrderLine { id: string; itemName: string; modifiers: string[]; stations: Station[]; // copied from the menu item at order time status: LineStatus; bumpedAt?: number; } interface KitchenOrder { id: string; type: "dine-in" | "takeaway" | "delivery"; table?: string; createdAt: number; lines: OrderLine[]; } // What a single station screen should show function linesForStation(order: KitchenOrder, station: Station) { return order.lines.filter( (line) => line.stations.includes(station) && line.status !== "voided" ); } // Expo can bump the order only when every live line is ready function isOrderReady(order: KitchenOrder) { return order.lines .filter((line) => line.status !== "voided") .every((line) => line.status === "ready"); } 

Two details in there save real pain. Station assignments are copied onto the line when the order is placed, so changing the menu mid-shift doesn't reroute orders already in the kitchen. And voided lines stay in the data with a status instead of being deleted, so the cook who already started on an item can see it was cancelled.

How I built the KDS in Oscar

Oscar is an offline-first POS for restaurants and retail. The kitchen display was one part of it, and the goal was to get rid of paper tickets and the constant walking between the floor and the kitchen.

The flow works like this. A cashier punches an order (dine-in, takeaway or delivery), and it appears on the kitchen screen immediately, pushed over WebSockets. Kitchen staff update the preparation status on their screen, and front-of-house staff see the change right away, so nobody has to walk back to ask whether table 4's food is ready.

Printing still has a place. Oscar uses QZ Tray to talk to printers: receipts print at the counter, kitchen tickets go to the kitchen and drink orders go to the bar. Many restaurants want screens and paper side by side, at least at first.

The data sits in a local browser database (WatermelonDB), so the POS keeps taking orders without internet and syncs to the Django backend when the connection comes back. I wrote more about that approach in Offline-First POS: Lessons From Building Oscar in React, and the full project is in the Oscar POS case study.

KDS vs printed tickets: which is better?

Neither wins for every kitchen. Here is how they compare in practice:

Printed tickets Kitchen display system
Setup Thermal printer per station Screen per station, plus mounts and network
Order changes Reprint or shout across the kitchen Card updates on screen, voids are visible
Routing to stations One ticket per printer Per item, with expo seeing the whole order
Timing data None Ticket times per order and per station
Internet or network outage Keeps printing if the POS can reach the printer Depends on how the system handles offline mode
Running costs Paper and printer upkeep Usually a monthly fee per screen plus hardware
Best fit Small menus, low volume Multiple stations, high volume, lots of modifiers

Merchant Maverick notes that most KDS products charge a monthly software fee per screen on top of the hardware, and that a KDS may not pay off for kitchens with little space or low order volume. That matches what you would expect: a two-person kitchen doing 40 covers a night gets less from routing and reports than a busy kitchen with five stations.

What happens when the internet goes down?

This is the question restaurant owners should ask every vendor, because a dead kitchen screen on a Friday night costs real money.

Cloud-based systems handle it in different ways. Toast's documentation is a good example of how layered it gets. With a local hub device on the same network, orders placed in the restaurant still reach the kitchen screens during an internet or cloud outage. Online orders, though, are not received until the connection returns, and some actions (such as course tickets fired from the expo screen) don't print in that mode. Without an eligible hub, the devices fall back to a more limited offline mode, where tickets can go to a backup printer if the restaurant has set that up.

The lesson is general, not specific to one vendor: "works offline" can mean very different things. When you evaluate a KDS, ask:

  • Do in-house orders still reach the kitchen screens without internet?
  • What happens to online and delivery orders during the outage, and are they delayed or lost?
  • Is there an automatic fallback to printed tickets?
  • When the connection comes back, how are conflicts resolved (for example, an item voided on the POS while the kitchen marked it ready)?

This is exactly why I built Oscar offline-first: the local database is the working copy, and the server catches up later, instead of the other way round.

Checklist: choosing or building a KDS

Test with a real rush: Before you commit, run a busy service with the KDS and your old tickets side by side. Problems with routing, screen placement and bump habits show up in the first hour of a real rush, not in a demo.

Whether you buy a KDS or have one built, check these:

  1. Same system as your POS. In my experience, the tighter the KDS is tied to the order data, the fewer orders go missing between counter and kitchen.
  2. Routing per item and modifier, with an expo view of the whole order.
  3. Clear handling of voids and edits after an order has been sent to the kitchen.
  4. Offline behaviour you have tested, not just read about.
  5. Hardware that survives a kitchen: heat, grease and wet hands. Bump bars help.
  6. All order channels in one queue: dine-in, takeaway, delivery and online.
  7. Timing reports you will actually read, such as average ticket time by station and hour.
  8. A printing fallback for when a screen or network fails.

What this means for restaurant owners and POS startups

If you run a restaurant, a KDS is worth it when your kitchen has several stations, a lot of modifiers or a high share of online orders. The value comes from routing and visibility, not from the screens themselves. Start with the POS you already use, and choose a KDS that is part of the same system.

If you are building a POS product, the KDS is where your architecture gets tested. You need real-time updates from the counter to the kitchen, sensible routing rules, careful handling of edits and voids, and a plan for when the network drops. These are hard to add later, so design the data model for them from day one. If you need help planning or building that, take a look at my product development service.

Sources

I'm Muhammad Moiz, a full-stack developer who builds web apps, SaaS and POS systems, and takes AI-built apps (Lovable, Bolt, Replit) to production. Get in touch.