Rebuilding the engine behind a bank's payments, on technology the bank controls.
A multinational banking group needed to extend payments across currencies, channels, and markets faster than a proprietary engine allowed. rinf.tech contributed to building a new payment engine, written in Scala on Akka and Kafka. The design is event-driven, so the bank could add markets without waiting on a vendor's roadmap.
The engine runs across multiple geographies, part of a wider body of work spanning business banking, lending, retail digital, and internal applications.
A multinational banking and financial services group processes payments across currencies, channels, and markets, under strict security and regulatory requirements. An engine at that scale has to connect to many systems and reach new markets regularly. A proprietary, tightly coupled engine makes each extension slow, and ties the bank to one vendor's pace.
rinf.tech contributed to building a new payment engine on Scala, Akka, and Kafka, running on the Java Virtual Machine (JVM). The design is event-driven. Payments move as messages, processed asynchronously, so the engine scales with volume and connects directly to the bank's systems.
The result is a payment engine the bank controls, running across multiple geographies with monitoring, alerting, and CRM integration. Extending it to a new currency or channel is a change the bank's own teams can make, not a request to a vendor.
Payment engine architecture
Payments flow as messages through Kafka, processed asynchronously in Scala on Akka's actor model.
A core the bank controls
Built on Scala, Akka, and Kafka rather than a proprietary payment package, so extensions do not wait on a vendor.
Payments across geographies
One engine serving multiple markets, with monitoring, alerting, and integration into the bank's CRM.
The constraint was the engine underneath
A bank can redesign its customer-facing app in a few months. The engine that moves the money underneath is the harder problem. It has to clear payments in many currencies, through many channels, across many markets, and integrate with the systems each of those depends on. And it has to be exact: a payment processed twice, lost, or applied out of order is a financial error, not a cosmetic one. Correctness, ordering, and recovery from failure are the baseline, before a single new market is added.
When that engine is a proprietary package, every extension runs through the vendor. Adding a currency, a channel, or a market means waiting on a roadmap the bank does not set. In a heavily regulated environment, where integration and security are checked closely, that dependency is a constraint on how fast the bank can move.
- Built, not bought. The engine is developed on a stack the bank runs and can modify, rather than a closed vendor product.
- Interoperable and reusable. It integrates with the bank's many systems, and its parts can be reused across products rather than rebuilt each time.
- Scales with volume. Processing grows with payment load, instead of being sized for a single fixed peak.
- Fits a regulated environment. The build is designed to meet the bank's security standards for development and integration.
A payment engine built to extend
The engine is event-driven. Rather than a synchronous chain, where each step waits for the one before it to finish, a payment enters as a message and moves through the system as a sequence of events. This lets the engine scale with volume and stay loosely coupled to the systems around it. It also gives the engine a durable, ordered record of every payment event, which is what recovery and reconciliation depend on after a failure.
# 01 — Ingest
A payment request enters as a message on Kafka from a channel (mobile banking, internet banking, or a business-banking system), rather than as a direct call into the engine.
# 02 — Process
Scala services on the JVM consume the message. Akka's actor model handles concurrent payments without shared-state locking, so load spreads across the system instead of queuing behind one bottleneck.
# 03 — Route across markets
The engine applies the rules for the currency, channel, and geography, and integrates with the systems each market requires. A new market means new configuration, handled by the same engine.
# 04 — Monitor and report
Processing is monitored with alerting on failures, and payment events feed CRM modules, so the state of a payment is visible to the teams who handle customers.
The engine is written in Scala on the JVM, with Akka for concurrency and Kafka as the messaging layer, and runs on cloud infrastructure. These are specialized skills, and the engine was delivered by a team established around them. Alongside the engine, rinf.tech contributed across the bank's wider set of systems. That work included the internal application suite used by front office, back office, call center, and internet banking; new features for the mobile banking app; and client onboarding and review processes, with test automation in Selenium and Cucumber supporting it.
Built inside the bank's own teams
rinf.tech worked within the bank's organization across several business areas, embedded in its delivery teams. The payment engine was the most demanding piece, developed to the bank's security and integration standards in a regulated environment.
What the architecture gives the bank
A payment engine the bank controls.
Built in-house rather than bought as a proprietary package, so extending it to a new currency, channel, or market is a change the bank's teams can make themselves.
Payments across multiple geographies from one engine.
The same engine serves multiple markets, with monitoring, alerting, and CRM integration, rather than a separate system per market.
Headroom under load.
Event-driven processing on Kafka, with Akka handling concurrency, scales horizontally as volume grows, instead of being sized for a fixed peak.
Reuse across products.
Because the engine is loosely coupled and modular, its parts can be reused as the bank adds products, rather than rebuilt each time.
Rebuilding the core beneath the surface
Modernizing a bank's payments reaches the engine underneath the app, where the money actually moves. Doing that on a custom, event-driven stack gives the bank an engine it governs: one it can extend to new markets, scale with volume, and integrate across its systems, without a vendor setting the pace.
For banks whose payment processing is the constraint on reaching new markets, this is what rebuilding the core in-house looks like.
- Industry
- Banking & financial services (multinational institution)
- Client
- Anonymized at its request
- Engagement type
- Mixed delivery teams, within the client's organization
- Core build
- Event-driven payment engine (Scala, Akka, Kafka on the JVM)
- Wider scope
- Internal app suite, mobile banking, onboarding, test automation
- Status
- In production across multiple geographies, ongoing