Jonathan Lalou's Blog

Posts Tagged ‘Fintech’

Lecturer

Sudeep Kalindi is a Principal Solution Architect at Amazon Web Services (AWS), where he focuses on building scalable AI and machine learning solutions for the global financial services industry. With a deep expertise in high-frequency transaction systems and cloud infrastructure, Sudeep advises major financial institutions on modernizing their fraud detection and personalization engines using advanced neural network architectures.

Pahal Patangia is the Global Head of Business for the Payments Industry at NVIDIA. He has spent nearly five years at NVIDIA accelerating the adoption of AI and accelerated computing within the payments ecosystem. Pahal works closely with banks, fintechs, and payment processors to deploy large-scale foundation models that transform transactional data into real-time business value.

Abstract

As digital transactions explode in volume and complexity, traditional rule-based and machine learning models are reaching their limits in combating sophisticated fraud and providing personalized customer experiences. This article examines the emergence of transformer-based foundation models as the “next frontier” for financial systems. Unlike prior models that treated transactions as isolated events, transformers excel at capturing long-term dependencies and sequential patterns in tabular transactional data. The discussion details the technical advantages of “attention” mechanisms in finance, the role of NVIDIA’s accelerated computing in training these massive models, and the deployment strategies on AWS that enable real-time inference. By integrating tabular foundation models with Graph Neural Networks (GNNs), financial institutions can achieve unprecedented accuracy in fraud detection and customer behavioral analysis.

The Evolution of Payment Systems: Beyond Rule-Based Models

The world of digital transactions has undergone a massive expansion, with billions of events flowing through systems daily via credit cards, QR codes, contactless payments, and cross-border transfers. This explosion in volume has been matched by an increase in the complexity of financial crime. Fraudsters now leverage generative AI and chatbots to simulate synthetic identities and execute complex, multi-stage attacks.

Historically, payment systems relied on rules-based engines or traditional machine learning models (such as Gradient Boosted Trees) that analyzed data in a “flat” or non-sequential manner. While effective for basic anomalies, these systems often fail to resolve the deep contextual history of a customer. They may miss the subtle shift in behavior that signals a compromised account because they lack the “memory” to connect transactions across long periods. The industry’s challenge is to find a middle way: leveraging the cutting-edge innovation of deep learning while maintaining the explainability and governance required by global financial regulators.

Transformers for Tabular and Sequential Financial Data

The primary innovation discussed is the application of the transformer architecture—originally designed for Natural Language Processing (NLP)—to tabular financial data. Transformers introduce the “attention” mechanism, which allows a model to weigh the importance of different parts of a transaction sequence differently.

In a financial context, this means the model can distinguish between a user’s stable, long-term habits and their recent, potentially anomalous interests. For instance, if a customer who has lived in the same city for ten years suddenly makes a high-value purchase in a foreign country, a transformer can analyze the sequence leading up to that event—looking for “warm-up” transactions or patterns indicative of travel—rather than just flagging the high dollar amount.

Key technical advantages include:

• Contextual Understanding: Transformers treat the entire transaction history of an entity (customer, merchant, or card) as a sequence, similar to a sentence in a language model.
• Solving Vanishing Gradients: Unlike Recurrent Neural Networks (RNNs), transformers can capture long-range dependencies without the performance degradation typically associated with long sequences.
• Multi-Modal Integration: They can blend different data “worlds”—such as event logs, clickstream data, and structured transaction records—into a single global embedding that provides a 360-degree view of an entity.

NVIDIA Accelerated Computing in Financial AI Factories

The training and deployment of these large-scale foundation models require immense computational power, a concept referred to as the “AI Factory.” NVIDIA’s accelerated computing platform is the engine behind these factories, providing the necessary throughput for processing millions of transactions in real time.

NVIDIA’s contribution extends beyond hardware (GPUs like the H100 and Blackwell) to specialized software frameworks. For example, the use of the NVIDIA AI Enterprise suite on AWS allows for efficient tuning and scaling of these models. Furthermore, the integration of Graph Neural Networks (GNNs) with transformers allows systems to not only understand the sequence of transactions but also the relationships between different entities (e.g., shared IP addresses or common merchants among fraudulent accounts). This combined approach enables “pattern mining” at a scale previously thought impossible.

Code Sample: Conceptual Transformer Layer for Transaction Sequences

import torch
import torch.nn as nn

class TransactionTransformer(nn.Module):
    def __init__(self, input_dim, embed_dim, num_heads, num_layers):
        super(TransactionTransformer, self).__init__()
        '''Project tabular transaction features into an embedding space'''
        self.embedding = nn.Linear(input_dim, embed_dim)

        '''Transformer Encoder Layer to capture sequential dependencies'''
        encoder_layer = nn.TransformerEncoderLayer(d_model=embed_dim, nhead=num_heads)
        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)

        '''Output layer for fraud classification (binary: 0 or 1)'''
        self.classifier = nn.Linear(embed_dim, 1)

    def forward(self, x):
        '''# x shape: [batch_size, sequence_length, input_dim]'''
        x = self.embedding(x)
        x = x.permute(1, 0, 2) # Transformer expects [seq_len, batch, embed]
        output = self.transformer(x)
        logits = self.classifier(output[-1]) # Use the last transaction's context
        return torch.sigmoid(logits)

print("Financial Transformer initialized for sequential analysis.")

Real-Time Fraud Detection and Personalized Banking

The ultimate goal of deploying these models on AWS is to move from reactive fraud detection to proactive prevention and hyper-personalization. By leveraging Amazon SageMaker, financial institutions can run “target experiments” and deploy models into a secure, scalable production environment.

The business impact is multifaceted:

1. Reduced False Positives: By understanding context, models can reduce the number of legitimate transactions being declined, improving customer satisfaction.
2. Authorization and Routing Optimization: Real-time insights allow for smarter routing of transactions through payment networks, reducing costs and increasing success rates.
3. Hyper-Personalization: Beyond fraud, these models understand customer intent, allowing banks to offer relevant products and services at the precise moment of need.

While it is still early in the adoption cycle, initial experiments show performance improvements in the range of 1% to 2% in fraud detection accuracy—a seemingly small number that translates into billions of dollars in saved revenue across the global economy.

Conclusion

The intersection of transformer architectures, NVIDIA’s accelerated computing, and AWS’s scalable infrastructure is redefining what is possible in financial services. By treating transaction data as a language to be understood rather than a set of rows to be filtered, the industry is building a more secure and personalized future for global payments. As these “global embeddings” continue to evolve, they will ultimately provide a comprehensive context for every customer, product, and entity in the financial ecosystem.

Links:

• NVIDIA Financial Services Solutions
• AWS Financial Services Cloud
• NVIDIA and AWS Partnership

Lecturer

Jordan Miller is a Staff Software Engineer at Nubank, where she is a core member of the Datomic team, specifically focusing on developer success and the evolution of the database product. Jordan is a prominent figure in the Clojure community, serving as the co-founder of Clojure Camp, a co-author of Clojure Brain Teasers, and the producer/host of the Lost In Lambduhhs podcast. Her professional background is marked by a deep passion for functional programming and a commitment to making complex technical systems accessible to a wider audience.

Abstract

Since its acquisition by Nubank in 2020, Datomic has transitioned from a specialized tool for discerning architects to the foundational storage layer of one of the world’s largest independent banks. This article explores the symbiotic relationship between Nubank’s mission to simplify banking and Datomic’s philosophy of data-driven simplicity. We analyze the technical challenges of scaling Datomic to serve over 114 million customers, focusing on innovations such as “implicit partitions” and the architectural shifts required to maintain a global-scale financial system. Furthermore, we examine how the “Datomic-as-a-Service” model within Nubank empowers thousands of developers to build resilient, high-performance microservices while maintaining the lowest cost-to-serve in the banking industry.

Simplicity as a Mission: The Nubank and Datomic Alignment

The acquisition of Cognitect (the creators of Clojure and Datomic) by Nubank was more than a corporate transaction; it was a meeting of shared values. Nubank was founded with the explicit goal of reducing the extreme complexity and high costs of the Brazilian banking sector. At the time, millions of Brazilians were unbanked, and interest rates for personal loans often exceeded 100% per year. Nubank sought to disrupt this by building a bank that was digital-first, customer-centric, and architecturally simple.
Datomic, with its focus on immutability, “database-as-a-value,” and the separation of reads from writes, provided the perfect technical backbone for this mission. Jordan highlights that the alignment on “simplicity” allowed the partnership to flourish. Today, Nubank serves 114.3 million users with an 83% activity rate, largely fueled by word-of-mouth referrals. The bank’s ability to scale rapidly while maintaining the lowest cost-to-serve globally is a direct consequence of an architecture that prioritizes developer productivity and system reliability through Datomic.

Architectural Innovation: Scaling the Immutable Store

Scaling a database to handle the needs of over 100 million customers requires rethinking traditional storage patterns. Within Nubank, Datomic is not just a database; it is a managed service provided to over 3,000 developers working across 1,000 microservices. This “Datomic-as-a-Service” (DaaS) model ensures that individual product teams do not need to worry about provisioning or maintaining their own database clusters.
A key innovation discussed by Jordan is the concept of implicit partitions. In standard Datomic, partitions are a way to group related data for better locality and performance. However, as the number of services and the volume of data grew at Nubank, manual partition management became a bottleneck. The Datomic team developed implicit partitions to automate this process, allowing the system to handle massive growth without manual intervention. This technical advancement is part of a broader effort to make Datomic “invisible” to the developer, allowing them to focus on business logic rather than storage mechanics.

The Power of “Database-as-a-Value”

The fundamental innovation of Datomic—treating the database as an immutable value—is what enables Nubank’s high-scale operations. In a traditional SQL database, “the” database is a moving target that changes with every update. In Datomic, a process can take a “snapshot” of the database at a specific point in time and perform complex queries against that static value. This eliminates many of the concurrency issues found in traditional systems and makes it trivial to implement features like “time-travel” auditing, which is critical for financial compliance.

Developer Success and the Future of Datomic

Jordan’s role at Nubank emphasizes that the success of a technology is as much about the people using it as it is about the code itself. The Datomic team at Nubank is committed to “Developer Success,” which involves building tools, documentation, and a culture that helps engineers leverage the database effectively. This includes the creation of a “Datomic Workshop” and active engagement with the Clojure community to ensure that Datomic continues to evolve as a world-class product.
The results of this focus are evident in Nubank’s operational efficiency. By providing a unified, simple, and powerful storage abstraction, Nubank has managed to grow by an average of 13 million customers per year since 2015 while keeping its infrastructure costs significantly lower than traditional banks. This demonstrates that functional programming and immutable databases are not just academic curiosities but are viable, high-performance solutions for the world’s most demanding financial environments.

Links:

• Jordan Miller on LinkedIn
• Nubank Official Website
• Datomic Official Website
• Watch the Lecture: Datomic at Nubank

The journey to unified mobile applications is a complex one, fraught with technical and organizational challenges. Rodrigo Sicarelli, a staff software engineer at StoneCo, a leading Latin American fintech company, shared a compelling real-world account of his company’s two-year transition to Kotlin Multiplatform (KMP). This exploration revealed the strategic decisions, hurdles, and impressive achievements that led to a remarkable 55% code sharing across two large-scale mobile applications.

The initial challenge for StoneCo was to evaluate various cross-platform frameworks to find one that could balance the efficiency of code sharing with the critical need for a seamless user experience in the financial sector. Rodrigo detailed the exhaustive process of assessment and the ultimate decision to adopt KMP, a choice that promised to unify their mobile development efforts. A key part of the journey was the organizational shift, which involved training 130 mobile engineers to embrace a new paradigm. Rodrigo emphasized that this was not merely a technical migration but a cultural and educational one, fostering a collaborative spirit and promoting knowledge sharing across teams.

As the adoption matured, the teams faced a number of technical hurdles. One of the primary challenges was ensuring consistent data models and a unified network layer. Rodrigo outlined how they tackled this by consolidating data sources and creating a shared codebase for networking logic, which streamlined development and reduced errors. Another significant obstacle was the integration of KMP into their iOS CI/CD pipeline. He provided a clear explanation of how they overcame this by creating custom Gradle tasks and optimizing their build process, which dramatically improved build times. He also touched upon the importance of addressing the specific needs of iOS developers, particularly concerning the generation of idiomatic Swift APIs from the shared Kotlin code.

A major win for the team was the development of a custom Gradle plugin to manage Kotlin Multiplatform dependencies. This innovation was designed to solve a problem with exposing external libraries to Swift, where the linker would sometimes struggle with duplicate symbols. By adding annotations, the team was able to improve the linking process and reduce build times. This solution not only streamlined their internal workflow but is also planned for open-sourcing, showcasing StoneCo’s commitment to giving back to the community.

Rodrigo concluded by looking to the future, outlining a vision for a single, unified application repository that is user-segment-aware and built with Compose Multiplatform. This forward-looking approach demonstrates a long-term commitment to KMP and a desire to continue pushing the boundaries of shared code. His talk provided invaluable, actionable insights for any organization considering or already in the process of scaling Kotlin Multiplatform.

Links:

• StoneCo website
• Two Years with Kotlin Multiplatform: From Zero to 55% Shared Code | Rodrigo Sicarelli