Operational IT systems are designed to make our lives better. They stand between the user and day-to-day business operations and are mission-critical in industries like healthcare, transportation, retail, and finance. For example, they’re what enables a doctor to look up a patient’s medical records or check the inventory for a particular drug. 

When it comes to financial technologies—also known as FinTech—these operational systems are heavily relied on in many high-stakes scenarios. Real-time stock trading, peer-to-peer payments, investment apps, and crypto price trackers are just some use cases where timely, accurate data are of the essence. 

This is the first post in a series all about building event-driven microservices for FinTech with Redpanda. The next posts will cover five architectural guidelines for FinTech systems, and a practical FinTech use case you can follow along.  

To start, let’s get into the challenges of FinTech operational systems, the benefits of an event-driven microservices architecture, and a quick intro to how Redpanda simplifies streaming data in FinTech systems.

The challenges of FinTech operational systems

To make sure we’re all on the same page, FinTech is defined as the “use of new technologies to improve and automate traditional forms of finance”. For example, instead of physically going to a bank, you can use Paypal or Stripe to send a payment in a blink.    

This means operational systems in the FinTech domain—in particular—need to be fast, accurate, safe, and reliable. Errors in these systems can result in significant financial losses to both consumers and businesses. So if you’re looking to design, build, and maintain FinTech operational systems—you’ll want to consider the following: 

• Need for speed: Unlike other business verticals, speed matters the most in FinTech. Payment processing and stock trading applications demand ultra-low latency, typically in the millisecond range, to stay profitable and competitive in the market. 

• Ability to scale (and quickly): FinTech systems are typically used by trillions of daily users worldwide, like an e-commerce payment processing system, for example. This introduces the need for these systems to withstand (and rapidly accommodate) traffic of massive scale while also delivering consistently low latency.

• Accuracy: Transactions need to be accurate or they’re essentially useless. If there’s a failure, you need to have solid strategies in place to roll back the system to the last-known good state.

• Safety and reliability: People want to know their data is safe with you. If your system isn’t available when they need it or loses any of their data, you might as well turn off the lights. FinTech systems need to be highly available and quickly recover from failures—without data loss.

The architecture under the hood can make or break your FinTech operational system. This is where event-driven microservices step in.

The benefits of event-driven microservices for FinTech

Microservices are widely used for structuring operational systems since they break up monolithic applications into smaller, easier-to-manage services that can be handled independently. 

When you combine microservices with an event-driven architecture, you get the perfect foundation for building real-time systems that are reliable, easily scalable, and flexible enough to keep up with changes. They're particularly useful for rapidly-changing businesses like banks, stock traders, and payment processing systems.

In an event-driven architecture, event streams flow from their producers to consumers in real time, allowing consumers to process events as they come in, opening the door to immediate analysis, insights, and responses. In short, this architecture comes with three main benefits:

• Improved reliability: Interactions are asynchronous, eliminating the need for consumers to be always available at the time of event production. Consumers receive and process events at any time at their own pace.

• Loosely coupled: Event producers and consumers are unaware of each other. They share common knowledge about the event broker, but aside from that, they’re loosely coupled.

• Highly available: Asynchrony and loose coupling significantly increase the availability of the overall system. If a consuming system crashes, it can be repaired, brought back online, and resume operations without affecting the rest. Moreover, different systems can be maintained and evolve independently of each other.

So now you have the right architecture for the job—but what about a platform that can handle real-time data streams?

Traditionally, Kafka was one of the most trusted and well-known streaming data (or event streaming) platforms. Sadly, it simply can’t keep up with today’s super high data demands or get the most performance out of modern hardware. This makes Kafka slow, complex, and expensive as you scale, which leads to higher costs (and extremely stressed engineers). This begs the question: what can you use instead?

Meet Redpanda

Redpanda is an event streaming platform for developers built from the ground up in C++ as a drop-in replacement for Apache Kafka®. Built on the Kafka protocol, Redpanda delivers low-latency, high-throughput streaming data processing, making it ideal for building real-time applications and event-driven architectures. 

Its lean architecture eliminates external dependencies (like JVM and Apache ZooKeeper™), and is essentially a lighter, faster, simpler-to-operate Kafka that squeezes the most out of your resources—without sacrificing your data’s reliability or durability. 

Furthermore, since Redpanda is built with the native Kafka API you can simply switch them out and instantly leverage a more cost-efficient, high-throughput streaming data platform. In fact, Aklivity did precisely that to simplify a P2P payments application using a CQRS architecture.

Make life easier: build event-driven microservice architectures with Redpanda

Redpanda fits into an event-driven architecture as an event broker, helping you secure reliable and scalable communication between your microservices so you can achieve the speed, accuracy, and safety needed for FinTech solutions.

Here’s a quick dip into the benefits:

• Low-latency, high-throughput data ingestion: Redpanda effortlessly handles high-volume, high-velocity event streams thanks to its thread per core architecture, which ensures the highest throughput with the lowest possible latency, no matter where it’s deployed (on-prem, cloud, edge).  

• Fault-tolerant and highly available event storage: Redpanda uses cloud-first storage and a Raft architecture to ensure zero data loss, improve data safety, and high availability at scale. (It's also Jepsen-verified!)

• Lightweight and cost-efficient: Redpanda's hardware-efficient design consumes 3x lower compute resources on average, and its Tiered Storage optimizes the cost efficiency of data retention so you scale without breaking the bank on escalating infrastructure and storage costs.

And that's just scratching the surface. We'll dig deeper into the nuts and bolts of Redpanda later in this series.

Keep an eye out for our next post where we'll cover five best practices when building an event-driven microservices architecture. In the meantime, you’re welcome to try Redpanda yourself and join the Redpanda Community on Slack to chat with our team about your specific FinTech use case.