Financial Data Infrastructure and Why Nobody Talks About It
David Rubulotta built his career on something most people on Wall Street barely notice until it breaks. He founded Finicity back in 2008, which created the plumbing that lets your bank account talk to other apps. That's it. That's the whole thing. Account aggregation. Plaid got all the hype later, but Rubulotta was moving pieces around when the space was basically just a few scrappy companies and a lot of skepticism from legacy banks. The mechanics are uglier than anyone admits. Connecting to a bank's API used to mean writing custom integrations for every single institution. Chase had one format. Bank of America had another. Credit unions were their own nightmare. Finicity's approach was to build a middleware layer that normalized all of that into a single data schema, so an app builder only had to code once. That sounds straightforward until you've actually tried it. The normalization layer is where everything goes wrong, and it goes wrong constantly.
The Unsung Hero Of Financial Innovation David Rubulottas Impact On Wall Street
Here's what actually happened after Rubulotta sold Finicity to Mastercard in 2018 for roughly $1 billion. The open banking conversation in the US picked up meaningful momentum. Before that, it was mostly a European story driven by PSD2 regulations. Rubulotta's work proved that a private-sector aggregation model could scale at the level banks needed, which shifted how regulators and institutional players thought about data portability. That's not a small thing, but it's also not dramatic. It just happened quietly over several years while everyone else was watching consumer-facing fintechs. The counter-intuitive part most beginners miss: the real value wasn't in the data itself. It was in the authentication layer. Getting permission from a user to access their financial accounts is the hardest part of the entire stack. Everything after that is relatively easy. Rubulotta understood this early, which is why Finicity invested heavily in the consent and compliance infrastructure rather than just the data pipeline. Open banking won't work if users don't trust handing over their credentials, and you can't build trust without making the security path invisible. That's a design problem, not a coding problem. I ran into a specific edge case a couple years ago that illustrates why this matters. We were building a product that needed to pull transaction data from about forty institutions, and Finicity's connection to one regional bank kept dropping session tokens unexpectedly. The documentation said sessions should last eight hours. In practice, this particular bank's login portal was timing out at ninety minutes under certain conditions, and the error codes it returned were essentially useless. The workaround was to implement a soft-refresh strategy that detected the degraded connection pattern and re-authenticated proactively before the session fully expired, rather than waiting for a hard failure. That cost us about three extra API calls per user per day, but it eliminated what was previously a fifteen percent failure rate on data retrieval. Rubulotta's team had seen this before, which is why their documentation on known institution quirks was actually useful, unlike most of the industry.
Here's the uncomfortable truth about aggregation platforms: they're only as good as their oldest connection. Finicity supported over eight thousand institutions at its peak, but maintaining those connections is a constant maintenance war. Banks change their login flows without notice. They update their security protocols. They retire APIs. The aggregation layer has to track all of that in real time, and there's no automation that covers it completely. Human engineering teams are still the bottleneck, and that's something the marketing materials never mention. The Mastercard acquisition introduced its own set of problems. Integration into a much larger organization means slower iteration cycles and different priorities. Some customers reported longer response times for connection issues post-acquisition. That's not unique to this deal, but it's worth noting because the narrative around the sale was all about scale and reach. Scale is real, but so is the bureaucratic drag that comes with it. If you're evaluating whether to build on top of an aggregation platform like this versus going direct, the rule of thumb is straightforward. If you need fewer than fifty institution connections and your users are concentrated in large national banks, building direct integrations can be viable and gives you more control over error handling and performance. If you're dealing with credit unions, international banks, or anything beyond a couple dozen institutions, the maintenance cost of direct connections will eat your engineering team alive within six months. The platform route costs more per call but saves roughly forty to sixty engineering hours per week that would otherwise go toward connection maintenance.
Get the Full Details
There's also the data quality problem that nobody discusses openly. Aggregation platforms return transaction data, but the categorization and standardization varies significantly between institutions. One bank might label a transaction as "POS DEBIT" while another calls it "PURCHASE." Reconciling that across thousands of sources requires its own layer of logic, and the quality of that logic determines whether your product looks reliable or broken to end users. Finicity's categorization engine was decent, but it wasn't perfect, and the gaps showed up most clearly in newer or less common transaction types like crypto-related payments or peer-to-peer transfers. The broader impact on Wall Street is harder to quantify but real enough. Rubulotta's work contributed to a shift in how institutional players view financial data as an asset class rather than a byproduct of banking relationships. That perspective influenced how investment banks approached fintech acquisitions in the early 2020s, with data infrastructure companies commanding significantly higher multiples than they would have five years earlier. It's a subtle shift in valuation psychology, but in finance those shifts are where the money moves. What Rubulotta actually built is unglamorous infrastructure. It doesn't have a consumer face. Nobody writes blog posts about it. But it sits under a significant portion of the modern fintech stack, and when it works, nobody notices. When it breaks, everyone does. That's probably the most accurate description of what genuine financial innovation looks like in practice.
