UX/UI Design · Baemingo · UX/UI design of a menu builder
From support-dependent setup to a menu builder restaurants can use themselves
Restaurants wanting to offer self-ordering relied on Baemingo’s support team to set up their menus and make changes. Products, menus and sales channels were connected in ways that were difficult to understand and manage.
I took responsibility for designing a menu builder that would let restaurants do this work themselves. I began by untangling how products, menus, availability and layout related to each other, then turned that logic into a visual interface with a live preview.
Through interviews with support staff and usability testing with restaurants, I developed the solution step by step. Restaurants would be able to build their ordering experience, see the result immediately and prepare the same underlying setup for app, web and self-service kiosk.
The outcome was development-ready UX/UI designs and a phased rollout plan, with the support team using the tool first and restaurants following later. I also built a working prototype in code afterwards to demonstrate and explore the experience.
- My role
- Product Designer, hands-on, alongside my role as Product Manager
- Year
- 2021–2022
- Industry
- Restaurant tech, B2B SaaS
- Company
- Baemingo
- Users
- Restaurant owners and staff, and Baemingo support
- Platform
- Web app, with live previews of the app, the web and the kiosk
The short version
The problem
Restaurants needed help from support to set up and change their self-ordering experience. Products, menus, availability and presentation were connected but served different purposes. The new setup needed to build on what restaurants already had and work across app, web and kiosk without entering the same information more than once.
My contribution
I led product discovery, interviewed the support team and designed the underlying logic, user journeys and interface. I tested the solution with support staff and restaurant customers, then refined it based on what we learned. The work resulted in development-ready UX/UI designs, a phased rollout plan and, later, a working prototype built in code.
The outcome
A visual menu builder where restaurants can arrange their self-ordering experience and see what guests will encounter. The same underlying setup can be previewed across app, web and kiosk, including channels the restaurant hasn’t purchased yet. The design was prepared for development, with a plan to let support use it first and offer it to restaurants if it worked better in support’s daily work.
When restaurants need support for their own settings
Baemingo offered self-ordering through an app, web ordering and self-service kiosks. But restaurants relied on support to set these channels up and change their settings afterwards.
This created a dependency even for tasks owners should be able to manage themselves: how menus appeared, which products were highlighted and how the restaurant’s own brand was presented to guests.
Self-service needed to build on what already existed
Restaurants already had products in their product catalogue and menus with prices, times and sales channels. They shouldn’t need to create another product list just to sell through an app or kiosk.
Instead, the challenge was to let restaurants arrange how their existing menu appeared and how guests moved through the ordering journey.
Three goals for the setup
Let restaurants do the work themselves. Support shouldn’t have to make every change.
Show the result immediately. Owners shouldn’t have to guess what their settings will look like to guests.
Prepare every sales channel. App, web and kiosk should share a foundation even if a restaurant doesn’t yet use all three.
As product designer, alongside my role as Product Manager, I took responsibility for investigating the problem and designing the new setup.
To make the setup simple, I first needed to work out which information belonged where.
Getting the logic right before designing the interface
I started with the support team – the people setting up self-ordering for restaurants every day. Interviews helped me understand which decisions they made, what information already existed and where mistakes were easy to make.
I separated the setup into four parts, each with a clear responsibility.
Product – what it is
A product has a name, image, description, options and add-ons. This information is created once in the product catalogue and shouldn’t need to be entered again in the menu builder.
Menu – what is sold
The menu determines which products are sold, how they’re grouped and what they cost. It can vary by venue, time and sales channel, such as a lunch menu available between 11 am and 2 pm.
Availability – what can be ordered right now
A product can be on the menu but temporarily sold out. Staff can mark it as Sold out today for a particular venue, with that status resetting the next day without changing the menu itself.
Layout – how food is presented
The layout determines how guests encounter the menu: start page, page order, images, labels, featured product rows, upsell suggestions and the restaurant’s branding.
But the layout doesn’t determine what’s sold. Products come from the menu, so the layout can’t add something the restaurant doesn’t actually offer.
Why this separation mattered
A product image belongs to the product. A lunch menu belongs to the menu and its time rules. Sold out today belongs to availability. Featuring a dish belongs to the layout.
Giving each part its own responsibility meant restaurants could change how food was presented without recreating products or introducing a mismatch between what’s shown and what’s available.
Often, one shared layout is enough, adapting content by venue, time and channel. Getting this logic right made the visual menu builder possible.
Turning support knowledge into tested design decisions
With the system logic in place, I designed the journeys and interface. I tested them with support staff and restaurant customers Baemingo worked closely with.
Five findings shaped the solution.
1. Seeing the menu made people want to change its content
The live preview helped owners notice missing products or things they wanted to adjust. I added a direct route from the preview to editing products and menus, including the option to add a missing product image where they were working.
2. Featuring products came up repeatedly
My initial flows didn’t include this. Testing showed that restaurants wanted to influence what guests noticed, so I added highlights: labels on product images and featured rows such as Offer, New and Popular.
3. Products first, then menus
Users wanted to create their products before arranging the menu and its presentation. This reinforced the decision to build on the existing product catalogue rather than another empty set of forms.
4. Drag and drop worked with larger menus
We tried sorting sections and products by dragging them into position. The interaction held up as menus grew, so I kept this direct, visual way of arranging content.
5. Colour choices needed guidance
Restaurant owners preferred recommended colour combinations to entering hex codes. I offered options based on the restaurant’s own brand colours.
The most important learning was how often seeing the final result made people want to edit the content behind it. Users wanted control without having to understand the system’s internal logic or become designers.
Building the menu while seeing the result
The central interaction has two areas. On the left is a live preview that owners can navigate as guests would. On the right is an inspector for anything needing attention, the pages in the guest journey, and the menu’s sections and products.
I drew inspiration from Figma’s combination of a visual canvas and a properties panel. Restaurants can drag and drop in the preview or inspector, and changes save automatically.
I later built a working prototype in code with a fictional restaurant. The images below show that prototype and can be enlarged.
1 · One preview, one inspector
2 · The start page
3 · Highlights at the top of the menu
4 · Products, labels and availability
5 · Upsell before checkout
6 · Preview a channel not yet purchased
7 · The kiosk
8 · Labels
9 · Branding
Try the complete setup
The working prototype lets visitors configure the start page, featured products, labels, upsell suggestions and branding. They can then switch between app, web and kiosk and try the ordering journey as a guest.
One setup for app, web and kiosk
A central design principle was that restaurants shouldn’t have to repeat the same work for each sales channel.
Shared foundation, adapted presentation
Products and menus determine what can be ordered at a venue, time and through a particular channel. The layout adapts how it’s shown. The app uses a narrower mobile flow, while the kiosk has room for larger images and more categories.
This keeps channels connected without making them look identical.
Prepare what hasn’t been activated
Restaurants can preview a channel before buying it and understand its value without having to subscribe first. The upgrade option appears alongside the preview.
Relevant choices rather than a blank canvas
Three start page layouts, recommended colour combinations and ready-made icons help owners create a good result without specialist design skills.
Confidence when making changes
Setup follows the order of the guest journey – start page, menu, after adding an item and before checkout. The preview makes changes visible, drag and drop provides direct control, and everything saves automatically. A choice can apply across all channels or just one.
Restaurants should be able to control their ordering experience without needing to understand everything behind the interface.
From development-ready design to a phased rollout plan
The work resulted in development-ready UX/UI designs, following discovery, interviews, system modelling, user journeys, interface design and testing with support staff and restaurant customers.
Start with the people already doing the task
The plan was for support to use the new tool first. They already set up self-ordering for customers every day, so they would quickly recognise what remained difficult.
Let the outcome determine the next step
The key question was whether the new setup actually became easier and more efficient for support. Only if it worked better for them would the tool be opened to restaurants for independent use. This was a phased rollout plan, not evidence that the whole rollout had happened.
Open questions
Staff ordering at the till uses the same products and menus, but needs a faster interface for staff. It remained outside this work.
Subcategories weren’t supported in the design and needed further exploration.
What I delivered
The original deliverable was development-ready design and a support-first rollout plan. I built the working prototype in code later to demonstrate and explore the complete setup.
The source material doesn’t report measured reductions in support work or how many restaurants later completed the setup independently.
What I took with me
This project taught me that self-service doesn’t begin by simply moving a task from support to the customer. First, you need to understand the work. Support knew where restaurants struggled and what often needed correcting.
I also took away how much simpler an interface can become when the underlying logic is clear. Once products, menus, availability and layout each had their own responsibility, restaurants could change the presentation without changing the menu itself.
For me, that’s the heart of the work: making a complex system understandable by first working out how it needs to function.
More of my responsibilities at Baemingo
At Baemingo, I had several responsibilities. Each one is its own case.
