Professional work

ZU Point Loyalty System CMS

A loyalty CMS for a rewards network of 48+ merchants and 20K+ outlets: voucher lifecycle, promo code engine, audit logs, and reporting.

Role
Software Engineer - Backend and Distributed Systems
Status
Active

What this project shows

Context

Client work with Digital Daya Teknologi (DDT) on the ZU Point loyalty platform at Technopartner Indonesia.

My contribution

Part of the Technopartner Indonesia engineering team that built the loyalty CMS core modules.

Why it matters

Production experience with redemption semantics that must be exactly once, rule-driven configuration, and multi-tenant operations at marketplace scale.

Public evidence

Highlights

  • 48+ merchants and 20K+ outlets on one voucher platform
  • Redemption that has to be exactly once under concurrency
  • Promo code engine with targeted generation
  • Activity logs and role-based administrative control
  • Reporting and export for campaign analysis

Loyalty Platform Engineering - Voucher Lifecycle - Promo Engine - Multi-Tenant CMS

Overview

ZU Point is a loyalty program that connects several brands and merchant networks under one points and voucher system: members earn ZU Point across participating brands and redeem it for vouchers and discounts (ZU Point about).

The ZU Point CMS is the administrative half of that ecosystem: the system merchants and campaign operators use to create vouchers, generate promo codes, configure merchants and outlets, and monitor what was issued, claimed, and redeemed. Public materials describe it as an advanced voucher and promo code management platform supporting one of Indonesia’s largest loyalty ecosystems, delivered by Technopartner Indonesia together with Digital Daya Teknologi (DDT) (case study).

The same portfolio lists ZU Point’s client as Nobu and its industry as a loyalty rewards system, with a scalable backend, a mobile web interface for members, and a CMS for tenant and campaign management (portfolio entry).

As part of the Technopartner Indonesia engineering team (my current role, since September 2024), I worked on this platform. This write-up describes the engineering problem it represents at the level that can be shared publicly.


Engineering Challenge

A loyalty CMS looks like an admin panel with forms. Operationally it is a system where money-like instruments are created, distributed, and consumed, and where a mistake is a financial and reputational event:

  • Vouchers are state machines. A voucher moves through creation, issuance, purchase, claim, redemption, and expiry, and several of those transitions can be attempted twice.
  • Redemption must be exactly once. A promo code that can be redeemed twice is a direct loss, and concurrency makes “check then act” the default wrong answer.
  • Promotional logic is genuinely complex. Multi-tier campaigns, discount versus Buy X Get Y versus percentage rules, and merchant-specific eligibility cannot all be expressed as separate special cases forever.
  • Tenants are independent and numerous. The public case study describes a network of 48+ merchants with 20K+ outlets, each with its own rules, outlet groups and categories.
  • Administrators are many and their powers differ. Role and access control is the difference between a campaign operator and someone who can invalidate vouchers across the platform.
  • Auditability is mandatory. “Who created, changed, issued or voided this” has to be answerable after the fact, because disputes arrive later than the campaign.
  • Reporting is the product’s output. If redemption counts and rates cannot be filtered and exported, the platform cannot tell the business what its campaigns did.

Two engineering organisations were also involved in the same system, which adds a boundary problem on top of all of the above.


My Role & Contribution

My recorded contribution is loyalty platform and CMS backend work on ZU Point: part of the Technopartner Indonesia engineering team that built the CMS core modules, in a delivery shared with Digital Daya Teknologi (DDT).

Within that scope, the engineering concerns are:

  • modelling a voucher as a lifecycle whose transitions are safe to repeat;
  • making redemption exactly once under concurrency, because a double-redeemed reward is a direct loss;
  • expressing campaign conditions as configuration rather than as code paths;
  • scoping what an operator can see and act on across a large merchant and outlet network;
  • keeping an audit trail that can answer who changed what, and reporting that can explain a campaign afterwards.

I am deliberately not assigning myself module ownership, merchant-level data or campaign outcomes here: the recorded scope of this engagement is a role on the team and the engineering area it covers.


Architecture

Conceptually, the CMS sits between campaign operators and the member-facing loyalty network.

Administrators work through the CMS, which owns the voucher lifecycle, promo code engine, merchant and outlet registry, and the audit log, and feeds claim, redemption, reporting, and member touchpoints.

Mermaid preview

The CMS is the control plane. The member touchpoints, the reward rules and the redemption path are where the operational truth is produced.


Voucher and Promo Code Lifecycle

The core object in the system is not a voucher record; it is a lifecycle with controlled transitions.

A deal creates vouchers that are issued, claimed, and redeemed, while expiry, voiding, and reversal are separate transitions off that path.

Mermaid preview

Each transition has to answer the same questions the same way:

  • who is allowed to perform it;
  • whether it is safe to repeat;
  • what it records so the transition can be explained later;
  • what happens if two actors attempt it at the same time;
  • what it means for already-issued vouchers when the underlying deal changes.

Public documentation confirms the object model includes deal types (discount, Buy X Get Y, percentage-based), bulk voucher injection, voucher purchase and issuance status, deal catalogs and lists, plus a promo code system for unique codes distributed either en masse or to specific users (case study).


Engineering Principles

Redemption is a state transition, not an update

Applying a voucher is not “set redeemed = true”. It is a guarded transition on a single record, and the guard is what enforces exactly-once semantics under concurrency. Reads used as decisions are the failure mode here, because the system is judged by what happens when two outlets redeem at the same instant.

Rules belong in configuration where the domain allows it

Campaign conditions change faster than code ships. A promo engine that can express eligibility, tiering, and deal types as configuration lets the business change a campaign without a release, which is the difference between a platform and a queue of change requests.

Multi-tenancy is a data boundary, not a filter

With tens of thousands of outlets, “all merchants” is not a valid default. Tenant scoping has to be structural: what an operator can see and act on is determined by their assignment, not by remembering to add a condition.

Audit the decision, not only the value

A log that says a voucher is voided answers nothing. A log that records who did it, when, under which role and from which interface can end an argument.

Reporting is part of the contract

Redemption counts and rates are what the platform is asked about. Filters by merchant type, category, and voucher type, and export to Excel or CSV, are not a dashboards-afterthought; they are the deliverable (case study).

Boundaries between organisations deserve explicit interfaces

When two engineering teams from different companies build one system, the integration surface has to be documented and stable, and ownership of each module has to be unambiguous. Otherwise every change becomes a negotiation.


Public Product Context

Public materials describe the following scope for this platform:

  • centralized control for creating, issuing, managing, and tracking vouchers and promo codes across multiple merchants;
  • a merchant network of 48+ merchants with 20K+ outlets managing their own promotional activity, with merchant profiles, outlet groups and categories, and enable/disable access;
  • real-time insight into voucher issuance, claims, and redemptions;
  • a dual-development architecture between Technopartner and DDT (case study);
  • for the wider ZU ecosystem: points earned across participating brands and redeemed as vouchers or discounts, including HyperMart, Bank Nobu and tenants across Lippo Malls (ZU Point about);
  • DDT’s own product line describes a customer loyalty solution with Open API, web, and mobile application options and multiple reward types including vouchers, points, stamps, and gamification (DDT).

Public References

Scope, Limits & Confidentiality

This is client work delivered by Technopartner Indonesia together with DDT, not a personal project.

This case study therefore:

  • describes the system only at the level that is publicly documented by the vendor and the partner;
  • describes my involvement at the level of the engineering team and the discipline it represents (loyalty platform backend and CMS engineering), because that is the level at which this work can be shared;
  • does not attribute specific module ownership, internal design, benchmarks, merchant-level or campaign-level data to me.

It intentionally omits:

  • proprietary source code and internal implementation details;
  • internal architecture, service topology and infrastructure;
  • merchant, outlet, member, and transaction data;
  • campaign rules, anti-abuse rules and internal processes;
  • commercial arrangements between the parties;
  • internal roadmaps and team structure.

The diagrams above are conceptual representations of the problem domain. They are not reproductions of the production architecture.


Why This Work Matters

Most of the systems I work on are judged on whether independent components agree about shared state. Loyalty pushes that question to its sharpest form: the shared state is a reward with a monetary value, the clients are dozens of merchants and tens of thousands of outlets, and the operations that must not be duplicated are exactly the ones users are most motivated to retry.

That makes it a good exercise in the parts of backend engineering that are easy to skip: guarded state transitions, idempotent writes, allocation and settlement records, role-scoped access, and an audit trail that survives a dispute months later.

The same discipline shows up in the systems I build now: define the lifecycle, make the transitions safe to repeat, and make the history explainable.

Search this site