Redesigning Wantsushi’s ordering experience across web and mobile

From a template to a product

The project began as a redesign of Wantsushi.ru’s template-based legacy website. Before changing the interface, I audited the existing experience using Yandex Metrika, Lighthouse, UX heuristics, support requests, and feedback from restaurant operators.

I looked at where customers left the ordering journey, which problems repeatedly reached support, how well the website performed, and where the template failed to support the restaurant’s actual product.

The audit showed that a visual refresh would not be enough. The project became a broader rebuild of the ordering experience across responsive web and mobile apps.

My role

I worked as a Contract Product Designer & Engineer from November 2020 through November 2022. I collaborated directly with the owners, restaurant back-office staff, and a marketing specialist.

I owned:

• UX scenarios and information architecture;
• visual and responsive interface design;
• the responsive React website;
• the Flutter apps for iOS and Android;
• frontend and backend development;
• infrastructure in Yandex Cloud;
• integration with the restaurant’s iiko system.

The scope was unusually broad, but product design remained the starting point. Implementation ownership allowed me to carry decisions into production, resolve gaps between proposed and working behavior, and account for technical constraints while designing the experience.

Auditing the complete ordering journey

The existing product could not be evaluated as a collection of isolated pages. Customers moved through one connected journey: discovering dishes, configuring an order, reviewing the cart, entering delivery information, applying rewards, placing the order, and following its status.

I combined several kinds of evidence:

• Yandex Metrika showed where customers left the journey;
• Lighthouse exposed performance and technical problems;
• UX heuristics identified unclear hierarchy, feedback, and interaction patterns;
• support requests revealed recurring customer problems;
• restaurant operators explained how orders were handled after checkout.

This gave the redesign a practical foundation based on the existing product, observed behavior, and restaurant operations.

Rebuilding the ordering experience

I redesigned the core journey from menu discovery to a completed order. The work covered menu navigation, product cards, item selection, the cart, delivery information, promotions and rewards, checkout, and order status.

Returning customers could save delivery information, review previous orders, use cashback, apply promo codes, and select available gifts. Order updates and push notifications kept customers informed after checkout.

These features had to work as one journey rather than a checklist of separate screens. The cart needed to explain the current order clearly, while delivery conditions, discounts, rewards, and available gifts could all affect what happened next.

I designed the cart, product cards, delivery information, and other commerce-specific patterns around this flow instead of relying on generic template components.

One product without forcing identical interfaces

The web version was a separate responsive React application rather than a wrapper around the Flutter app. This allowed the website to use larger screens appropriately while the mobile apps followed familiar mobile interaction patterns.

The platforms shared the same product structure, terminology, order logic, and visual identity, but their layouts did not need to be pixel-identical.

In the Flutter apps, I used Material Design primitives for common controls and expected platform behavior. The product-specific layer was designed separately: menu cards, the cart, delivery information, rewards, order status, and other patterns particular to Wantsushi.

This reduced unnecessary custom work without making the product feel like an unmodified Material template.

Connecting customer experience to restaurant operations

A successful checkout was only one part of the system. The resulting order also had to enter the restaurant’s existing workflow through iiko.

Customer choices, delivery information, rewards, and order states needed to remain understandable in the interface while producing data the restaurant could process. Working across product design, backend development, and the integration itself helped me account for these requirements before they became implementation problems.

I also managed the supporting infrastructure in Yandex Cloud. This gave me visibility into how interface decisions affected application state, external services, error handling, and the reliability of the complete ordering flow.

The implementation is included here because it shaped the product—not as a separate inventory of technologies.

Carrying the design into production

Owning design and implementation meant there was no separate handoff at which product decisions became someone else’s responsibility. I worked through responsive behavior, loading and error states, platform differences, integration constraints, and inconsistencies that only became visible in a functioning product.

Everything described in this case reached production:

• a custom responsive React ordering website;
• Flutter apps for iOS and Android;
• an end-to-end ordering journey;
• cashback, gifts, promo codes, and returning-customer features;
• order-status updates and notifications;
• integration with iiko;
• supporting backend and cloud infrastructure.

Outcomes

The project replaced a generic legacy website with a custom ordering product spanning responsive web, iOS, and Android.

In the post-launch analysis I conducted at the time, cart abandonment was approximately 60% lower than in the previous experience.

The project also delivered:

• one consistent ordering model across three customer-facing platforms;
• a web experience designed specifically for responsive use;
• production mobile apps based on shared product logic;
• an ordering flow connected to the restaurant’s existing iiko operations;
• reusable patterns for the menu, cart, delivery information, rewards, and order status.

What I learned

Wantsushi changed how I think about the boundary between product design and engineering. Implementation knowledge is useful when it improves product decisions: identifying edge cases earlier, designing realistic states, understanding operational constraints, and choosing patterns that remain consistent after release.

The lesson was not that one person should own every discipline. The value came from being able to connect customer needs, interface decisions, restaurant operations, and implementation in one shipped product.

That experience now helps me work more effectively with engineering teams. I understand where responsive rules, application state, APIs, and third-party integrations affect design—and where product intent can be lost if those details are left unresolved.