Back to Engineering Articles/Promo & Voucher Engine Q-Commerce: Rule Engine Anti-Abuse

Promo & Voucher Engine Q-Commerce: Rule Engine Anti-Abuse

System design promo engine untuk quick commerce. Rule engine dengan kondisi komposable (min transaksi, first-N-order, area, kategori) ke efek (discount, free ongkir), atomic counter untuk limit penggunaan Redis Lua, anti-fraud device fingerprinting, stackable vs eksklusif promo resolution, dan budget cap. Implementasi Golang lengkap dengan composable condition interface, AND/OR composite tree, concurrent-safe redeem, serta Kafka event streaming untuk audit trail.

Faisal AffanFaisal Affan
6/20/2026

Promo & Voucher Engine Q-Commerce: Rule Engine Anti-Abuse

"The fastest way to lose margin in quick commerce is a poorly-designed promo engine. Every unvalidated discount bleeds profit, every exploited loophole compounds into millions."

TL;DR

Promo engine adalah salah satu komponen paling kritis di Q-commerce. Satu bug di rule evaluation bisa menyebabkan kerugian puluhan juta dalam hitungan menit. Artikel ini membangun promo engine dari nol: composable rule engine dengan AST-based condition tree, atomic counter Redis Lua untuk limit penggunaan, anti-fraud device fingerprinting, dan stackable promo resolution.

Arsitektur Promo Engine

Sebelum masuk ke kode, mari pahami arsitektur keseluruhan.

Key Design Decisions

  1. Rule config di PostgreSQL — bukan code, biar bisa diubah tanpa deploy
  2. Atomic counter di Redis Lua — prevent race condition pada limited promos
  3. Fraud detector terpisah — biar bisa di-scale independently
  4. Kafka untuk audit trail — semua promo application di-log buat reconciliation

1. Composable Rule Engine

Inti dari promo engine adalah rule evaluation. Setiap promo punya kondisi yang harus dipenuhi sebelum efek diterapkan. Kondisi bisa sederhana (minimal transaksi Rp50.000) atau kompleks (area Jabodetabek DAN kategori Elektronik ATAU first-100-order).

Design Pattern: AST-based Condition Tree

Kita pakai Composite Pattern — setiap kondisi adalah node dalam tree, bisa berupa leaf condition atau composite AND/OR.

internal/promo/rule/types.go
package rule

import (
    "context"
    "time"
)

// Rule merepresentasikan satu promo rule lengkap
type Rule struct {
    ID          string         `json:"id"`
    Name        string         `json:"name"`
    Description string         `json:"description"`
    Priority    int            `json:"priority"`    // higher = applied first
    Conditions  Condition      `json:"conditions"`  // root of condition tree
    Effect      Effect         `json:"effect"`
    Limits      UsageLimits    `json:"limits"`
    Stackable  bool            `json:"stackable"`
    ExclusivityGroup string   `json:"exclusivity_group,omitempty"`
    Active      bool           `json:"active"`
    StartAt     time.Time      `json:"start_at"`
    EndAt       time.Time      `json:"end_at"`
}

// UsageLimits mendefinisikan batas pemakaian promo
type UsageLimits struct {
    MaxUsageTotal    int            `json:"max_usage_total"`    // global cap
    MaxUsagePerUser  int            `json:"max_usage_per_user"` // per user cap
    MaxUsagePerDay   int            `json:"max_usage_per_day"`  // daily cap
    BudgetCap        int64          `json:"budget_cap"`         // max total discount amount in IDR
    BudgetUsed       int64          `json:"budget_used"`        // current usage
}

// Effect adalah aksi yang diterapkan jika kondisi terpenuhi
type Effect struct {
    Type            EffectType `json:"type"`
    Value           float64    `json:"value"`            // percentage or amount
    MaxDiscount     int64      `json:"max_discount,omitempty"`
    MinOrderAmount  int64      `json:"min_order_amount,omitempty"`
}

type EffectType string

const (
    EffectPercentage   EffectType = "percentage_discount"
    EffectFixedAmount  EffectType = "fixed_amount"
    EffectFreeShipping EffectType = "free_shipping"
    EffectCashback     EffectType = "cashback"
)

Condition Interface dan Implementasi

internal/promo/rule/condition.go
package rule

import (
    "context"
    "encoding/json"
    "fmt"
)

// Condition adalah interface untuk evaluasi kondisi
type Condition interface {
    // Evaluate mengevaluasi kondisi terhadap context order
    Evaluate(ctx context.Context, ctx *EvalContext) (*EvalResult, error)
    // Type mengembalikan tipe kondisi (untuk serialization)
    Type() string
}

// EvalContext adalah context yang dibawa saat evaluasi
type EvalContext struct {
    UserID        string
    OrderAmount   int64          // in IDR smallest unit (sen)
    Items         []OrderItem
    Area          string
    City          string
    Province      string
    StoreID       string
    CategoryIDs   []string
    PaymentMethod string
    UsageCount    UsageCounters
    IsFirstOrder  bool
    OrderCount    int
    DeviceFingerprint string
    PhoneHash     string
}

type OrderItem struct {
    SKU        string
    Name       string
    CategoryID string
    Price      int64
    Quantity   int
}

type UsageCounters struct {
    UserTotal   int
    GlobalTotal int
    TodayTotal  int
}

// EvalResult adalah hasil evaluasi satu kondisi
type EvalResult struct {
    Passed       bool
    Reason       string             // why it passed/failed
    MatchedValue interface{}        // nilai yang match (untuk debug)
    Children     []*EvalResult      // untuk composite conditions
}

// --- Leaf Conditions ---

// MinTransactionCondition: minimal amount transaksi
type MinTransactionCondition struct {
    MinAmount int64 `json:"min_amount"`
}

func (c *MinTransactionCondition) Type() string { return "min_transaction" }

func (c *MinTransactionCondition) Evaluate(ctx context.Context, ec *EvalContext) (*EvalResult, error) {
    if ec.OrderAmount < c.MinAmount {
        return &EvalResult{
            Passed: false,
            Reason: fmt.Sprintf("Order amount %d < minimum %d", ec.OrderAmount, c.MinAmount),
        }, nil
    }
    return &EvalResult{
        Passed:       true,
        Reason:       fmt.Sprintf("Order amount %d >= minimum %d", ec.OrderAmount, c.MinAmount),
        MatchedValue: ec.OrderAmount,
    }, nil
}

// AreaCondition: filter berdasarkan area
type AreaCondition struct {
    AllowedAreas []string `json:"allowed_areas"`
}

func (c *AreaCondition) Type() string { return "area" }

func (c *AreaCondition) Evaluate(ctx context.Context, ec *EvalContext) (*EvalResult, error) {
    for _, area := range c.AllowedAreas {
        if area == ec.Area || area == ec.City || area == ec.Province {
            return &EvalResult{
                Passed:       true,
                Reason:       fmt.Sprintf("Area %s is allowed", ec.Area),
                MatchedValue: ec.Area,
            }, nil
        }
    }
    return &EvalResult{
        Passed: false,
        Reason: fmt.Sprintf("Area %s not in allowed list", ec.Area),
    }, nil
}

// CategoryCondition: filter kategori produk
type CategoryCondition struct {
    AllowedCategories []string `json:"allowed_categories"`
    MatchAny          bool     `json:"match_any"` // true = cukup salah satu
}

func (c *CategoryCondition) Type() string { return "category" }

func (c *CategoryCondition) Evaluate(ctx context.Context, ec *EvalContext) (*EvalResult, error) {
    if c.MatchAny {
        for _, item := range ec.Items {
            for _, allowed := range c.AllowedCategories {
                if item.CategoryID == allowed {
                    return &EvalResult{
                        Passed:       true,
                        Reason:       fmt.Sprintf("Item %s matches category %s", item.SKU, allowed),
                        MatchedValue: item,
                    }, nil
                }
            }
        }
        return &EvalResult{Passed: false, Reason: "No items match any allowed category"}, nil
    }

    // MatchAll: semua item harus dari kategori yang diizinkan
    for _, item := range ec.Items {
        allowed := false
        for _, cat := range c.AllowedCategories {
            if item.CategoryID == cat {
                allowed = true
                break
            }
        }
        if !allowed {
            return &EvalResult{
                Passed: false,
                Reason: fmt.Sprintf("Item %s category %s not allowed", item.SKU, item.CategoryID),
            }, nil
        }
    }
    return &EvalResult{Passed: true, Reason: "All items in allowed categories"}, nil
}

// FirstNOrderCondition: hanya untuk N order pertama
type FirstNOrderCondition struct {
    MaxOrderSequence int `json:"max_order_sequence"`
}

func (c *FirstNOrderCondition) Type() string { return "first_n_order" }

func (c *FirstNOrderCondition) Evaluate(ctx context.Context, ec *EvalContext) (*EvalResult, error) {
    if ec.OrderCount <= c.MaxOrderSequence {
        return &EvalResult{
            Passed:       true,
            Reason:       fmt.Sprintf("Order %d <= max sequence %d", ec.OrderCount, c.MaxOrderSequence),
            MatchedValue: ec.OrderCount,
        }, nil
    }
    return &EvalResult{
        Passed: false,
        Reason: fmt.Sprintf("Order %d exceeds max sequence %d", ec.OrderCount, c.MaxOrderSequence),
    }, nil
}

// TimeSlotCondition: valid only during specific hours
type TimeSlotCondition struct {
    StartHour int `json:"start_hour"` // 0-23
    EndHour   int `json:"end_hour"`   // 0-23
}

func (c *TimeSlotCondition) Type() string { return "time_slot" }

func (c *TimeSlotCondition) Evaluate(ctx context.Context, ec *EvalContext) (*EvalResult, error) {
    // hour check logic — simplified, use actual time from context
    return &EvalResult{
        Passed: true,
        Reason: "Time slot valid",
    }, nil
}

Composite Conditions: AND/OR

internal/promo/rule/composite.go
package rule

import (
    "context"
    "fmt"
    "strings"
)

// ANDCondition: semua child harus pass
type ANDCondition struct {
    Conditions []Condition `json:"conditions"`
}

func (c *ANDCondition) Type() string { return "and" }

func (c *ANDCondition) Evaluate(ctx context.Context, ec *EvalContext) (*EvalResult, error) {
    var children []*EvalResult

    for _, cond := range c.Conditions {
        result, err := cond.Evaluate(ctx, ec)
        if err != nil {
            return nil, fmt.Errorf("and condition: %w", err)
        }
        children = append(children, result)
        if !result.Passed {
            return &EvalResult{
                Passed:   false,
                Reason:   fmt.Sprintf("AND failed at: %s", result.Reason),
                Children: children,
            }, nil
        }
    }

    return &EvalResult{
        Passed:   true,
        Reason:   "All AND conditions passed",
        Children: children,
    }, nil
}

// ORCondition: minimal satu child harus pass
type ORCondition struct {
    Conditions []Condition `json:"conditions"`
}

func (c *ORCondition) Type() string { return "or" }

func (c *ORCondition) Evaluate(ctx context.Context, ec *EvalContext) (*EvalResult, error) {
    var children []*EvalResult

    for _, cond := range c.Conditions {
        result, err := cond.Evaluate(ctx, ec)
        if err != nil {
            return nil, fmt.Errorf("or condition: %w", err)
        }
        children = append(children, result)
        if result.Passed {
            return &EvalResult{
                Passed:   true,
                Reason:   fmt.Sprintf("OR passed at: %s", result.Reason),
                MatchedValue: result.MatchedValue,
                Children: children,
            }, nil
        }
    }

    return &EvalResult{
        Passed:   false,
        Reason:   "No OR conditions passed",
        Children: children,
    }, nil
}

// NOTCondition: negasi kondisi
type NOTCondition struct {
    Condition Condition `json:"condition"`
}

func (c *NOTCondition) Type() string { return "not" }

func (c *NOTCondition) Evaluate(ctx context.Context, ec *EvalContext) (*EvalResult, error) {
    result, err := c.Condition.Evaluate(ctx, ec)
    if err != nil {
        return nil, fmt.Errorf("not condition: %w", err)
    }
    return &EvalResult{
        Passed:   !result.Passed,
        Reason:   fmt.Sprintf("NOT (%s) = %v", result.Reason, !result.Passed),
        Children: []*EvalResult{result},
    }, nil
}

Rule Evaluator Engine

internal/promo/rule/evaluator.go
package rule

import (
    "context"
    "fmt"
    "time"
)

// Evaluator adalah engine untuk mengevaluasi semua rules terhadap order
type Evaluator struct {
    store RuleStore
}

type RuleStore interface {
    GetActiveRules(ctx context.Context) ([]Rule, error)
    GetRulesByIDs(ctx context.Context, ids []string) ([]Rule, error)
}

func NewEvaluator(store RuleStore) *Evaluator {
    return &Evaluator{store: store}
}

// EvaluateResult adalah hasil evaluasi lengkap
type EvaluateResult struct {
    RuleID      string
    RuleName    string
    Passed      bool
    ConditionResult *EvalResult
    Effect      *Effect
    AppliedAt   time.Time
}

// EvaluateAll mengevaluasi semua active rules untuk order context
func (e *Evaluator) EvaluateAll(ctx context.Context, ec *EvalContext) ([]EvaluateResult, error) {
    rules, err := e.store.GetActiveRules(ctx)
    if err != nil {
        return nil, fmt.Errorf("get active rules: %w", err)
    }

    results := make([]EvaluateResult, 0, len(rules))

    for _, r := range rules {
        // Skip expired or not-yet-active rules
        now := time.Now()
        if now.Before(r.StartAt) || now.After(r.EndAt) {
            continue
        }
        if !r.Active {
            continue
        }

        result := r.Conditions.Evaluate(ctx, ec)
        if err != nil {
            // Log error but continue evaluating other rules
            continue
        }

        results = append(results, EvaluateResult{
            RuleID:          r.ID,
            RuleName:        r.Name,
            Passed:          result.Passed,
            ConditionResult: result,
            Effect:          &r.Effect,
            AppliedAt:       now,
        })
    }

    return results, nil
}

// EvaluateSingle evaluates a single rule
func (e *Evaluator) EvaluateSingle(ctx context.Context, ruleID string, ec *EvalContext) (*EvaluateResult, error) {
    rules, err := e.store.GetRulesByIDs(ctx, []string{ruleID})
    if err != nil {
        return nil, fmt.Errorf("get rule %s: %w", ruleID, err)
    }
    if len(rules) == 0 {
        return nil, fmt.Errorf("rule %s not found", ruleID)
    }

    r := rules[0]
    result, err := r.Conditions.Evaluate(ctx, ec)
    if err != nil {
        return nil, fmt.Errorf("evaluate rule %s: %w", ruleID, err)
    }

    return &EvaluateResult{
        RuleID:          r.ID,
        RuleName:        r.Name,
        Passed:          result.Passed,
        ConditionResult: result,
        Effect:          &r.Effect,
        AppliedAt:       time.Now(),
    }, nil
}

Rule Configuration via JSON/YAML

Kita bisa menyimpan rule sebagai JSON di database:

config/rules/sample-rules.json
{
  "rules": [
    {
      "id": "promo_welcome_50k",
      "name": "Welcome New User - 50K Diskon",
      "priority": 100,
      "conditions": {
        "type": "and",
        "conditions": [
          { "type": "min_transaction", "min_amount": 50000 },
          { "type": "first_n_order", "max_order_sequence": 1 },
          { "type": "area", "allowed_areas": ["Jakarta", "Tangerang", "Bekasi", "Depok"] }
        ]
      },
      "effect": {
        "type": "fixed_amount",
        "value": 50000,
        "max_discount": 50000,
        "min_order_amount": 50000
      },
      "limits": {
        "max_usage_total": 10000,
        "max_usage_per_user": 1,
        "max_usage_per_day": 500,
        "budget_cap": 500000000
      },
      "stackable": false,
      "exclusivity_group": "welcome_promo",
      "active": true,
      "start_at": "2026-01-01T00:00:00Z",
      "end_at": "2026-12-31T23:59:59Z"
    },
    {
      "id": "free_ongkir_jabodetabek",
      "name": "Free Ongkir Jabodetabek",
      "priority": 50,
      "conditions": {
        "type": "and",
        "conditions": [
          { "type": "area", "allowed_areas": ["Jakarta", "Bogor", "Depok", "Tangerang", "Bekasi"] },
          { "type": "min_transaction", "min_amount": 30000 }
        ]
      },
      "effect": { "type": "free_shipping", "value": 0 },
      "limits": {
        "max_usage_per_user": 10,
        "budget_cap": 100000000
      },
      "stackable": true,
      "active": true,
      "start_at": "2026-01-01T00:00:00Z",
      "end_at": "2026-12-31T23:59:59Z"
    }
  ]
}

Deserialize JSON ke Condition Tree

internal/promo/rule/deserialize.go
package rule

import (
    "encoding/json"
    "fmt"
)

// rawCondition digunakan untuk deserialisasi JSON
type rawCondition struct {
    Type       string          `json:"type"`
    Conditions json.RawMessage `json:"conditions,omitempty"`
    Condition  json.RawMessage `json:"condition,omitempty"`
    MinAmount  *int64          `json:"min_amount,omitempty"`
    MaxAmount  *int64          `json:"max_amount,omitempty"`
    // ... field lainnya sesuai tipe
    AllowedAreas     []string `json:"allowed_areas,omitempty"`
    AllowedCategories []string `json:"allowed_categories,omitempty"`
    MaxOrderSequence *int     `json:"max_order_sequence,omitempty"`
    MatchAny         *bool    `json:"match_any,omitempty"`
}

// UnmarshalCondition mengkonversi JSON ke Condition interface
func UnmarshalCondition(data []byte) (Condition, error) {
    var raw rawCondition
    if err := json.Unmarshal(data, &raw); err != nil {
        return nil, fmt.Errorf("unmarshal condition: %w", err)
    }
    return buildCondition(raw)
}

func buildCondition(raw rawCondition) (Condition, error) {
    switch raw.Type {
    case "and":
        return buildAND(raw)
    case "or":
        return buildOR(raw)
    case "not":
        return buildNOT(raw)
    case "min_transaction":
        return &MinTransactionCondition{MinAmount: *raw.MinAmount}, nil
    case "area":
        return &AreaCondition{AllowedAreas: raw.AllowedAreas}, nil
    case "category":
        matchAny := false
        if raw.MatchAny != nil {
            matchAny = *raw.MatchAny
        }
        return &CategoryCondition{
            AllowedCategories: raw.AllowedCategories,
            MatchAny:          matchAny,
        }, nil
    case "first_n_order":
        return &FirstNOrderCondition{MaxOrderSequence: *raw.MaxOrderSequence}, nil
    default:
        return nil, fmt.Errorf("unknown condition type: %s", raw.Type)
    }
}

func buildAND(raw rawCondition) (*ANDCondition, error) {
    var children []json.RawMessage
    if err := json.Unmarshal(raw.Conditions, &children); err != nil {
        return nil, fmt.Errorf("and children: %w", err)
    }
    conds := make([]Condition, 0, len(children))
    for _, child := range children {
        c, err := UnmarshalCondition(child)
        if err != nil {
            return nil, err
        }
        conds = append(conds, c)
    }
    return &ANDCondition{Conditions: conds}, nil
}

func buildOR(raw rawCondition) (*ORCondition, error) {
    var children []json.RawMessage
    if err := json.Unmarshal(raw.Conditions, &children); err != nil {
        return nil, fmt.Errorf("or children: %w", err)
    }
    conds := make([]Condition, 0, len(children))
    for _, child := range children {
        c, err := UnmarshalCondition(child)
        if err != nil {
            return nil, err
        }
        conds = append(conds, c)
    }
    return &ORCondition{Conditions: conds}, nil
}

func buildNOT(raw rawCondition) (*NOTCondition, error) {
    var child json.RawMessage
    if err := json.Unmarshal(raw.Condition, &child); err != nil {
        return nil, fmt.Errorf("not child: %w", err)
    }
    c, err := UnmarshalCondition(child)
    if err != nil {
        return nil, err
    }
    return &NOTCondition{Condition: c}, nil
}

Pattern: Composite + Strategy

Desain ini menggabungkan Composite Pattern (AND/OR nodes) dengan Strategy Pattern (leaf conditions). Keuntungan: rules bisa dikonfigurasi tanpa deploy code, tree bisa dirender untuk debugging, dan evaluasi bisa di-stop early (short-circuit AND/OR).

2. Atomic Promo Counter dengan Redis Lua

Ketika promo punya limit penggunaan (first-1000, daily cap 500), kita butuh atomic increment-and-check. Race condition di sini bisa menyebabkan over-redemption.

Why Redis Lua?

Naif approach: GET counter → if counter < limit → INCR counter. Ini NOT atomic. Di high concurrency, dua request bisa sama-sama lulus check dan melebihi limit. Redis Lua script menjamin atomic execution — seluruh script jalan tanpa interupsi.

internal/promo/counter/redis_counter.go
package counter

import (
    "context"
    "fmt"
    "time"

    "github.com/redis/go-redis/v9"
)

// CounterService handles atomic promo usage counting
type CounterService struct {
    client *redis.Client
}

func NewCounterService(client *redis.Client) *CounterService {
    return &CounterService{client: client}
}

// counterKey generates Redis key for a specific counter type
func (s *CounterService) counterKey(promoID string, counterType string) string {
    return fmt.Sprintf("promo:counter:%s:%s", promoID, counterType)
}

// dailyCounterKey includes date for daily-rolling counters
func (s *CounterService) dailyCounterKey(promoID string) string {
    today := time.Now().UTC().Format("2006-01-02")
    return fmt.Sprintf("promo:counter:%s:daily:%s", promoID, today)
}

// incrementAndCheckScript: atomically increment and check limit
// Returns: 0 = limit exceeded, >0 = current count after increment
const incrementAndCheckScript = `
    local key = KEYS[1]
    local ttl = tonumber(ARGV[1])
    local limit = tonumber(ARGV[2])

    local current = redis.call("GET", key)
    if current and tonumber(current) >= limit then
        return 0
    end

    local count = redis.call("INCR", key)
    if count == 1 and ttl > 0 then
        redis.call("EXPIRE", key, ttl)
    end

    if count > limit then
        redis.call("DECR", key)
        return 0
    end

    return count
`

var incrementAndCheck = redis.NewScript(incrementAndCheckScript)

// IncrementAndCheck atomically increments and checks if limit is reached
// Returns (currentCount, allowed, error)
func (s *CounterService) IncrementAndCheck(
    ctx context.Context,
    promoID string,
    counterType string,
    limit int,
    ttl time.Duration,
) (int64, bool, error) {
    key := s.counterKey(promoID, counterType)

    result, err := incrementAndCheck.Run(ctx, s.client,
        []string{key},
        int(ttl.Seconds()),
        limit,
    ).Int64()
    if err != nil {
        return 0, false, fmt.Errorf("increment and check promo %s: %w", promoID, err)
    }

    return result, result > 0, nil
}

// CheckGlobalLimits checks all global limits atomically
func (s *CounterService) CheckGlobalLimits(
    ctx context.Context,
    promoID string,
    limits UsageLimits,
) error {
    // Check total usage limit
    if limits.MaxUsageTotal > 0 {
        _, allowed, err := s.IncrementAndCheck(ctx, promoID, "total",
            limits.MaxUsageTotal, 0)
        if err != nil {
            return err
        }
        if !allowed {
            return fmt.Errorf("promo %s: total usage limit reached (%d)", promoID, limits.MaxUsageTotal)
        }
    }

    return nil
}

// CheckAndIncrementAll checks all limits in one shot using Redis MULTI/EXEC via Lua
const checkAllLimitsScript = `
    local total_key = KEYS[1]
    local daily_key = KEYS[2]
    local user_key = KEYS[3]

    local max_total = tonumber(ARGV[1])
    local max_daily = tonumber(ARGV[2])
    local max_user = tonumber(ARGV[3])
    local daily_ttl = tonumber(ARGV[4])
    local user_ttl = tonumber(ARGV[5])

    -- Check total
    if max_total > 0 then
        local total = redis.call("GET", total_key)
        if total and tonumber(total) >= max_total then
            return "TOTAL_LIMIT_EXCEEDED"
        end
    end

    -- Check daily
    if max_daily > 0 then
        local daily = redis.call("GET", daily_key)
        if daily and tonumber(daily) >= max_daily then
            return "DAILY_LIMIT_EXCEEDED"
        end
    end

    -- Check user
    if max_user > 0 then
        local user = redis.call("GET", user_key)
        if user and tonumber(user) >= max_user then
            return "USER_LIMIT_EXCEEDED"
        end
    end

    -- All good, increment counters
    if max_total > 0 then
        local total = redis.call("INCR", total_key)
    end
    if max_daily > 0 then
        local daily = redis.call("INCR", daily_key)
        if daily == 1 then
            redis.call("EXPIRE", daily_key, daily_ttl)
        end
    end
    if max_user > 0 then
        local user = redis.call("INCR", user_key)
        if user == 1 then
            redis.call("EXPIRE", user_key, user_ttl)
        end
    end

    return "OK"
`

var checkAllLimits = redis.NewScript(checkAllLimitsScript)

// BudgetCheck: cek sisa budget promo sebelum apply
func (s *CounterService) CheckBudget(
    ctx context.Context,
    promoID string,
    discountAmount int64,
    budgetCap int64,
) (bool, error) {
    if budgetCap <= 0 {
        return true, nil // no budget cap
    }

    key := fmt.Sprintf("promo:budget:%s", promoID)

    const budgetScript = `
        local key = KEYS[1]
        local increment = tonumber(ARGV[1])
        local cap = tonumber(ARGV[2])

        local current = redis.call("GET", key)
        local used = 0
        if current then
            used = tonumber(current)
        end

        if used + increment > cap then
            return 0  -- budget exceeded
        end

        redis.call("INCRBY", key, increment)
        return 1  -- OK
    `

    result, err := redis.NewScript(budgetScript).Run(ctx, s.client,
        []string{key}, discountAmount, budgetCap).Int64()
    if err != nil {
        return false, fmt.Errorf("check budget promo %s: %w", promoID, err)
    }

    return result == 1, nil
}

// UsageLimits is defined here for counter package
type UsageLimits struct {
    MaxUsageTotal   int `json:"max_usage_total"`
    MaxUsagePerUser int `json:"max_usage_per_user"`
    MaxUsagePerDay  int `json:"max_usage_per_day"`
    BudgetCap       int64 `json:"budget_cap"`
}

Why Not PostgreSQL for Counters?

Redis dipilih karena: (1) operasi INCR di Redis adalah microsecond latency vs PostgreSQL row lock yang milisecond. (2) TTL-based key auto-expire untuk daily counter tanpa cron job. (3) Redis Lua script menjamin atomicity tanpa transaction overhead. Trade-off: jika Redis crash, data counter bisa hilang — mitigasi dengan Redis AOF persistence + periodic snapshot ke PostgreSQL untuk recovery.

3. Anti-Fraud Detection

Fraud di promo engine biasanya berupa: multi-account pakai device sama, alamat mirip, atau nomor telepon beda tapi alamat sama.

internal/promo/fraud/detector.go
package fraud

import (
    "context"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "strings"
    "time"
)

// FraudDetector mendeteksi potensi fraud pada redeem promo
type FraudDetector struct {
    store    FraudStore
    config   FraudConfig
}

type FraudStore interface {
    // GetDeviceUsers returns all user IDs that used this device
    GetDeviceUsers(ctx context.Context, fingerprint string) ([]string, error)
    // GetPhoneHashes returns all phone hashes for a user
    GetPhoneHashes(ctx context.Context, userID string) ([]string, error)
    // GetUserAddresses returns address hashes for a user
    GetUserAddresses(ctx context.Context, userID string) ([]AddressRecord, error)
    // RecordFraudEvent logs a fraud detection event
    RecordFraudEvent(ctx context.Context, event FraudEvent) error
}

type FraudConfig struct {
    MaxAccountsPerDevice int     `json:"max_accounts_per_device"` // 3
    MaxAccountsPerPhone  int     `json:"max_accounts_per_phone"`  // 2
    AddressSimilarityThreshold float64 `json:"address_similarity_threshold"` // 0.8
    MaxRedeemsPerHour    int     `json:"max_redeems_per_hour"`    // 5
}

type AddressRecord struct {
    UserID      string
    AddressHash string
    AddressRaw  string
    City        string
    CreatedAt   time.Time
}

type FraudEvent struct {
    EventID     string    `json:"event_id"`
    UserID      string    `json:"user_id"`
    PromoID     string    `json:"promo_id"`
    RiskLevel   string    `json:"risk_level"` // low, medium, high
    Reason      string    `json:"reason"`
    DeviceFP    string    `json:"device_fingerprint,omitempty"`
    PhoneHash   string    `json:"phone_hash,omitempty"`
    Timestamp   time.Time `json:"timestamp"`
}

// FraudCheckResult menyimpan hasil pemeriksaan fraud
type FraudCheckResult struct {
    IsSuspicious bool
    RiskLevel    string // low, medium, high
    Reasons      []string
    ShouldBlock  bool
}

func NewDetector(store FraudStore, config FraudConfig) *FraudDetector {
    return &FraudDetector{store: store, config: config}
}

// CheckFraud melakukan multi-faktor fraud check
func (d *FraudDetector) CheckFraud(
    ctx context.Context,
    userID string,
    deviceFP string,
    phoneHash string,
    addressHash string,
) (*FraudCheckResult, error) {
    result := &FraudCheckResult{
        Reasons: make([]string, 0),
    }

    // 1. Device fingerprint check
    deviceUsers, err := d.store.GetDeviceUsers(ctx, deviceFP)
    if err != nil {
        return nil, fmt.Errorf("get device users: %w", err)
    }

    if len(deviceUsers) >= d.config.MaxAccountsPerDevice {
        result.IsSuspicious = true
        result.RiskLevel = "high"
        result.Reasons = append(result.Reasons,
            fmt.Sprintf("Device used by %d accounts (max %d)", len(deviceUsers), d.config.MaxAccountsPerDevice))
        result.ShouldBlock = true
    }

    // 2. Phone hash check
    phoneUsers, err := d.store.GetPhoneHashes(ctx, phoneHash)
    if err != nil {
        return nil, fmt.Errorf("get phone users: %w", err)
    }

    if len(phoneUsers) >= d.config.MaxAccountsPerPhone {
        result.IsSuspicious = true
        if result.RiskLevel != "high" {
            result.RiskLevel = "medium"
        }
        result.Reasons = append(result.Reasons,
            fmt.Sprintf("Phone number used by %d accounts", len(phoneUsers)))
    }

    // 3. Address similarity check
    existingAddresses, err := d.store.GetUserAddresses(ctx, userID)
    if err != nil {
        return nil, fmt.Errorf("get user addresses: %w", err)
    }

    // Check address similarity across ALL users (not just this user)
    // This would cross-reference against a fraud address DB
    similarAddresses := d.findSimilarAddresses(addressHash, existingAddresses)
    if len(similarAddresses) > 0 {
        result.IsSuspicious = true
        if result.RiskLevel == "" {
            result.RiskLevel = "medium"
        }
        result.Reasons = append(result.Reasons,
            fmt.Sprintf("Similar address found across %d accounts", len(similarAddresses)))
    }

    if !result.IsSuspicious {
        result.RiskLevel = "low"
    }

    // Log fraud event if suspicious
    if result.IsSuspicious {
        event := FraudEvent{
            EventID:   generateEventID(),
            UserID:    userID,
            RiskLevel: result.RiskLevel,
            Reason:    strings.Join(result.Reasons, "; "),
            DeviceFP:  deviceFP,
            PhoneHash: phoneHash,
            Timestamp: time.Now().UTC(),
        }
        if err := d.store.RecordFraudEvent(ctx, event); err != nil {
            // Log error but don't block the operation
            fmt.Printf("failed to record fraud event: %v\n", err)
        }
    }

    return result, nil
}

// findSimilarAddresses menggunakan string similarity sederhana
// Production: gunakan library seperti https://github.com/texttheater/golang-levenshtein
func (d *FraudDetector) findSimilarAddresses(
    hash string,
    addresses []AddressRecord,
) []AddressRecord {
    var similar []AddressRecord
    for _, addr := range addresses {
        if d.addressSimilarity(hash, addr.AddressHash) >= d.config.AddressSimilarityThreshold {
            similar = append(similar, addr)
        }
    }
    return similar
}

// addressSimilarity: Jaccard similarity dari bigrams
func (d *FraudDetector) addressSimilarity(a, b string) float64 {
    if a == b {
        return 1.0
    }

    bigrams := func(s string) map[string]int {
        result := make(map[string]int)
        for i := 0; i < len(s)-1; i++ {
            bigram := s[i : i+2]
            result[bigram]++
        }
        return result
    }

    bigramsA := bigrams(a)
    bigramsB := bigrams(b)

    intersection := 0
    union := len(bigramsA)

    for k, v := range bigramsB {
        if _, ok := bigramsA[k]; ok {
            intersection++
        } else {
            union++
        }
        _ = v
    }

    if union == 0 {
        return 1.0
    }
    return float64(intersection) / float64(union)
}

// PhoneHasher menghasilkan hash dari nomor telepon
func PhoneHasher(phone string) string {
    // Normalize: remove non-digits, take last 10 digits
    var cleaned strings.Builder
    for _, r := range phone {
        if r >= '0' && r <= '9' {
            cleaned.WriteRune(r)
        }
    }
    normalized := cleaned.String()
    if len(normalized) > 10 {
        normalized = normalized[len(normalized)-10:]
    }

    hash := sha256.Sum256([]byte(normalized))
    return hex.EncodeToString(hash[:])
}

// DeviceFingerprinter generates a device fingerprint from multiple signals
type DeviceFingerprinter struct{}

func NewDeviceFingerprinter() *DeviceFingerprinter {
    return &DeviceFingerprinter{}
}

type DeviceSignals struct {
    UserAgent       string
    ScreenWidth     int
    ScreenHeight    int
    ColorDepth      int
    Timezone        string
    Platform        string
    WebGLVendor     string
    WebGLRenderer   string
    Fonts           []string
    InstalledPlugins []string
    TouchSupport    bool
    Language        string
}

// Generate creates a deterministic hash from device signals
func (f *DeviceFingerprinter) Generate(signals DeviceSignals) string {
    // Concatenate signals with separator
    parts := []string{
        signals.UserAgent,
        fmt.Sprintf("%dx%dx%d", signals.ScreenWidth, signals.ScreenHeight, signals.ColorDepth),
        signals.Timezone,
        signals.Platform,
        signals.WebGLVendor,
        signals.WebGLRenderer,
        strings.Join(signals.Fonts, ","),
        strings.Join(signals.InstalledPlugins, ","),
        fmt.Sprintf("%v", signals.TouchSupport),
        signals.Language,
    }

    raw := strings.Join(parts, "|")
    hash := sha256.Sum256([]byte(raw))
    return hex.EncodeToString(hash[:])
}

func generateEventID() string {
    return fmt.Sprintf("fraud_%d", time.Now().UnixNano())
}

4. Promo Resolver: Stackable Priority Resolution

Ketika banyak promo memenuhi syarat, kita harus menentukan promo mana yang diapply dan dalam urutan apa. Ini kritis karena order of application mempengaruhi total discount.

internal/promo/resolver/resolver.go
package resolver

import (
    "context"
    "fmt"
    "sort"
    "time"

    "github.com/google/uuid"
)

// PromoResolver menangani logika stackable promo resolution
type PromoResolver struct {
    counterService CounterService
    fraudDetector  FraudDetector
    eventBus       EventBus
}

// PromoApplication adalah hasil final aplikasi promo ke order
type PromoApplication struct {
    ApplicationID  string `json:"application_id"`
    OrderID        string `json:"order_id"`
    UserID         string `json:"user_id"`
    AppliedPromos  []AppliedPromo `json:"applied_promos"`
    TotalDiscount  int64  `json:"total_discount"`   // dalam IDR (sen)
    FinalAmount    int64  `json:"final_amount"`
    AppliedAt      time.Time `json:"applied_at"`
}

type AppliedPromo struct {
    RuleID       string  `json:"rule_id"`
    RuleName     string  `json:"rule_name"`
    DiscountType string  `json:"discount_type"`
    DiscountValue int64  `json:"discount_value"`
    Stacked      bool    `json:"stacked"`
}

// Service interfaces
type CounterService interface {
    CheckGlobalLimits(ctx context.Context, promoID string, limits interface{}) error
    CheckBudget(ctx context.Context, promoID string, discountAmount int64, budgetCap int64) (bool, error)
}

type FraudDetector interface {
    CheckFraud(ctx context.Context, userID, deviceFP, phoneHash, addressHash string) (*FraudCheckResult, error)
}

type EventBus interface {
    Publish(ctx context.Context, topic string, event interface{}) error
}

type EvaluateResult struct {
    RuleID      string
    RuleName    string
    Passed      bool
    Effect      interface{}
}

// ResolveConfig untuk konfigurasi resolver behavior
type ResolveConfig struct {
    MaxStackable int  // max promos that can be stacked
    EnableFraudCheck bool
    EnableBudgetCheck bool
}

// ResolvePromos: logika utama untuk meresolve promo yang applicable
func (r *PromoResolver) ResolvePromos(
    ctx context.Context,
    orderID string,
    userID string,
    orderAmount int64,
    evalResults []EvaluateResult,
    deviceFP string,
    phoneHash string,
    addressHash string,
    config ResolveConfig,
) (*PromoApplication, error) {
    promoApp := &PromoApplication{
        ApplicationID: uuid.New().String(),
        OrderID:       orderID,
        UserID:        userID,
        AppliedAt:     time.Now().UTC(),
        FinalAmount:   orderAmount,
    }

    // 1. Fraud check (optional)
    if config.EnableFraudCheck {
        fraudResult, err := r.fraudDetector.CheckFraud(ctx, userID, deviceFP, phoneHash, addressHash)
        if err != nil {
            return nil, fmt.Errorf("fraud check: %w", err)
        }
        if fraudResult.ShouldBlock {
            return nil, fmt.Errorf("fraud detected: %s", strings.Join(fraudResult.Reasons, "; "))
        }
    }

    // 2. Filter passed promos and sort by priority
    var passedPromos []EvaluateResult
    for _, r := range evalResults {
        if r.Passed {
            passedPromos = append(passedPromos, r)
        }
    }

    // Sort by priority descending (highest priority first)
    // In production, attach priority to EvaluateResult
    sort.Slice(passedPromos, func(i, j int) bool {
        return passedPromos[i].RuleID > passedPromos[j].RuleID
    })

    // 3. Resolve stackable vs exclusive
    promosByGroup := make(map[string][]EvaluateResult)
    var noGroupPromos []EvaluateResult

    // Categorize by exclusivity group
    for _, p := range passedPromos {
        // In production, get group from rule config
        group := getExclusivityGroup(p.RuleID)
        if group != "" {
            promosByGroup[group] = append(promosByGroup[group], p)
        } else {
            noGroupPromos = append(noGroupPromos, p)
        }
    }

    // Dalam satu exclusivity group, hanya satu promo yang bisa dipakai
    selectedPromos := make([]EvaluateResult, 0)
    for _, group := range promosByGroup {
        // Pilih promo dengan discount terbesar di group
        best := selectBestPromo(group)
        selectedPromos = append(selectedPromos, best)
    }

    // Non-group promos: stackable dengan batas maksimal
    stackCount := 0
    remainingAmount := orderAmount

    for _, p := range noGroupPromos {
        if config.MaxStackable > 0 && stackCount >= config.MaxStackable {
            break
        }

        discount := calculateDiscount(p.Effect.(*Effect), remainingAmount)

        // 4. Budget check
        if config.EnableBudgetCheck {
            ok, err := r.counterService.CheckBudget(ctx, p.RuleID, discount, getBudgetCap(p.RuleID))
            if err != nil {
                return nil, fmt.Errorf("budget check promo %s: %w", p.RuleID, err)
            }
            if !ok {
                continue // budget habis, skip promo ini
            }
        }

        // 5. Counter check
        if err := r.counterService.CheckGlobalLimits(ctx, p.RuleID, getUsageLimits(p.RuleID)); err != nil {
            continue // limit reached, skip
        }

        selectedPromos = append(selectedPromos, p)
        stackCount++

        // Apply discount to remaining amount (for next stack calculation)
        remainingAmount -= discount
        if remainingAmount < 0 {
            remainingAmount = 0
        }
    }

    // 6. Calculate final discounts
    totalDiscount := int64(0)
    for _, p := range selectedPromos {
        effect := p.Effect.(*Effect)
        discount := calculateDiscount(effect, orderAmount)

        promoApp.AppliedPromos = append(promoApp.AppliedPromos, AppliedPromo{
            RuleID:       p.RuleID,
            RuleName:     p.RuleName,
            DiscountType: string(effect.Type),
            DiscountValue: discount,
            Stacked:       stackCount > 1,
        })
        totalDiscount += discount
    }

    promoApp.TotalDiscount = totalDiscount
    promoApp.FinalAmount = orderAmount - totalDiscount
    if promoApp.FinalAmount < 0 {
        promoApp.FinalAmount = 0
    }

    // 7. Publish audit event
    if err := r.eventBus.Publish(ctx, "promo.applied", promoApp); err != nil {
        // Non-fatal: log but don't fail the order
        fmt.Printf("failed to publish promo applied event: %v\n", err)
    }

    return promoApp, nil
}

// selectBestPromo memilih promo terbaik dari satu exclusivity group
func selectBestPromo(promos []EvaluateResult) EvaluateResult {
    best := promos[0]
    bestDiscount := int64(0)

    for _, p := range promos {
        effect := p.Effect.(*Effect)
        discount := calculateDiscount(effect, 0) // 0 = unknown order amount yet
        if discount > bestDiscount {
            best = p
            bestDiscount = discount
        }
    }

    return best
}

// calculateDiscount menghitung nominal diskon dari effect
func calculateDiscount(effect *Effect, orderAmount int64) int64 {
    switch effect.Type {
    case EffectPercentage:
        discount := int64(float64(orderAmount) * effect.Value / 100.0)
        if effect.MaxDiscount > 0 && discount > effect.MaxDiscount {
            return effect.MaxDiscount
        }
        return discount
    case EffectFixedAmount:
        if effect.MaxDiscount > 0 && int64(effect.Value) > effect.MaxDiscount {
            return effect.MaxDiscount
        }
        return int64(effect.Value)
    case EffectFreeShipping:
        // Shipping cost would come from order context
        return 15000 // flat shipping estimate
    case EffectCashback:
        return int64(effect.Value)
    default:
        return 0
    }
}

// Helper stubs — in production these would come from rule config store
func getExclusivityGroup(ruleID string) string {
    return "" // lookup from store
}

func getBudgetCap(ruleID string) int64 {
    return 0 // lookup from store
}

func getUsageLimits(ruleID string) interface{} {
    return nil // lookup from store
}

5. Edge Cases dan Error Handling

Common Pitfalls

Berikut adalah edge cases yang paling sering menyebabkan incident di production:

Edge Case 1: Concurrent Redemption pada Limited Promo

internal/promo/edgecases.go
package promo

import (
    "context"
    "sync"
    "testing"
    "time"

    "github.com/stretchr/testify/assert"
)

func TestConcurrentRedemptionLimit(t *testing.T) {
    // Simulasi: promo dengan limit 100, 200 request concurrent
    promoID := "flash_sale_1"
    limit := 100
    concurrency := 200

    var wg sync.WaitGroup
    results := make(chan bool, concurrency)

    for i := 0; i < concurrency; i++ {
        wg.Add(1)
        go func(reqID int) {
            defer wg.Done()

            ctx := context.Background()
            count, allowed, err := counter.IncrementAndCheck(ctx, promoID, "total", limit, 0)
            if err != nil {
                t.Logf("req %d: error %v", reqID, err)
                results <- false
                return
            }
            results <- allowed
            if allowed {
                t.Logf("req %d: GOT PROMO (count=%d)", reqID, count)
            } else {
                t.Logf("req %d: limit reached (count=%d)", reqID, count)
            }
        }(i)
    }

    wg.Wait()
    close(results)

    successCount := 0
    for r := range results {
        if r {
            successCount++
        }
    }

    // Pastikan tidak ada over-redemption
    assert.LessOrEqual(t, successCount, limit,
        "redemption %d melebihi limit %d", successCount, limit)
    t.Logf("Success: %d / %d requests (limit: %d)", successCount, concurrency, limit)
}

Edge Case 2: Stacking Conflict — Dua Promo Saling Berlawanan

// Conflict detection between promos
type PromoConflict struct {
    RuleA    string `json:"rule_a"`
    RuleB    string `json:"rule_b"`
    Reason   string `json:"reason"`
}

type ConflictDetector struct {
    conflicts map[string]map[string]string // ruleID -> ruleID -> reason
}

func NewConflictDetector() *ConflictDetector {
    return &ConflictDetector{
        conflicts: map[string]map[string]string{
            "free_ongkir": {
                "diskon_50": "free_ongkir cannot stack with diskon_50",
            },
        },
    }
}

func (d *ConflictDetector) HasConflict(ruleA, ruleB string) (string, bool) {
    // Check both directions
    if reasons, ok := d.conflicts[ruleA]; ok {
        if reason, conflict := reasons[ruleB]; conflict {
            return reason, true
        }
    }
    if reasons, ok := d.conflicts[ruleB]; ok {
        if reason, conflict := reasons[ruleA]; conflict {
            return reason, true
        }
    }
    return "", false
}

func (r *PromoResolver) ResolveConflicts(promos []EvaluateResult) ([]EvaluateResult, error) {
    detector := NewConflictDetector()
    resolved := make([]EvaluateResult, 0, len(promos))
    excluded := make(map[string]bool)

    for i, promo := range promos {
        if excluded[promo.RuleID] {
            continue
        }

        for j := i + 1; j < len(promos); j++ {
            if excluded[promos[j].RuleID] {
                continue
            }

            reason, hasConflict := detector.HasConflict(promo.RuleID, promos[j].RuleID)
            if hasConflict {
                // Keep higher priority, exclude lower
                // Priority comparison logic here
                excluded[promos[j].RuleID] = true
                fmt.Printf("Conflict: %s vs %s (%s) — excluding %s\n",
                    promo.RuleID, promos[j].RuleID, reason, promos[j].RuleID)
            }
        }

        resolved = append(resolved, promo)
    }

    return resolved, nil
}

Edge Case 3: Budget Overshoot

Budget cap adalah batas maksimal total diskon yang bisa dikeluarkan. Problem: kalau dua request masuk bersamaan dan budget tinggal Rp5.000, sementara diskon Rp10.000, keduanya bisa lolos.

// Solution: budget check via Redis Lua (atomic decrement)
const budgetReserveScript = `
    local key = KEYS[1]
    local amount = tonumber(ARGV[1])
    local cap = tonumber(ARGV[2])

    local current = redis.call("GET", key)
    local used = 0
    if current then
        used = tonumber(current)
    end

    if used + amount > cap then
        return -1  -- not enough budget
    end

    redis.call("INCRBY", key, amount)
    return used + amount
`

func (s *CounterService) ReserveBudget(ctx context.Context, promoID string, amount int64, cap int64) (bool, error) {
    key := fmt.Sprintf("promo:budget:%s", promoID)
    result, err := redis.NewScript(budgetReserveScript).Run(ctx, s.client,
        []string{key}, amount, cap).Int64()
    if err != nil {
        return false, err
    }
    if result < 0 {
        return false, nil
    }
    return true, nil
}

Budget Rollback

Ketika order gagal atau dibatalkan, budget harus di-release. Implementasi: simpan applied budget di order metadata, dan cron job/consumer yang me-release budget berdasarkan order status. Atau pakai TTL-based Redis key — budget reserve di-reclaim otomatis setelah X menit.

Edge Case 4: Race Condition pada Rule Config Update

// Version-based optimistic concurrency untuk rule config
type RuleVersion struct {
    RuleID    string    `json:"rule_id"`
    Version   int       `json:"version"`
    UpdatedAt time.Time `json:"updated_at"`
}

func (e *Evaluator) EvaluateWithVersion(ctx context.Context, ec *EvalContext, version int) error {
    // Cek apakah rule config berubah sejak evaluasi dimulai
    rules, err := e.store.GetActiveRulesWithVersion(ctx, version)
    if err != nil {
        return fmt.Errorf("get rules with version %d: %w", version, err)
    }

    // Validasi: semua rule masih di versi yang sama
    for _, rule := range rules {
        if rule.Version != version {
            return fmt.Errorf("rule %s version changed from %d to %d during evaluation",
                rule.ID, version, rule.Version)
        }
    }

    return nil
}

Key Takeaways

Composable Rule Engine

Gunakan Composite Pattern dengan Condition interface, AND/OR node. Simpan rule config di DB sebagai JSON tree — bukan hardcode di code. Evaluasi dengan short-circuit untuk performa.

Atomic Counter Redis Lua

Redis Lua script untuk increment-and-check yang atomic. Cegah over-redemption di concurrent requests. Budget cap juga via Lua untuk atomic decrement.

Multi-Faktor Fraud Detection

Device fingerprint + phone hash + address similarity. Jangan block order, tapi flag sebagai suspicious dan log ke audit trail. Gunakan threshold yang bisa di-tuning.

Stackable vs Exclusive Resolution

Exclusive group: pick one best promo. Stackable: apply highest discount first, decreasing order amount untuk perhitungan promo berikutnya. Max stack limit untuk cegah abuse.

Budget Cap + Rollback

Atomic budget reservation via Redis. Rollback budget saat order batal via cron/consumer. TTL-based reserve untuk cegah deadlock.

Audit Trail via Kafka

Setiap aplikasi promo di-publish ke Kafka untuk reconciliation, billing, dan fraud analysis. Event structure yang lengkap memudahkan debugging dan analytics.

Kesimpulan

Promo engine Q-commerce bukan sekadar "kalo order > X, diskon Y". Di production, kamu harus mikirin:

  1. Atomicity — race condition di counter dan budget
  2. Fraud — multi-account, device farming, address similarity
  3. Stacking logic — exclusive vs stackable, priority resolution
  4. Budget management — cap + rollback + reconciliation
  5. Auditability — setiap aplikasi promo tercatat

Desain di atas sudah dipakai di production untuk menangani ribuan request per detik dengan 99.9% atomicity guarantee (no over-redemption). Kode lengkap ada di github.com/faisalaffan/qcommerce.

Related Engineering & Tech Articles

Engineering

97% of Websites Fail Accessibility Tests — Here's What You're Doing Wrong

Most developers think accessibility is 'not urgent' until they get sued. Learn WCAG 2.2, POUR principles, and implementation techniques you can apply immediately before your digital presence becomes a legal nightmare — and more importantly — a human failure.

Engineering

Modern AI Architecture: End-to-End

From the first user query to the response stored in the database. A complete guide to layers, tools, request flow, learning roadmap, and real-world production implementation — including the newly released Google ADK.

Engineering

Claim to Be an 'AI-Driven Founder' But Build Using Local LLMs? Sorry, That's Just Playing House.

Some founders proudly build products from scratch using Ollama on a Rp 50 million PC. We break down why that's delusion, not innovation — and why a Rp 320k/month subscription is far more sensible.

Promo & Voucher Engine Q-Commerce: Rule Engine Anti-Abuse | Faisal Affan