Context
Waco is our own product, not a client engagement. Evolvier runs three first-party platforms — Peyze, Waco, and GenIm — because operating production systems we own keeps our engineering honest. Every architecture decision in this case study is one we live with, on-call rotations included.
Waco is the WhatsApp commerce engine of the three. It maps a merchant's live inventory onto the official WhatsApp Business API so that discovery, cart building, and checkout happen inside the chat thread, then pushes receipts, tracking codes, and delivery updates back into the same thread automatically.
The product exists because of how commerce actually behaves in our core markets. In the UAE and wider GCC, India, and much of Africa, buying conversations start on WhatsApp. The standard playbook then pushes the buyer out — a link, a new browser session on a mobile connection, a login wall, a checkout form. Every hop sheds intent, and a conversation that started warm ends as an abandoned cart.
The challenge
The hard version of this problem is not "send product messages on WhatsApp." Broadcast tools do that. The hard version is keeping a conversational channel truthful and transactional at the same time:
- Truthful. Chat must quote the same prices, stock, and regional availability as the store backend — continuously, not via nightly exports that go stale by morning.
- Transactional. Payment must complete in-thread without card data ever entering the conversation layer, using the wallets each market actually runs on.
- Closed-loop. After payment, the thread has to remain the customer's order record — receipt, tracking, delivery — without an agent copying anything between portals.
All of it had to sit on the official WhatsApp Business API. Unofficial automation that puppets consumer accounts violates WhatsApp's terms and gets numbers banned, taking the sales channel and its history down with it. Building inside the official API's constraints — message templates, session windows, structured message types — was a hard requirement, not a preference.
Architecture & decisions
A decoupled conversation layer
The first decision was the most important one: Waco is a conversation engine, not a commerce backend. It does not own product data, orders, or payments — it orchestrates them. The engine sits as middleware between the WhatsApp Business API on one side and the merchant's stock and order systems on the other, communicating over documented REST contracts. That decoupling means a merchant can swap their backend and Waco changes one adapter. It also bounds the blast radius: a conversation-layer failure degrades to "chat goes quiet," never to "orders are corrupted."
Live inventory sync without a second catalog
A static catalog export is wrong within a day — that is how chat channels end up quoting prices the store no longer charges. Waco instead holds a live connection to the merchant's stock system, so pricing, availability, and regional rules resolve at message time. The sync layer is integration discipline applied without shortcuts: verified webhooks for change events, idempotent writes so retries cannot double-apply, backoff so a slow merchant API never cascades into the messaging path. An item that hits zero stock stops being offered; a price change propagates to the next message that mentions it. This is the same middleware engineering we sell as API integration and automation — Waco is where we pressure-test it on our own pager.
Per-merchant data isolation
Waco serves many merchants from one engine, so isolation is structural, not procedural. Each merchant's catalog connection, conversation state, and order references run under scoped credentials against scoped data — a flow in one merchant's thread cannot read another merchant's stock or customers. This mirrors the regional data isolation posture we apply across our platforms, documented on our security page.
Payments that never touch the thread
Asking a customer to type card details into a chat is a non-starter, and bouncing them to a generic payment page reintroduces exactly the drop-off Waco exists to remove. The pattern we shipped: when a cart is ready, Waco generates an encrypted, single-purpose checkout URL and posts it into the thread. The customer pays with Apple Pay or the regional wallets their market prefers — in the GCC, India, and Africa, payment friction is a wallet problem more than a card problem, and the gateway mix reflects that. Card data never enters the conversation layer; the sensitive exchange happens on hardened payment rails with tokenization and 3D Secure 2.0. The thread carries a link and a confirmation, nothing more.
Structured flows first, free text second
Discovery inside WhatsApp leans on the API's structured primitives — interactive lists, buttons, catalog cards — because deterministic UI converts better than guessing at intent. Where shoppers type free-form questions, the conversation layer maps them onto live catalog queries, work that draws on our AI development practice. It follows the same rule as everything else in Waco: the conversational layer can phrase the answer, but the backend is the only source of truth for price and stock.
Build highlights
- Logistics loops with no human in them. The receipt posts when payment settles, the tracking code posts when the logistics partner generates it, and delivery updates push as the parcel moves. "Where is my order" — the highest-volume message a chat seller receives — became an automated flow driven directly by fulfillment data.
- Session-window discipline. The official API constrains when a business may message a customer. Waco's scheduler treats those rules as a first-class constraint: approved templates outside the service window, session messages inside it, so automation never drifts into policy violations.
- One backend, many surfaces. Merchants pairing Waco with a native app — the kind our mobile app development team ships — run both channels against the same stock and order systems, so chat never sells what the app says is gone.
Results
Waco is built for merchants across the GCC, India, and Africa, and runs in production as an Evolvier-operated platform. The figures below are tokenized until the current numbers are confirmed for publication — we publish metrics we can stand behind, not approximations.
—Platform uptime (to be confirmed)
—Catalog-to-chat sync latency (to be confirmed)
—Order updates automated (to be confirmed)
The structural results are already visible in how the system behaves: pricing in chat cannot drift from the store, payment data cannot leak into the conversation layer, and order-status traffic that used to consume agent hours now resolves without one.
Build something similar
Almost nothing in Waco's architecture is WhatsApp-specific. A decoupled integration engine, live data sync with idempotent writes, single-purpose encrypted payment links, and automated fulfillment loops apply to any channel that has to transact against live business data. If you are building a conversational commerce channel — or any system where chat, payments, and logistics must stay synchronized — these patterns transfer directly, and we have already made the early mistakes at our own expense.