All work with Baemingo

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
Working prototypeTry it yourselfSet up self-ordering as the restaurant would: pages, highlights, labels, upsell and branding, in the app, on the web and at the kiosk. Then order as a guest.

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.

01

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.

02

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.

03

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.

04

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.

Working prototypeTry it yourselfSet up self-ordering as the restaurant would: pages, highlights, labels, upsell and branding, in the app, on the web and at the kiosk. Then order as a guest.

1 · One preview, one inspector

The builder: the menu in a phone preview with the rows Erbjudande and Nyhet at the top, and the inspector with Needs attention, Pages and Sections and products
The menu appears as guests see it. The inspector brings together what needs attention, the pages and the ability to arrange sections and products.

2 · The start page

Pages, Start page: a phone with the start page in the Full image design, and the inspector with three designs to pick from and a library of start images
Restaurants choose from three layouts: Full image, Image and card or Menu first, with options to upload images or choose from a small library.

3 · Highlights at the top of the menu

Pages, Top of the menu: the highlighted rows outlined in the preview, and the inspector with a switch and the highlights Erbjudande, Nyhet and Populär to show, hide and reorder
Products can appear in featured rows such as Offer, New and Popular. Owners decide which rows are shown and in what order.

4 · Products, labels and availability

A product open in the preview with the highlight Nyhet on the picture and Vegansk and Glutenfri under the name, and the inspector with image, highlight, food facts and availability
Promotional highlights sit alongside food information such as Vegan and Gluten-free, with the option to mark a product Sold out today.

5 · Upsell before checkout

Pages, After adding: a sheet in the phone saying Salmon poké is in the cart, with Passar bra med and three suggestions to add or Hoppa över, and the upsell rules in the inspector
After a guest adds something to their basket, relevant additions can be suggested. Simple rules keep the suggestions limited to products currently available to order.

6 · Preview a channel not yet purchased

The web channel with a banner saying Online ordering isn’t in your plan yet, the menu shown as guests would see it on the restaurant’s website, and Upgrade plan
Even a channel outside the subscription shows how the restaurant’s menu would appear, alongside an option to upgrade.

7 · The kiosk

The self-service kiosk in portrait with the highlighted rows, sections in a side menu and products in a grid with labels on the pictures
The shared setup adapts to a larger portrait screen, with bigger product images, a grid and clear section navigation.

8 · Labels

The Labels tab: highlights in priority order and food facts, each with an icon, a name and the number of products, and a phone preview
Highlights and food information are managed centrally. Priority determines which highlight appears when several are associated with a product.

9 · Branding

Branding: the start page in a phone, and the inspector with logo, name, welcome line, brand colours, label icons, typeface and corners, and language
Restaurants can adapt their logo, colours, typography, corners and label icons using predefined choices or their own identity.

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.

05

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.

06

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.