Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How Monzo Keeps Its Banking App Running Like a Startup
Transcript
- Lucas: If these conversations are useful for what you're building or running, that's exactly why we do them. We deliberately don't run ads on this show, and we want to keep it that way. If you want to support that choice, the link is buy me a coffee dot com slash fexingo. Luna: Yeah, it's a small thing that makes a big difference for us. Keeps the show completely listener-supported. Lucas: Alright, so today I want to talk about Monzo. Specifically, how they've managed to keep their engineering velocity high even as they crossed nine million customers. Most digital banks slow down as they scale. Monzo… hasn't. Luna: Is it the architecture, or the culture? I've heard both. Lucas: It's both, but the architecture enables the culture. Monzo is built on event sourcing and CQRS—command query responsibility segregation. That's not unique in fintech, but the way they apply it is. They keep their core ledger extremely simple. Every transaction is an event, and the ledger is just an append-only log. Luna: So no updating balances in place? It's all replay? Lucas: Exactly. Your balance is computed by replaying all events up to that point. That sounds slow, but with projections—materialised views—they cache the state. So reads are fast, writes are simple, and there's never a conflict because you're only appending. Luna: I worked at a fintech that tried event sourcing and we hit a wall with schema evolution. How does Monzo handle changing the event structure over time? Lucas: They version every event. So old events always have a schema that can be deserialized. They also use a technique called 'upcasting'—when a new version comes in, they transform old events into the new shape on read. That way the log stays immutable. Luna: That's smart. But it means every team has to be disciplined about not breaking backward compatibility. Lucas: Right, and that discipline is part of their culture. They have strong conventions around event naming and field types. It's not just tech—it's how they review pull requests. Any event change gets extra scrutiny. Luna: So what about deployments? Monzo is known for shipping multiple times a day. How do they avoid breaking the bank? Lucas: Feature flags are central. They treat every deployment as an experiment. A new feature is turned on for a small percentage of users, then gradually rolled out. If something goes wrong, they toggle it off without a rollback. The flag infrastructure itself is built on their event system, so it's consistent. Luna: I've seen feature flags become a mess—hundreds of dead flags cluttering the codebase. How do they keep it clean? Lucas: They have a policy: once a flag is fully rolled out, you have one sprint to remove the old code path. They also run automated scans that flag stale flags. It's not perfect, but it's better than most. Luna: One sprint seems aggressive. I imagine some teams struggle. Lucas: They do. But the alternative is technical debt that slows everyone down. Monzo's CTO has said that they'd rather ship fast and clean up fast than let flags accumulate. It's a trade-off. Luna: Let's talk about the team itself. Monzo has a reputation for being lean. How lean? Lucas: As of last year, their engineering team was around 250 people. That's for a bank with nine million customers and a full product suite—current accounts, savings, loans, investments. Compare that to a traditional bank where a team that size might handle just one product. Luna: How do they keep that team from getting bogged down in meetings? Lucas: They're very deliberate about async communication. Most decisions happen in written proposals, not meetings. They use a format called 'RFCs'—request for comments—which anyone can contribute to. That reduces the need for synchronous discussions. Luna: Does that work for a regulated industry? I imagine some decisions need sign-off from compliance. Lucas: It does, because compliance is embedded early. They have compliance engineers who are part of the product teams, not a separate gate after the fact. So when an RFC is written, compliance reviews it alongside the tech lead. Luna: That's a different model from most banks I've seen. Usually compliance comes in at the end and says no. Lucas: Exactly. And that's a big part of why Monzo can move fast. They front-load the regulatory review. It's not faster per se, but it avoids rework. Luna: So the architecture, the feature flags, the async culture, the embedded compliance—it all adds up. But how do they ensure reliability? A bank outage is existential. Lucas: They run a game day program where they simulate failures. For example, they'll kill a database replica in production—actually pull the plug—and see if the system degrades gracefully. They've done this since the early days, so it's part of the muscle memory. Luna: That takes a certain kind of engineering courage. Most teams are too scared to test failure in prod. Lucas: Absolutely. But Monzo's philosophy is that you can't wait for failure to happen—you have to practice it. They also have a very mature observability stack, tracing every event from ingestion to the ledger. So when something does go wrong, they can pinpoint it quickly. Luna: I want to circle back to the event sourcing. A common criticism is that it makes it hard to delete data, which is a concern with GDPR. How does Monzo handle the right to be forgotten? Lucas: That's a great question. They don't actually delete events from the log. Instead, they anonymize them by replacing personally identifiable information with a hash or a null. The event itself stays for audit purposes, but it's no longer linked to a person. That's a pattern used by several event-sourced systems. Luna: So the log is immutable, but the data within it can be scrubbed. Makes sense. Lucas: And that approach passes regulatory muster because the audit trail remains intact. It's a clever middle ground between compliance and immutability. Luna: What's one thing you think other startups can learn from Monzo's engineering playbook? Lucas: I think it's the idea of 'primitives over frameworks.' Monzo doesn't use a massive off-the-shelf banking platform. They built their own small set of primitives—events, projections, flags—and compose them. That lets them move fast because they deeply understand every piece. It's harder upfront but pays off later. Luna: That requires a lot of conviction, especially when investors are pushing for faster feature delivery. Lucas: It does. But Monzo's early technical decisions were made when they had fewer than fifty engineers. That was the window to invest in that foundation. Once you're at two hundred engineers, it's much harder to switch. Luna: So the lesson for early-stage startups: invest in the right abstractions early, even if it slows you down for a quarter. Lucas: Exactly. And that's why Monzo's story is worth studying—it's not just about tech, it's about choosing what to build versus what to buy, and building a culture that respects both speed and correctness. Luna: I think that's a good note to end on. Thanks, Lucas. Lucas: Thanks, Luna. Talk to you next time.