Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How Monzo Scaled Its Core Banking Platform
Transcript
- Lucas: So Monzo just crossed five million customers in the UK, and I keep thinking about how they got there. Because it wasn't just about a nice app. The real story is how they rebuilt their entire core banking platform while regulators were watching. Luna: That sounds like a nightmare. You're moving money and data around, and the FCA is basically breathing down your neck. Lucas: Exactly. And they did it in a way that a lot of banks are still trying to figure out. They went all in on microservices before it was cool, and they did it from day one. But the path wasn't clean. There were a lot of bumps. Lucas: Let's start with the early days. Monzo launched as a prepaid card in 2015. The original architecture was a monolith. A single Ruby on Rails app. That's fine for a startup with a few thousand users. But they knew that wasn't going to scale. Luna: Right, so they had to make the jump early. What was the catalyst? Lucas: The big moment was when they decided to apply for a full banking license. That's when the regulatory requirements kicked in. They needed to support features like direct debits, Faster Payments, and real-time balance updates. The monolith was already showing cracks, and they knew they couldn't bolt that on. Luna: So they chose microservices. But that's not a silver bullet. What was their approach? Lucas: They didn't just split it arbitrarily. They identified the core domains: accounts, transactions, payments, and so on. Each becomes its own service with its own database. And they were strict about ownership. The payments service owns all payment data, period. Luna: That sounds clean, but what about the hard parts? Like, how do you keep data consistent across services? Lucas: That's where it gets interesting. They used an event-driven approach. Every service publishes events, and other services subscribe to them. So when a transaction happens, the accounts service updates the balance, and it publishes an event that the ledger service picks up. That way, you don't have distributed transactions. You have eventual consistency. Luna: But eventual consistency in banking? That sounds risky. What if a customer checks their balance and it's not up to date? Lucas: They handle that with a mix of strategies. For most reads, they use a read model that's updated via these events. But for something like a balance check, they can read from the source of truth if they need to. It's a trade-off, but they've built a system that's fast and accurate enough for the vast majority of cases. Lucas: And they learned the hard way that you can't just sprinkle microservices everywhere. They had a few services that were too chatty. They were making thousands of calls per second to each other, and that just kills performance. So they had to refactor again, merging some services back. Luna: So it's not a one-way street. You go microservices, then you realize some things should be together. Lucas: Right. And that's a normal part of the process. The key is to have good boundaries and to know when to break them. Monzo's team is pretty open about how they've iterated. Luna: Now, you mentioned the platform part. They opened up their APIs to third parties. That's a whole different beast. Lucas: Yeah, that was a big strategic move. They launched what they call the Monzo API, allowing developers to build apps on top of their banking platform. So you can have a budgeting app that reads your transactions, or a savings app that moves money around. That's banking as a platform. Luna: But how do you do that without compromising security? The API is essentially a door into their core. Lucas: They use OAuth 2.0 for authorization, and they scope the access. So a third-party app can only see what the customer explicitly grants. And they have a review process for apps before they're published. But the real challenge is that you're now exposing your platform to external developers, and you can't control how they use it. Lucas: One of the things that surprised me was the operational cost. Running a public API means you have to think about rate limiting, versioning, and backward compatibility. You can't just change an endpoint and break every app that depends on it. Luna: That's a classic platform trade-off. You get the ecosystem, but you give up the freedom to move fast. Lucas: Exactly. And they've had to strike that balance. They maintain a stable API version, and they deprecate things slowly. It's a lot of overhead, but it's the cost of being a platform player. Luna: Let's talk about the regulatory side. How did they manage to get their architecture approved by the regulators? I imagine the FCA wants to see some kind of control. Lucas: It's not like they submit a diagram and get a thumbs up. Regulators care about outcomes. They want to see that you can manage risk, that you have proper audit trails, and that you can isolate failures. Monzo had to demonstrate that their microservices could handle that. For example, they have to be able to trace any transaction back to the source, which means their event logs have to be comprehensive. Lucas: They also had to prove that the system is resilient. If one service goes down, it shouldn't take down the whole bank. That's a core principle in their design. They use circuit breakers and bulkheads to isolate failures. Luna: So it's not just about writing code. You have to think about how you operate it and how you demonstrate that to regulators. Lucas: Right. And that's something a lot of engineers overlook. It's the operational maturity that matters. Monzo has put a lot of effort into monitoring and alerting. They have a dedicated engineering team that works on what they call 'banking reliability.' Luna: That's interesting. Because a lot of podcasts talk about the cool tech, but not the boring stuff like reliability. And that's what actually keeps the lights on. Lucas: Absolutely. And that's a thread we keep coming back to on this show. The boring stuff is often the most important. Whether it's a bank or a social media app, you need that foundation. Luna: It's funny you mention that. Because thinking about the listeners who are building their own platforms, the same principles apply. You need to invest in the unglamorous parts, or the whole thing falls apart. Lucas: Yeah. And that's actually why we love doing this show. We get to talk to people who are solving these problems, and we get to share it with you. If you find these conversations useful for what you're building or running, there's a way to keep it going. You can support the show at buy me a coffee dot com slash fexingo. It's a small gesture, but it helps us keep the episodes ad-free and focused on the engineering. Luna: Yeah, and we really appreciate that. It lets us dig into these deep topics without worrying about sponsors. Lucas: And we're not done with Monzo yet. I want to talk about how they handled the transition from monolith to microservices, because it wasn't a big bang. They did it incrementally, using a strangler pattern. Luna: Oh, that's the classic approach. You gradually replace pieces of the monolith with new services. Lucas: Exactly. They started by extracting the transaction service, then the account service, and so on. Each step, they made sure everything still worked. It took them over a year, but they did it without a major outage. That's a testament to their engineering discipline. Luna: So what's next for Monzo? Are they going to expand the platform further? Lucas: I think so. They're already a bank, but they want to be the infrastructure for other financial products. They have a business account, and they're opening up more APIs. The vision is that you can build an entire fintech on top of Monzo. Luna: That's ambitious. But they've proven they have the technical chops. What's the biggest challenge they'll face? Lucas: I'd say it's the same challenge every platform faces: balancing control and openness. You want to give developers freedom, but you also have to protect the bank. And as they grow, they'll have to deal with more regulatory scrutiny. But if anyone can do it, it's a team that has been through the fire. Luna: Well, it's been a great look under the hood. Any final thoughts? Lucas: Just that Monzo's story shows that you don't need to be a giant bank to innovate. You need a clear architecture, a willingness to iterate, and a focus on what matters: keeping the system up and the customers happy. That's a lesson we can all take away.