The 0.99% Fee Model: Zero Monthly Fees

pythondef calculate_fee(transaction_amount: Decimal, source_currency: str) -> Decimal:
    """Calculate the 0fee platform fee for a transaction."""
    FEE_RATE = Decimal("0.0099")

    # Convert to USD for fee calculation
    usd_amount = convert_to_usd(transaction_amount, source_currency)

    # Fee in USD
    fee = usd_amount * FEE_RATE

    return fee.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)

Transaction: 10,000 XOF
USD equivalent: 10,000 x 0.0016 = $16.00
Fee: $16.00 x 0.0099 = $0.1584
Fee rounded: $0.16

1st of month  --> Invoice generated for previous month
5th of month  --> Payment due date
6th-10th      --> Grace period (warnings sent)
10th of month --> Suspension if unpaid

pythonasync def generate_monthly_invoices():
    """Generate invoices for all active apps on the 1st of the month."""
    previous_month_start = get_first_day_of_previous_month()
    previous_month_end = get_last_day_of_previous_month()

    apps = await get_active_apps()

    for app in apps:
        transactions = await get_completed_transactions(
            app_id=app.id,
            start_date=previous_month_start,
            end_date=previous_month_end
        )

        if not transactions:
            continue  # No invoice for zero-activity months

        total_fees = sum(tx.platform_fee_usd for tx in transactions)

        invoice = PlatformInvoice(
            app_id=app.id,
            user_id=app.user_id,
            period_start=previous_month_start,
            period_end=previous_month_end,
            transaction_count=len(transactions),
            total_transaction_volume_usd=sum(tx.amount_usd for tx in transactions),
            total_fees_usd=total_fees,
            status="pending",
            due_date=get_fifth_of_current_month(),
            generated_at=datetime.utcnow()
        )

        await save_invoice(invoice)
        await send_invoice_email(app.user, invoice)

sqlCREATE TABLE platform_invoices (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    app_id UUID NOT NULL REFERENCES apps(id),
    user_id UUID NOT NULL REFERENCES users(id),
    period_start DATE NOT NULL,
    period_end DATE NOT NULL,
    transaction_count INTEGER NOT NULL DEFAULT 0,
    total_transaction_volume_usd DECIMAL(12, 2) NOT NULL DEFAULT 0,
    total_fees_usd DECIMAL(10, 2) NOT NULL DEFAULT 0,
    status VARCHAR(20) NOT NULL DEFAULT 'pending',
    -- pending, paid, overdue, suspended
    due_date DATE NOT NULL,
    paid_at TIMESTAMP,
    generated_at TIMESTAMP NOT NULL DEFAULT NOW(),
    created_at TIMESTAMP NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);

CREATE INDEX idx_platform_invoices_app ON platform_invoices(app_id);
CREATE INDEX idx_platform_invoices_status ON platform_invoices(status);
CREATE INDEX idx_platform_invoices_due ON platform_invoices(due_date);

pythonasync def process_refund(transaction_id: str):
    """Refund a transaction and reverse the platform fee."""
    transaction = await get_transaction(transaction_id)

    if transaction.status != "completed":
        raise ValueError("Can only refund completed transactions")

    # Refund via provider
    refund_result = await provider_refund(transaction)

    if refund_result.success:
        # Reverse the platform fee
        transaction.status = "refunded"
        transaction.refunded_at = datetime.utcnow()

        # Credit the fee back to the merchant's balance
        await adjust_balance(
            app_id=transaction.app_id,
            amount=transaction.platform_fee_usd,
            type="fee_reversal",
            reference=f"Refund of {transaction.reference}"
        )

        await save_transaction(transaction)

python# No balance check before processing
# The fee is accrued, not deducted in real-time
async def record_transaction_fee(transaction: Transaction):
    """Record the platform fee -- no balance check required."""
    fee = calculate_fee(transaction.amount, transaction.source_currency)

    transaction.platform_fee_usd = fee

    # Accrue to the merchant's running balance
    await update_running_balance(
        app_id=transaction.app_id,
        fee_amount=fee
    )

Customer pays:       25,000 XOF via Orange Money CI
Provider fee:        Included in provider settlement (not our concern)
Merchant receives:   25,000 XOF (full amount from provider)

0fee platform fee:
  25,000 XOF x 0.0016 = $40.00 USD equivalent
  $40.00 x 0.0099 = $0.396
  Rounded: $0.40

Accrued to monthly invoice: $0.40

Total volume:    500 x 25,000 XOF = 12,500,000 XOF (~$20,000)
Total fees:      500 x $0.40 = $200.00
Invoice amount:  $200.00
Due:             5th of next month

pythonfrom decimal import Decimal, ROUND_HALF_UP

# WRONG: floating point
fee = 40.00 * 0.0099  # 0.396000000000000003...

# RIGHT: Decimal
fee = Decimal("40.00") * Decimal("0.0099")  # 0.3960 exactly
fee = fee.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)  # 0.40

typescriptfunction formatFee(feeUsd: number, displayCurrency: string): string {
  if (displayCurrency === 'USD') {
    return `$${feeUsd.toFixed(2)}`;
  }

  const converted = feeUsd / conversionRates[displayCurrency];
  const symbol = currencySymbols[displayCurrency];

  // Zero-decimal currencies show no decimal places
  if (ZERO_DECIMAL_CURRENCIES.has(displayCurrency)) {
    return `${symbol}${Math.round(converted).toLocaleString()}`;
  }

  return `${symbol}${converted.toFixed(2)}`;
}

json{
  "invoice_id": "inv_2026_02_app123_001",
  "period": "February 2026",
  "app": "My Boutique",
  "line_items": [
    {
      "description": "Transaction fees (487 transactions)",
      "volume_usd": 18750.00,
      "rate": "0.99%",
      "amount": 185.63
    },
    {
      "description": "Fee reversal (3 refunds)",
      "amount": -1.17
    }
  ],
  "total_usd": 184.46,
  "due_date": "2026-03-05",
  "status": "pending"
}