Our client was a leading European banking institution, implementing SEPA payments and processing massive volumes of transfers every day. They operated under strict regulatory oversight and required live compliance checks to ensure that every transaction followed EU standards.

In this regard, the bank needed a high-throughput solution that could integrate into their core payment pipelines, as well as maintain full auditability, zero downtime, and the ability to scale horizontally during peak transaction periods.

• Strict and evolving EU regulations requiring compliance checks for every single transfer.

• Extremely high throughput demands, reaching tens of thousands of SEPA requests per second (a "heavy load" even for the largest EU banks).

• The need for zero downtime processing, since any interruption in payment pipelines may result in massive financial penalties.

• Granular analysis of large batch files, where each transfer must be screened individually without losing batch-level context.

To fulfil all the requirements of the project, we defined the following goals:

• Automate ALR/AML compliance checks for instant SEPA payments.

• Categorize transactions into Accepted, Suspicious, and Manual Review flows.

• Integrate into bank core processing pipelines without introducing significant latency.

• Use sharding and horizontal scaling to handle peak loads (e.g., end-of-month salary runs).

• Provide reliable message storage and searchability for audit trails and regulatory reporting.

• Implement an active-active high availability architecture with no single point of failure.

We built a high-throughput financial middleware platform based on stream processing and distributed messaging. Apache Kafka handled reliable ingestion and queueing, allowing the system to process massive SEPA flows without message loss.

SEPA messages and processing results were stored in sharded MongoDB, which enabled horizontal scaling, high-concurrency writes, and fast lookups for auditing and regulatory reporting.

The infrastructure ran in an active-active configuration to eliminate single points of failure and ensure uninterrupted processing during outages or maintenance.

The result represented a high-availability financial middleware solution that could operate directly inside SEPA payment pipelines. It intercepted large incoming SEPA batches, split them into individual transfers, and performed automated regulatory checks on both transaction-level messages and the batch as a whole.

Each payment was classified as Accepted, Suspicious, or requiring Manual Review, guaranteeing that only compliant transactions were forwarded for execution.

Key Features

• Batch splitting and transaction-level parsing of SEPA files with context-aware re-assembly of validated transfers.

• Automated tri-state compliance classification into Accepted, Suspicious, and Manual flows.

• Live message ingestion and queueing powered by Apache Kafka.

• Active-active high-availability infrastructure complying with DORA standards.

• Low-latency compliance checks optimized for tens of thousands of requests per second.

• Fintech Systems Architect: Designed the SEPA processing model and ISO 20022 compliance approach.

• Distributed Systems Engineers: Implemented Kafka-based ingestion and tuned active-active synchronization.

• NoSQL Database Expert: Built MongoDB sharding strategy and optimized high-concurrency storage.

• Compliance & Regulatory Logic Developers: Developed ALR/AML rule sets and transaction classification logic.