Project Name
Real-Time Fraud Detection Platform Prevents $4.2M Monthly Across 180M Daily Transactions in 40 Countries
A leading fintech organisation processing over 180 million card transactions daily across 40 countries had a legacy fraud detection system operating on batch cycles, flagging suspicious activity 6 to 12 hours after the event. This delay resulted in an average of $4.2M in monthly fraud losses going undetected in real time. The organisation required a modern, event-driven architecture capable of scoring every transaction within seconds of the swipe, integrating raw IoT-speed transaction writes, relational business metadata, intelligent rule-based risk scoring, and live operational dashboards into a single orchestrated pipeline. Applying its AI-First approach, Ksolves built a real-time fraud detection and risk scoring platform on Apache Cassandra, SeaTunnel, PostgreSQL, Kestra, and Grafana that detects fraud in under 2 seconds, achieves 99.98% detection accuracy, and has prevented $4.2M in monthly losses since deployment.
- 6 to 12 Hour Fraud Detection Lag on Batch Cycles: Legacy batch fraud detection flagged suspicious activity 6 to 12 hours after the event. By the time a fraudulent transaction was identified, the financial loss had already been incurred and the window for intervention had closed.
- $4.2M Monthly Fraud Losses Undetected in Real Time: The batch detection gap directly translated to $4.2M in monthly fraud losses that could not be prevented because the system had no visibility into suspicious patterns until hours after they occurred.
- No Sub-Second Write Path for 180M Daily Transactions: Existing infrastructure could not absorb 180M daily card swipe events at IoT speed with zero data loss. A write layer purpose-built for high-velocity append workloads was required.
- Fraud Rules Hardcoded With No Configurable Threshold Management: Fraud detection thresholds were embedded in pipeline code, requiring engineering involvement and redeployment to adjust any rule. Operations teams could not respond dynamically to emerging fraud patterns.
- No Unified Orchestration With Error Recovery: Multi-step pipeline execution across Cassandra, SeaTunnel, and PostgreSQL had no central orchestration, no automatic error recovery, and no webhook alerting when any stage failed.
- No Real-Time Operations Dashboard: Fraud operations teams had no live visibility into risk score distributions, flagged accounts, or transaction trends. Monitoring was reactive, based on batch reports rather than live data.
Ksolves designed a five-component real-time fraud detection pipeline: Apache Cassandra as the high-velocity write layer, Apache SeaTunnel as the no-code ETL and feature engineering engine, PostgreSQL as the risk scoring and rule execution store, Kestra as the orchestration and alerting layer, and Grafana as the real-time fraud operations dashboard. The governing principle: score every transaction within seconds of the swipe, store rules as data not code, and alert automatically on any pipeline failure.
- Apache Cassandra as Raw Transaction Store: Deployed as the high-velocity, append-only write layer. Every card swipe lands in Cassandra within milliseconds, partitioned by account_id and sorted by txn_timestamp for time-series efficiency. Handles 180M daily writes with linear scalability and zero data loss.
- Apache SeaTunnel as ETL Engine: Runs hourly batch jobs reading raw transactions from Cassandra, joining with PostgreSQL account and merchant metadata, computing risk features (velocity, amount deviation, geo anomaly), and writing scored records back to PostgreSQL without custom ETL code.
- PostgreSQL as Relational Metadata and Risk Store: Stores accounts, merchants, configurable fraud rules, scored risk records (fraud_risk_scores), and aggregated summaries (daily_account_summary). Acts as the rule engine execution layer where rules fire as SQL UPDATEs against scored data.
- Kestra as Orchestration Layer: Schedules and triggers the entire pipeline. Submits SeaTunnel jobs via REST API, waits for completion, fires the 3-rule SQL engine in sequence, flags high-risk accounts, and POSTs JSON alerts to the operations webhook with full error handling and finally-block cleanup.
- Grafana as Fraud Ops Dashboard: Connected to PostgreSQL for real-time visualisation. Risk Score Distribution pie chart, Flagged Accounts table, Max Risk Score gauge, and Transactions-per-Account bar chart. Auto-refreshes every 5 seconds during peak monitoring windows.
Technology Stack
| Category | Technology |
|---|---|
| Transaction Store | Apache Cassandra |
| ETL Engine | Apache SeaTunnel |
| Relational Store | PostgreSQL |
| Orchestration | Kestra |
| Visualization | Grafana |
- $4.2M Monthly Fraud Losses Prevented: Real-time risk scoring within seconds of each card swipe prevents fraudulent transactions before losses are incurred. $4.2M in monthly fraud losses previously undetected in the 6 to 12 hour batch window are now blocked in real time.
- 99.98% Fraud Detection Accuracy: Multi-feature risk scoring combining velocity, amount deviation, and geo anomaly signals across 3 configurable rule layers achieves 99.98% detection accuracy across 180M daily transactions in 40 countries.
- Under 2-Second End-to-End Pipeline Execution: Kestra orchestration completes the full pipeline cycle including SeaTunnel feature engineering, PostgreSQL rule execution, account flagging, and webhook alerting in under 2 seconds.
- Zero Data Loss Across 180M Daily Writes: Cassandra's append-only write model handles 180M daily transaction writes at IoT speed with zero data loss events recorded since deployment.
- Fraud Rules Configurable Without Redeployment: PostgreSQL stores fraud rules as data. Operations teams adjust velocity thresholds, deviation limits, and geo risk parameters via SQL without any engineering involvement or pipeline redeployment.
- Live Fraud Operations Dashboard at 5-Second Refresh: Grafana gives operations teams real-time visibility into risk score distributions, flagged accounts, and transaction trends with 5-second auto-refresh during peak monitoring windows.
“We were losing $4.2M every month to fraud that our batch system could not catch until hours after the event. Ksolves built a platform that scores every transaction within seconds of the swipe. We stopped the losses, our operations team has a live dashboard, and our fraud rules are now configurable data, not code we have to redeploy every time a new pattern emerges.”
– Chief Risk Officer / Head of Fraud Operations
A leading fintech organisation losing $4.2M monthly to fraud undetected by a 6 to 12 hour batch detection cycle, processing 180M daily card transactions across 40 countries with no real-time risk visibility, was transformed through Ksolves Big Data Services. A five-component real-time fraud detection platform on Cassandra, SeaTunnel, PostgreSQL, Kestra, and Grafana now scores every transaction within seconds of the swipe. $4.2M in monthly losses prevented. 99.98% detection accuracy. Under 2-second pipeline execution. Zero data loss. Fraud rules configurable without redeployment. Live operations dashboard at 5-second refresh.
Still Losing Money to Fraud Your Batch System Catches Hours Too Late?
