Android-powered self-service kiosk for a fast food restaurant in Belgium
Damien Toulouse, the owner of a Vietnamese restaurant in Brussels called Can Tho, wanted to create a restaurant with an innovative user experience to attract customers and grow brand loyalty, taking a waiter- and cash-free approach. Damien contacted us with an idea to build an application for the kiosks that would automate business processes at their restaurant. These kiosks would offer self-service ordering and a point-of-sale system.
We developed an application for self-ordering kiosks to help Can Tho serve customers faster and the restaurant's staff use their time more efficiently. Each Can Tho kiosk consists of a table, payment terminal, and wireless printer so customers can browse the menu, order, customize dishes, pay for an order, and get a receipt in one place.
Expertise brought to CanTho
Our client came with a user interface design, and our task was to come up with a dynamic and engaging user experience. We spent some time discussing core features and the flow in order to develop a prototype. This prototype served as the starting point for our design.
We developed CanTho using Clean Architecture principles, which allowed us to separate business logic and price calculations into independent modules. By doing so, we simultaneously increased maintainability and reliability.
With CanTho, one of the main challenges was to implement a payment terminal and provide a smooth payment flow for customers. Since we needed a modern solution to satisfy even the pickiest customers, we went with the Valina terminal, which lets users pay both by card and with contactless methods.
We also implemented logic for price calculations that handles value-added tax (VAT).
As a result, we developed stable software that automates all work that’s otherwise done by waiters.
We had the non-trivial task of implementing the backend for this Belgian waiter-free restaurant. The backend needed to let customers create their own dishes from suggested ingredients and add-ons. We chose the Django framework for the service base with a PostgreSQL database and the Django REST framework to let the backend communicate with the kiosks.
We needed to make sure we kept all information about transactions and value-added taxes as required by Belgian law. So we decided to integrate a point of sale (POS) system since developing and licensing similar functionality on our own would have taken a lot of time. Lightspeed had an API and the certifications required for use in Belgium.
Integrating Lightspeed led to a simple and clear order flow. Through the Lightspeed admin dashboard, restaurant staff can fill in information such as the price of dishes and all ingredients along with the VAT percentage. This information is synchronized with the CanTho database with the help of a web API, representing the server-to-server communication. To mitigate all possible discrepancies on the backend, all financial information is in a read-only format. After a user places their order, the backend transmits the data to the Lightspeed server, which checks the accuracy of calculations and keeps the tax information.
The backend for the CanTho app has extensive capabilities for editing menus. Seeing as CanTho’s key feature is creating custom dishes, we developed a multi-layer system for customizing orders as well as ingredients and add-ons. Everything can be set up via the admin dashboard.
We built a Django admin site adding the Django JET plugin to make the admin interface more beautiful and navigation more efficient. Also, we made the app available in English, French, and Dutch.
We developed a backend application that synchronizes with the Lightspeed POS, provides an API for the kiosks, and allows staff to fine-tune the CanTho ecosystem that includes the menu, Lightspeed integration, smart light bulbs, kiosks, and printers via the admin dashboard.
When integrating the Lightspeed POS, we needed to implement server-to-server communication through a web API. We developed the Lightspeed API client library using Requests.
We chose to divide the business logic for deserialization and synchronization using Marshmallow schema classes for deserialization. We used Marshmallow schemas instead of DRF serializers due to their simplicity, dynamic fields, and the absence of direct interaction with models, which was exactly what we needed.
Synchronization is done by synchronizer classes with the help of our client library and Marshmallow classes to serialize or deserialize data. This data is saved in the case of incoming synchronization or sent to Lightspeed in the case of outgoing synchronization.
Taking into account that menu information changes rarely, instead of periodically syncing with Celery beat tasks, we implemented on-demand synchronization by adding a synchronize button in the admin dashboard. What’s more, the admin can see the synchronization status and the number of items created and deleted during the last sync.