Manual vs auto payments

1) Conceptual frame

Auto payments - decisions to "pass/reject/escalate" are made automatically based on rules and scoring, sending to the corridor is carried out without the participation of the operator.

Manual payments - human verification (Fin. operator/risk analyst) confirms or cancels the request before sending/after return.

2) Mode selection criteria

When auto is the default

Same-method & return-to-source met.
ND ≥ 0 (no negative net deposits).
KYC level ≥ L1, no active RG locks.
Risk rate <threshold, no geo-conflicts (IP≈KYC≈SIM).
Sum of the pre-approved threshold ≤ for the segment.
Method/corridor - instantaneous/reliable with low return.
No fresh chargeback/abuse signals.

When "manual" is the default

SoF/SoW required (threshold/signal).
POP/Sank Phase (fuzzy hits) or controversial documents.
GEO conflict, suspected multi-account/household.
Velocity/amount anomalies (many applications, large amount).
Conclusion to a new prop without history.
FX arbitration scenarios, non-standard corridors (SWIFT).
Any rule exceptions and returns with unclear cause.

3) Pros/cons

4) Hybrid pipeline architecture

1. Pre-checks: same-method, ND, RG/KYC, sanctions.
2. Risk scoring: payment/device/behavior/geo/fx signs.
3. Decisioner: 'AUTO _ PASS/ MANUAL_REVIEW/DENY'.
4. Queues: manual queue with SLA priorities, auto-router to the corridor.
5. Orchestration: selection of the corridor (instant → fast → standard) by cost/ETA/limits.
6. Treasury/FX: pre-funding, pool limits, slippage guards.
7. Reconciliation: statuses, returns/reverses, re-rooting/refand.
8. Observability: timelines, p95/p99, backlog, breach alerts.

5) Policies (pseudo-DSL)

yaml policy: "payouts_auto_manual_v2"
eligibility:
same_method: true nd_min: 0 kyc_min: L1 routing:
cascade:
- corridor: "INSTANT" when: risk_score < 0. 5 and amount <= preapproved_limit
- corridor: "FAST_A2A" when: risk_score < 0. 65
- corridor: "STANDARD_SEPA" when: else manual_review:
triggers:
- risk_score >= 0. 65
- geo_conflict_score >= 2
- new_beneficiary == true and amount > new_beneficiary_cap
- sanctions_fuzzy_hit == true
- velocity_24h_payouts > 3 or amount_24h > segment_cap
- returns_last_30d >= 1 deny:
rules:
- self_excluded == true
- nd_total < 0 and allow_nd_withdrawal == false limits:
preapproved_limit:
LOW_RISK: {EUR: 2000}
MID_RISK: {EUR: 500}
sla:
auto_p95_minutes: 30 manual_p95_hours: 8 audit:
store_decision_tree: true store_feature_snapshot: true

6) Manual check queues and priorities

1. Senior amounts with expiring SLAs.

2. Same-method & ND≥0 (quick release upon confirmation).

3. Multi-tickets of one player (lower churn/appeals).

4. Instant corridors with network degradation (fast hang-up or resolution).

5. The rest.

Queue management SLA: target p95 of solution '≤ 4-8 hours' (license/market-dependent).

Tools: auto-sub-collection of documents, checklists, answer macros, "Approve with note," "Partial release."

7) UX and Communications

Auto-branch: show ETA and statuses ("Initiated," "Credited").
Manual branch: honestly tell the expected window (threshold) and what is needed (list of documents/checks).
Escalation: notifications when leaving the SLA, a proposal to change the method (if it does not violate the same-method/ND).
Details history: marked "verified" recipient for future auto payments.

8) Data model

sql payout. timeline (
payout_id PK, user_id, amount_minor BIGINT, currency TEXT,
method TEXT, corridor TEXT, provider TEXT, iso2 TEXT,
nd_snapshot NUMERIC, same_method_ok BOOLEAN,
risk_score NUMERIC, decision TEXT, -- AUTO_PASS    MANUAL    DENY reason_codes TEXT[], reviewer TEXT,
t_request TIMESTAMP, t_precheck_ok TIMESTAMP, t_risk_ok TIMESTAMP,
t_decided TIMESTAMP, t_initiated TIMESTAMP, t_posted TIMESTAMP, t_available TIMESTAMP,
status TEXT, meta JSONB
);

review. queue (
ticket_id PK, payout_id FK, priority INT, state TEXT, assignee TEXT,
created_at TIMESTAMP, picked_at TIMESTAMP, resolved_at TIMESTAMP, sla_deadline TIMESTAMP
);

risk. features_snapshot (
payout_id FK, payload JSONB, created_at TIMESTAMP
);

9) SQL templates

9. 1. Share of auto/manual/failures and their TTW

sql
SELECT decision,
COUNT() AS cnt,
100. 0 COUNT() / SUM(COUNT()) OVER () AS share_pct,
PERCENTILE_CONT(0. 95) WITHIN GROUP (ORDER BY EXTRACT(EPOCH FROM (COALESCE(t_available, t_decided) - t_request))) AS p95_sec
FROM payout. timeline
WHERE t_request BETWEEN:from AND:to
GROUP BY decision;

9. 2. Manual Queue Backlog and SLA Delays

sql
SELECT
COUNT() FILTER (WHERE state='OPEN') AS open_tickets,
COUNT() FILTER (WHERE sla_deadline < now() AND state IN ('OPEN','IN_PROGRESS')) AS sla_breaches
FROM review. queue;

9. 3. Auto payments - breach along the corridors

sql
SELECT corridor,
100. 0 COUNT() FILTER (WHERE EXTRACT(EPOCH FROM (t_available - t_request)) >:p95_target_sec) / NULLIF(COUNT(),0) AS breach_pct
FROM payout. timeline
WHERE decision='AUTO_PASS' AND status='SUCCESS'
AND t_request BETWEEN:from AND:to
GROUP BY 1 ORDER BY breach_pct DESC;

9. 4. Manual → Allowed Conversion

sql
SELECT
100. 0 COUNT() FILTER (WHERE status IN ('SUCCESS','INITIATED')) / NULLIF(COUNT(),0) AS manual_approve_rate
FROM payout. timeline
WHERE decision='MANUAL' AND t_decided BETWEEN:from AND:to;

10) Metrics and dashboards

Auto-rate%: share of payments in the auto-line.
Manual approve %/deny%, manual p95 TAT (decision time).
TTW p95/p99 по decision/corridor/provider/geo.
SLA-breach% (auto and manual).
Returns/Reverse% and share of repayments after return.
Cost per payout along branches and corridors.
ND <0 share among applications.
Queue health: open, in-progress, breaks, average wait.
Complaint/1k payouts and CSAT vs mode.

11) Alerts

Manual backlog spike: 'open _ tickets'> threshold or 'manual p95 TAT'> SLA.
Auto p95 breach on corridor/provider.
Returns surge by code/bank/geo.
ND negative spike in applications.
Policy drift: payments without a fixed solution/feature snapshot.
New beneficial risk: high proportion of manual on new recipients.

12) Incident playbooks

A. Hand surge (inhibits TTW)

1. Include pre-approval for low-risk segments up to X sum.
2. Increase the capacity of the review (long-day, move the shift).
3. Temporarily raise the risk_score threshold for MANUAL in safe GEO/methods.

B. Auto corridor degradation (p95↑/returns↑)

1. Cascade to alternative corridor, reduce limit per-txn.
2. Update ETA users, PSP ticket/bank.
3. Post-mortem: adjust routing weights.

C. Wave returns for new props

1. Auto-block "new" recipients before manual confirmation.
2. Offer the player a saved verified prop/source.

3. Auto-refund to game wallet and CTA "choose method."

13) Economics and trade-offs

Auto reduces the cost of the operating system and increases CSAT/retention, but requires investment in scoring/rules/telemetry.
Manual ones are more expensive, but reduce rare large losses and are important for regulatory protection.
We are looking for a balance point: maximum cars for low-risk segments and instant corridors; manual - for edge cases.

14) A/B tests

Thresholds' risk _ score ', pre-approval limits, priority of corridors in the cascade.
Copyright and ETA for manual branch.
Guardrails: Returns %, CBR bps, manual p95 TAT, CSAT, Complaints/1k.

15) Best practices (short)

1. Default-auto for ND≥0, same-method, KYC L1 +, low amounts and verified details.
2. Policy-as-code + feature/decision logging, reproducibility.
3. Cascade of corridors on cost/ETA/health, auto-failover.
4. SLA priority queues and checklists for the operator.
5. Transparent ETAs and statuses for both branches.
6. Pre-funding/pool limits, FX guards.
7. p95/p99 metrics and tail/return/backlog alerts.
8. Post-incidents and regular scoring/rule tuning.

16) Implementation checklist

• AUTO/MANUAL/DENY and versioning trigger matrix.
• Scoring and "pre-approval" limits by segment.
• Same-method/ND/KYC/RG/sanctions in pre-checks.
• Queues and priorities, SLAs and roles.
• Cascades of corridors and health-feed, failover.
• Data model and timelines, snapshots of feature/solutions.
• Dashboards and alerts by TTW/SLA/returns/backlog.
• Playbooks: degradation, wave of returns, growth of manual.
• A/B and Return/CB Data Freeze
• Regular license/policy compliance audits.

Summary

"Manual vs auto-payments" - not an either-or choice, but a stratified system: auto - for predictable safe scenarios with strong telemetry; manual - for narrow, risky and regulatory sensitive cases. Formalize the rules as code, measure p95/p99 and backlog, keep cascades of corridors and transparent ETAs - and you will receive fast, reliable and economically sustainable payments.