Why a bot assistant is more than just a chat?
We develop conversational interfaces for mobile apps that automate order intake. This is not a chat with an operator: every action — create, modify, cancel — is atomic and rollbackable. The user can change their mind at any step, and the bot retains context.
In our practice, we have completed over 50 projects integrating bots with OMS. For example, for a coffee chain we built a bot that handles 300+ orders per day. Average checkout time is 30 seconds — twice as fast as linear scripts. Such solutions reduce support load by 40% and offer significant cost savings over time. Contact us to assess the potential for your case.
How state machine prevents data loss?
Completing an order via bot is a multi-step form stretched over time. Between replies, the user might close the app, switch to another, and return after 10 minutes. The state must be preserved. We use a state machine on Redis: each step is a finite automaton with explicit transitions. Wikipedia - Finite-state machine
The slot structure for an order dialogue:
{ "session_id": "uuid", "step": "confirm_address", "order_draft": { "items": [ {"sku": "ITEM-123", "qty": 2, "price": 1500} ], "delivery_address": null, "payment_method": "card", "promo_code": null }, "expires_at": "2025-01-15T14:30:00Z" } State is stored on the server (Redis with TTL 30–60 minutes). The mobile app sends only session_id with each message.
A critical point: every dialogue step must support 'back' and 'cancel' commands. If the user writes 'change item' at the address confirmation step, the bot should return to the item selection step without wiping already entered data.
State machines yield 2–3x fewer bugs than custom dialogue handlers — proven across dozens of projects. A state-machine bot processes orders twice as fast as conventional scripts.
How we integrate the bot with the order backend?
The bot should not contain business logic. It calls API methods:
-
POST /orders/draft— create a draft -
PUT /orders/draft/{id}/items— modify items -
POST /orders/draft/{id}/submit— finalize -
DELETE /orders/{id}— cancel
A typical issue: the bot lets the user add an out-of-stock item, which is only discovered at final submit. That's poor UX. Stock checks must happen when adding an item to the draft.
If an LLM is used for message processing, function calling makes the integration cleaner: the model invokes add_to_cart, remove_from_cart, apply_promo_code as tools, rather than trying to parse intent via regex. This halves recognition errors and reduces cart abandonment by 25%.
UI on the mobile client
Beyond text chat, the bot often uses structured elements:
Quick reply buttons — after 'Payment method?' we show options as tappable chips, so the user doesn't have to type.
Product cards — when confirming the order contents, we display mini-cards with image, name, price. On Android this is a RecyclerView with horizontal scroll inside a bubble message; on iOS — UICollectionView with horizontalScrollDirection.
Order summary — a final screen before confirmation as a separate component, not plain text. The user sees the full list, total, address, and a 'Place order' button. This UI boosts conversion by 15%.
| Component | iOS (SwiftUI) | Android (Jetpack Compose) |
|---|---|---|
| Quick reply | HStack with chips | Row with Surface |
| Product card | LazyHStack with AsyncImage | LazyRow with AsyncImage |
| Order summary | List with Section | Column with Card |
Status notifications
After the order is placed, the bot continues working via push notifications: 'Order received', 'Courier on the way', 'Delivered'. On iOS — APNs via Firebase Cloud Messaging, on Android — FCM directly.
Notifications include a deep_link with parameters that open the chat history for that specific order, not the main app screen.
Process
- Scenario design: regular order, modification, cancellation, reorder, promo code.
- Server state machine development + integration with order API.
- Mobile UI: bubble layout, quick replies, product cards, summary.
- Testing edge cases: mid-process interruption, conflicting commands, expired sessions.
Technical details of the state machine: on the server it's implemented in Python using the transitions library. States and transitions are defined in a YAML config, allowing scenario changes without rebuilding. Each state has a TTL timeout — if the user is idle for 30 minutes, the session ends.
What is included in the deliverable
- Server and mobile client source code
- API and scenario documentation
- Push notification and deep linking setup
- Real-device testing (iOS/Android)
- Deployment guide for App Store and Google Play
- 6-month warranty on bugs
On iOS we use StoreKit 2 for in-app purchases and TestFlight for beta testing. The state-machine order bot is suitable for complex scenarios.
| Stage | Duration |
|---|---|
| Scenario design | 1–2 days |
| State machine development | 2–4 days |
| OMS integration | 2–3 days |
| Mobile UI | 3–5 days |
| Testing and debugging | 2–3 days |
Timeline estimates
A bot with a linear scenario (selection → address → payment → confirmation) + mobile client: 1–1.5 weeks. With non-linear scenarios, loyalty system integration, order history, and push notifications: 3–4 weeks.
Our team has been in mobile development for over 10 years. Order an audit — we'll propose the optimal solution. Request a consultation — we'll explain how a bot fits your business.