Pricing Trends

Rate applies to the entire balance based on the tier reached. Once a client crosses a threshold, the new rate is paid on the full deposit — creating strong step-change incentives but exposing banks to cliff-effect margin compression.

if balance >= TIER_3.min:
    rate = TIER_3.rate          // entire balance
elif balance >= TIER_2.min:
    rate = TIER_2.rate
else:
    rate = BASE_RATE
interest = balance * rate
// Client at $4.9M adds $100K → rate jumps to next tier on ALL $5M

Each balance slice has its own rate; the effective rate is the weighted average across all tiers. Smoother than bracketing and avoids cliff effects at tier boundaries — and significantly cheaper for the bank on large balances.

slice_1 = min(balance, T1.cap) * T1.rate
slice_2 = clamp(balance - T1.cap, T2.cap) * T2.rate
slice_3 = max(balance - T2.cap, 0) * T3.rate
total_interest = slice_1 + slice_2 + slice_3
effective_rate = total_interest / balance
// $4M balance: 60% cheaper for bank vs bracketing at same tier rates

The existing balance rate is frozen at the agreed level; only incremental balance above the lock baseline is renegotiated. Protects the client's installed base during repricing cycles and enables banks to negotiate only on new money.

base_balance = 2_000_000        // frozen at existing rate: 3%
new_balance  = 3_000_000        // renegotiated at: 5%
base_interest = base_balance * 0.03
new_interest  = new_balance * 0.05
total = base_interest + new_interest
// Client keeps existing rate. Bank negotiates only the increment.

Rate agreement has a hard end date; on expiry the system auto-reverts to the base structure. Used to manage promotional pricing and time-boxed exceptions such as dividend accumulation periods or year-end liquidity spikes.

structure.start_date = today
structure.end_date   = today + 120_days
if today <= end_date:
    rate = promotional_rate     // 6%
else:
    rate = base_structure()     // auto-revert, no manual action
// Today most banks: someone has to remember. The engine: scheduled date.

Structure applies to a consolidated balance across multiple accounts or legal entities. Lets corporate groups benefit from total scale rather than per-account balances. Advanced form is Notional Pooling — virtual aggregation without physical fund movement.

group_balance = entity_A + entity_B + entity_C
              = 1.5M + 2.0M + 1.0M = 4.5M
rate = tier_lookup(group_balance)   // all entities get the group rate
// Physical sweep: funds move. Notional pool: funds stay, interest optimized.

Balance generates non-cash credits that offset treasury management fees. Deposits are classified as non-interest-bearing (NIB) on bank financials — a better funding quality metric — while the client effectively pays zero fees from their balance.

monthly_credit = avg_balance * ECR * (days / 365)
               = 100_000_000 * 0.0325 * (30/365)
               = 267_123                 // MXN of credits generated
tm_fees_due    = 200_000
net_to_client  = max(0, tm_fees_due - monthly_credit)   // = 0
// Bank books as NIB: better KPI. Client pays zero fees in cash.

Rate is adjusted based on the hour funds arrive. Money deposited before 10am can be invested by Treasury for the full day — it is worth more. Funds arriving after 3pm go to the central bank overnight at near-zero yield — worth less.

if arrival_time < 10:00:
    rate = base_rate + 15bps     // Treasury invests all day
elif arrival_time < 15:00:
    rate = base_rate             // standard
else:
    rate = base_rate - 14bps     // only overnight central bank
// Rule is fully automatic. No human decision at execution time.
// Parametrizable per client — not all clients accept this structure.

Rate is not fixed — it is tied to a market benchmark plus a negotiated spread. The client negotiates TIIE+50bps, not a fixed 3.5%. When the benchmark moves, the rate adjusts automatically. Eliminates constant renegotiation cycles and is increasingly required by sophisticated corporate treasurers.

rate = benchmark_rate + spread
     = TIIE_28d + 50bps
     = 7.00%    + 0.50%   = 7.50%
// Next month Banxico cuts: TIIE → 6.50%
// Rate auto-adjusts: 6.50% + 0.50% = 7.00% (no renegotiation)
// MX benchmark: TIIE 28d  |  US: SOFR  |  EUR: €STR  |  UK: SONIA

Deposit rate reflects total relationship value — loans, FX, cash management, payroll, tenure, product breadth. A client with deposits only receives one rate. A client who also has active loans and runs 5,000 transactions per month receives another. Systematizes the intuitive reciprocity that today is done manually by RMs.

relationship_score = f(
    deposits, loans, fx_volume,
    tm_fees, tenure_years, product_count
)
deposit_rate = base_rate - relationship_discount(score)
// McKinsey: full relationship clients generate 20% more ROE
// Q2: clients report 1x higher NIB deposit growth vs peers

Not all balances of equal size carry equal funding value. A balance that oscillates between $50M and $150M cannot be invested with the same certainty as one stable at $100M. The engine calculates historical standard deviation and applies an FTP penalty — reducing the maximum rate that can be offered without destroying margin.

volatility = stddev(daily_balance, lookback=90_days)
if volatility < 0.05:
    ftp_adjustment = 0bps         // stable: full FTP
elif volatility < 0.15:
    ftp_adjustment = -10bps       // medium volatility
else:
    ftp_adjustment = -50bps       // high volatility
effective_ftp = base_ftp + ftp_adjustment
max_rate = effective_ftp - min_margin
// Oliver Wyman: up to 80bps real value difference for same nominal balance

Non-maturity deposits are priced using a modeled duration derived from the client's behavioral history, not the contract terms. A client with 8 years of stable $50M balances has a behavioral tenor of 3 years — Treasury can invest that money at the 3-year curve rate and pay higher FTP to the business, enabling better client rates without margin destruction.

behavioral_tenor = model(
    balance_history, stability_score,
    client_tenure, volatility_percentile
)
// Client A: demand deposit, 5yr stable → tenor = 3yr  → FTP = curve[3yr]
// Client B: demand deposit, high rotation → tenor = 30d → FTP = overnight
// Oliver Wyman: 100% difference in tenor between same-contract segments
// Translates to: 80bps difference in real deposit value

Premium rate is unlocked retroactively only if the client reaches a target balance within a defined window. Converts the rate negotiation into a bilateral performance contract — the client earns the premium only by delivering the promised balance growth.

base_rate  = 3.5%        // applies regardless
target     = 5_000_000   // client commits to reach in 90 days
bonus_rate = 4.5%        // retroactive if target met
if final_balance >= target:
    rate = bonus_rate    // applied to full period retroactively
else:
    rate = base_rate     // no premium, no penalty
// Aligns incentives: client earns premium only if bank gains real volume

Rate varies based on the channel through which funds arrive. Digital portal investments cost the bank zero operationally and can be processed faster — rewarded with better rates. Funds arriving via RM phone call or branch involve human cost and slower processing — standard rate. Natural extension of intraday pricing logic applied to the how, not just the when.

if channel == "digital_portal":
    rate = base_rate + 10bps
elif channel == "rm_call":
    rate = base_rate
elif channel == "branch":
    rate = base_rate - 5bps
// Simon-Kucher 2026: "channel pricing emerging as growth lever"
// Southeast Asia and digital-first banks are the current pioneers

Rate baseline differs by client industry before any individual negotiation begins. Government and education sectors are structurally more stable depositors — worth more to Treasury. Manufacturing and retail are more volatile. The benchmarks give the pricing desk an objective anchor instead of pure intuition.

industry_adjustment = {
    "government":    -20bps,    // highly stable → better FTP
    "education":     -15bps,
    "fin_services":  +10bps,    // rate-sensitive → higher cost
    "manufacturing": +15bps,    // volatile → lower value
    "retail":        +12bps
}
base_rate = market_rate + industry_adjustment[client.industry]
// PCBB 2025 benchmarks: real observed data across US commercial banks

Rate adjusted based on where outflows go. Funds that leave to suppliers with accounts at the same bank, or to employee payroll accounts at the same institution, create network value — that client is worth more than one whose funds all exit to competitors. No major platform has systematized this structure yet.

ecosystem_score = outflows_to_same_bank / total_outflows
// 70% of client outflows stay in-bank ecosystem
rate_multiplier = 1 + (ecosystem_score * ecosystem_premium)
effective_rate  = base_rate * rate_multiplier
// Requires integration with Cash Management transaction data
// Data already exists in the bank — just not connected to pricing engine

Structure adapts to the client's monthly cash cycle — payroll dates, receivables peaks, supplier payment windows. If the client always has liquidity peaks on days 1 and 15, the engine offers better rates on those specific days to capture the surplus without paying that premium rate for the full month.

client_cycle = analyze_transaction_history(client_id, months=12)
peak_days    = client_cycle.recurring_high_balance_days   // [1, 2, 15, 16]
rate_schedule = {
    day: base_rate + peak_premium if day in peak_days else base_rate
    for day in range(1, 32)
}
// Requires Cash Management transaction data integration
// Extension of intraday pricing logic applied at monthly cycle level

The system proactively detects when a client is at churn risk or has untapped liquidity potential, and automatically triggers a personalized rate offer before the client starts shopping competitors. Shifts deposit pricing from reactive negotiation to proactive retention.

triggers = [
    balance_dropped_15pct_in_30_days,   // → retention offer
    td_matures_in_7_days,               // → renewal offer
    large_inflow_detected,              // → investment offer
    competitor_raised_rates,            // → defensive offer
]
for trigger in active_triggers:
    offer = model.generate_offer(client, trigger, market_data)
    notify_rm(offer)                    // RM receives pre-calculated proposal
// Curinos One (May 2026): one bank generated $1.6B incremental deposits

The pricing structure offered today is designed based on the predicted future balance trajectory over the next 30/60/90 days. If the model predicts the client will receive dividend payments next month, the engine structures today's offer to capture that incoming liquidity before the client considers alternatives.

forecast = model.predict_balance(client_id, horizon=[30, 60, 90])
// forecast[30] = 8_500_000  (high confidence: dividend incoming)
// forecast[60] = 3_000_000  (returns to base)
structure = design_structure_for_forecast(forecast)
// Offer today: growth incentive targeting $8M in 30 days
// If client hits target → earns premium. Bank captures the dividend.

When deposits exceed Treasury's efficient deployment capacity, the FTP for the excess drops to zero or turns negative. The engine reflects this limit as zero or negative rate for the excess tranche — relevant in low-rate cycles or when a bank has excess liquidity that cannot be invested at acceptable yields.

treasury_efficient_capacity = 10_000_000_000   // $10B
if balance <= capacity:
    ftp = standard_ftp_curve(tenor)
else:
    excess = balance - capacity
    ftp_on_excess = 0           // or negative: Treasury can't use it
// Bank cannot profitably pay any rate on the excess tranche
// Relevant in excess-liquidity cycles (post-2020, rate cut environments)