Professional work
Janji Jiwa Multi-Brand Apps
One app suite for every Jiwa Group brand: customer ordering, outlet operations, and an offline-capable rider app for a network of 900+ outlets.
- Role
- Software Engineer - Backend and Distributed Systems
- Status
- Active
What this project shows
Context
Client work with Jiwa Group across customer, outlet, and rider-facing applications at Technopartner Indonesia.
My contribution
Part of the Technopartner Indonesia engineering team behind the Jiwa Group app suite and the backend services it runs on.
Why it matters
Production experience across multi-surface F&B commerce: ordering and payments, outlet operations, and offline-capable field sales.
Public evidence
Highlights
- One customer app covering every brand under Jiwa Group
- Rider app that sells offline and syncs when the connection returns
- Payments through Midtrans and OVO
- Outlet operations: stock, orders and sales reporting
- Publicly stated network of 900+ outlets and 1,500+ mobile carts
Multi-Surface F&B Commerce - Mobile Applications - Backend Services - Offline-First Field Sales
Overview
Jiwa Group runs several food and beverage brands, and the digital side of that business is not one app. It is a suite of surfaces that have to agree with each other:
- JIWA+, the multi-brand customer app for ordering, membership, and promotions;
- Janji Jiwa Outlet Apps, the outlet-facing app for stock, orders, and sales reporting;
- Kopi Sejuta Jiwa Rider App, the field app used by mobile coffee cart sellers to run a selling session, take payments and track commissions.
The publicly documented delivery lists a multi-brand system, integration with Midtrans and OVO for payments, personalization (favorites, re-order, item modifiers), a web-based admin panel for dynamic content, and fraud detection to protect customer data and transaction integrity (case study). The rider app adds an offline mode: transactions can be completed without connectivity and synchronise once the connection returns (case study).
As part of the Technopartner Indonesia engineering team (my current role, since September 2024), I worked on this product family. The write-up below describes the engineering problem it represents and the scope of my involvement at the level that can be shared publicly.
Three Surfaces, One Business
The three apps look unrelated from the outside. Operationally they are one system, because they touch the same orders, the same stock and the same money.
| Surface | Primary user | What it has to get right |
|---|---|---|
| JIWA+ customer app | Consumers | Brand selection, ordering, payment, membership, and vouchers |
| Outlet app | Outlet staff and managers | Stock levels, order handling, sales, and performance reporting |
| Rider app | Mobile coffee cart sellers | Selling sessions, cash and QRIS payments, stock and returns, and commissions |
A transaction started in one surface is visible in another. That is the whole point of the suite, and it is also where nearly all of the engineering difficulty lives.
Engineering Challenge
Building for a multi-brand F&B group introduces a specific set of constraints:
- One app, several brands. Menus, pricing, promotions, and outlet availability differ per brand while the ordering experience stays recognisably the same.
- Membership and loyalty are cross-cutting. Points, tiers, vouchers, and campaign eligibility affect the order total, so they cannot be bolted on after checkout.
- Payments are external contracts. A payment gateway is not a function call; it is a distributed transaction with retries, timeouts, and a source of truth that is not your database.
- Operations are the customer. Outlet staff need stock and reporting to be correct, not just presentable.
- Field sales are hostile to networking. A rider on a street corner cannot be asked to wait for a request to succeed, so the app has to work offline and reconcile later.
- Scale is uneven. A promotion can produce a burst of traffic that has nothing to do with the average load.
The consequence is that “add a feature to the app” usually means changing a workflow that several surfaces and at least one external system already depend on.
My Role & Contribution
My recorded contribution is backend and service work on the Jiwa Group app suite: part of the Technopartner Indonesia engineering team behind the customer, outlet, and rider surfaces, and the shared services they run on.
Within that scope, the engineering concerns are the ones this product family makes unavoidable:
- keeping one order visible and consistent across surfaces that have different lifecycles;
- integrating an external payment truth into the order lifecycle instead of treating it as a step;
- keeping membership, vouchers, and campaign eligibility inside the price calculation;
- supporting a field app that has to keep working while it is offline and reconcile when it returns;
- keeping stock, settlement, and commission figures defensible after the fact.
I am deliberately not assigning myself module ownership or customer metrics here: the recorded scope of this engagement is a role on the team and the engineering area it covers, and I would rather leave a claim out than inflate it.
Architecture
Conceptually, the suite is a set of client applications over shared backend services, with external systems at the edge.
The admin panel is part of the architecture rather than an afterthought: menus, promotions, and brand-specific configuration change far more often than the app itself, so they are configuration, not releases.
The Offline Problem
The rider app is the most interesting surface from a systems perspective, because it cannot assume the network exists.
A selling session has to remain correct when the device is offline for minutes or hours. That makes the following unavoidable:
- Local truth. The device needs its own usable state: menu, stock, and the orders already taken.
- Durable local writes. A transaction that the rider has completed must survive an app restart, a crash or a battery event.
- Reconciliation. Once connectivity returns, queued transactions have to reach the backend without being duplicated or silently dropped.
- Idempotency. Retrying a sync is normal, not exceptional, so replaying the same sale must not produce two sales.
- Conflict handling. Stock and returns can move on both sides while the device is offline, and the resolution rule has to be deliberate rather than accidental.
- End-of-day truth. Commission and reporting figures have to come from reconciled data, not from whatever the device believed at the time.
This is the same class of problem I keep running into in distributed systems: the network is not the only place where state can be inconsistent, and the client is not a passive terminal.
Engineering Principles
Public Product Context
Public materials describe the following scope for this family of products:
- a single customer app supporting multiple brands under Jiwa Group, with pre-order, membership management and exclusive promotions (case study);
- outlet-side management of stock, order processing, sales tracking and outlet reporting, including a holiday-date feature for scheduling and delivery planning (case study);
- a rider app covering selling sessions, inventory, order recording, cash and QRIS payments, commissions, and location tracking, with offline mode and automatic sync (case study);
- payment integration with Midtrans and OVO, personalization features, a web-based admin panel and fraud detection (case study).
For scale context, Jiwa Group publicly states three brands, 900+ outlets and 100+ cities (Jiwa Group about us), and reporting on Kopi Sejuta Jiwa’s locator feature puts its mobile carts at more than 1,500 operating units (Selular, 2026).
The apps are distributed publicly: JIWA+ is published as com.jiwa.jiwagroup on Google Play and as an App Store listing by the Jiwa Group publisher.
Scope, Limits & Confidentiality
This is client work delivered by Technopartner Indonesia, not a personal project.
This case study therefore:
- describes product capabilities only as they are publicly documented by the vendor and the client;
- describes my involvement at the level of the engineering team and the discipline it represents (mobile-facing product engineering and backend services), because that is the level at which this work can be shared;
- does not attribute specific module ownership, internal design, benchmarks, revenue or customer metrics to me.
It intentionally omits:
- proprietary source code and internal implementation details;
- internal architecture, service topology and infrastructure;
- customer, transaction, and outlet-level data;
- campaign rules, fraud rules and internal processes;
- team structure and internal roadmaps.
The diagrams above are conceptual representations of the problem domain. They are not reproductions of the production architecture.
Why This Work Matters
This suite is a good example of the kind of system I want to keep working on: several surfaces, an external payments truth, a loyalty model that changes the money, and a client that has to keep working when the network does not.
Each of those is a source of distributed-state problems rather than a UI problem: an order that exists in three places, a payment whose real status arrives later than the request, a stock number that changed while a device was offline, a commission that has to be defensible after the fact.
Working on it is why I treat idempotency, reconciliation, and lifecycle modelling as first-class parts of an interface rather than implementation detail.