System design interview guide
Monzo System Design Interview: How Card Payments and the Ledger Work
Short answer
A strong scenario to practise for a Monzo system design interview is card payments. It covers how a payment is approved and recorded. We have no public source that Monzo asks it. The key idea is to answer the card network fast. Then write every penny into a ledger where each payment is two equal and opposite entries. The shop's terminal asks Mastercard, and Mastercard asks Monzo through Monzo's own data centres and its own card processor. In this design, a card service checks the card and takes a short lock on the account. It checks the balance and writes a hold. In 2016 Monzo wrote that it aims to answer within tens of milliseconds. In 2019 it wrote that it stores its data in Cassandra. Monzo described a backup in 2025. If AWS fails, Monzo Stand-in on Google Cloud can approve payments from a copy of balances.
Two courses by the author of this page:
770 lessons · 18 free to read
₹1,111 in India · $35 elsewhere, once
Get System DesignYou own this course
219 lessons · 10 free to read
₹1,333 in India · $35 elsewhere, once
Get Generative AI and Agentic AIYou own this course
Save your progress and get the interview checklist PDF
Monzo had 15.2 million customers in its 2026 annual report. In a 2025 post, Monzo showed its main platform on AWS with about 3,000 microservices. A microservice is a small program that does one job. In 2016 Monzo wrote that it aims to answer the card network within tens of milliseconds. A separate backup platform on Google Cloud can approve payments if the main one goes down.
Designing Monzo's card payments is about one short request that must be right. A shop's card terminal asks Mastercard, and Mastercard asks Monzo: approve or decline? In card terms, Monzo is the issuer, the bank that gave you the card. The merchant's bank is the acquirer. Mastercard is the card scheme, the network between them. Monzo must check the card and the balance and answer within tens of milliseconds. The money then moves in the ledger, Monzo's record of every penny. It is double-entry: every debit has an equal credit. Behind it sit thousands of small services on Kubernetes, software that runs services across many servers. Monzo has written openly about its design and its outages. That gives you real numbers and real failure stories to reason with.
Where it shows up
Card payments and ledgers are a common system design topic for backend and platform roles at banks and payment companies. It also appears as design a banking system, design a digital wallet or design card authorisation. We have no public source that Monzo uses this exact question in its interviews. This guide is built from Monzo's own engineering blog, so you can reason with real numbers.
Spec sheetMonzo
- 01Customers
- 15.2M
- 02Card payments a day, estimated
- ~10M
- 03Peak authorisations a second, estimated
- ~360
- 04Ledger entries a day, estimated
- ~21M+
worked through below, with the maths
Monzo in its own numbers
Every figure below is quoted from Monzo's own engineering writing. Tap a source to check it.
15.2M
customers, financial year 2026
Monzo annual report, 20263,000
microservices on the Primary Platform in AWS
Monzo Technology blog, 2025Tens of ms
to answer the payment network on a card payment
Monzo Technology blog, 201621
Cassandra servers, each piece of data on 3 of them
Monzo incident write-up, 201918
microservices in Monzo Stand-in on Google Cloud
Monzo Technology blog, 2025~1%
Stand-in's cost, compared with the Primary Platform
Monzo Technology blog, 2025
Why this question is asked
This question tests whether you can keep money correct under failure. A card payment is not one request. It is an authorisation, maybe a reversal, and later a clearing record with the final amount. The same message can also arrive twice. The interviewer wants to hear about idempotency and a ledger you can audit. Idempotency means doing something twice has the same effect as doing it once. They also want to know what happens when a database or a whole cloud fails. A candidate who stores one balance column and updates it in place has missed the point.
What the interviewer asks
“Design the card payment system for a mobile bank like Monzo. A customer taps their card in a shop. The bank must approve or decline in milliseconds and update the balance in the app. It must also keep a correct record of the money for the regulator.”
Ask these back before you draw
- 1.Debit cards only, or credit too? (Start with a debit card on a current account.)
- 2.Do we connect to Mastercard ourselves, or through a third-party processor? (In 2019 Monzo wrote that it built its own processor; say so.)
- 3.How fast must we answer? (In 2016 Monzo wrote that it aims for tens of milliseconds.)
- 4.Is clearing in scope, the later record that confirms the final amount? Or only the authorisation?
- 5.What should happen if our main platform is down? Decline everything, or approve some payments on a backup?
This page is the free part.
The course goes deeper on the Monzo design
₹1,111 in India$35 everywhere elseonce, for the whole course
The System Design course covers the Monzo design across a run of lessons, not one page. These 4 alone are about 126 minutes of step-by-step reading, every one with a quiz.
- Idempotency
Why some operations are safe to retry and others charge you twice, and how to make everything safe.
- Idempotency Keys
Safely retry failed API requests without causing duplicate side effects.
- ACID Properties
Database transaction guarantees that keep your data correct.
- Quorum in Distributed Systems
What is quorum in system design? How read and write quorums work, why R + W > N, sloppy quorums, hinted handoff and quorum vs consensus, with a lab.
all part of
System Design Masterclass
770 lessons · about 290 hours · 18 free to read
₹1,111in India, by UPI
$35everywhere else, by card or PayPal
It is really nice and good Please join the course
You own this course
Continue with Idempotencypay once,
yours for life
Live from the course bench
Before you design Monzo, try the questions it rests on.
Real interview questions, live diagrams and measured lab results, pulled at random from the lessons. A new set every time you come back.
01Requirements
Requirements
Always clarify these in the first 5 minutes of the interview. Do not start drawing boxes until both lists are agreed.
Functional requirements
- Receive a card authorisation request from Mastercard and answer approve or decline
- Check the card (frozen or not) and the account (open or not) before approving
- Check that the customer has enough money, and hold it so a second payment cannot spend it too
- Handle reversals, when a terminal disconnects before it gets the answer
- Match each later clearing record to its authorisation, and post the final amount
- Record every movement of money in a double-entry ledger
- Show the new balance and the transaction in the app straight away
- Keep approving the most important payments when the main platform is down
Non-functional requirements
- Answer the payment network within tens of milliseconds, as Monzo wrote in 2016 that it aims to
- Available 24x7: in 2016 Monzo wrote that its systems must be available "no matter what happens"
- Never lose or double count money: the ledger is the source of truth
- Safe to process the same payment message more than once
- Survive a failed database server, a failed data centre and even a failed cloud provider
- Every change auditable later, by time of storage and by time of accounting impact
02Scale estimates
Back-of-envelope scale estimates
Show your math. Pulling numbers from thin air signals you have not thought about the load.
Customers
15.2M
Monzo's own total for the 2026 financial year. The same report gives 10.4 million monthly active users. Size the card path for the active users.
Card payments a day, estimated
~10M
Assume each monthly active user makes 1 card payment a day. That is our assumption, not Monzo's number. 10.4 million x 1 is about 10 million authorisations a day. As a check, Monzo's card spend was £73.0 billion in the 2026 financial year. That is about £200 million a day, or about £19 a payment.
Peak authorisations a second, estimated
~360
10.4 million / 86,400 seconds is about 120 a second on average. Assume the busiest hour runs at 3 times the average. That gives about 360 a second. Design for several times that, for Black Friday and payday.
Ledger entries a day, estimated
~21M+
The ledger is double-entry, so every movement of money has at least two lines: a debit and a credit. 10.4 million payments x 2 lines is about 21 million entries a day. That is before clearing, transfers, fees and interest.
Replicas that must answer
2 of 3
Monzo's 2019 write-up: data was stored on 3 of its 21 Cassandra servers, and every read and write used quorum. Quorum means a majority, here 2 of 3 copies must respond. So one copy can be down and payments still work.
03Architecture
High-level architecture
Start at the shop. The card terminal sends an authorisation request through the merchant's bank to Mastercard. Mastercard sends it to Monzo. In 2025 Monzo wrote that it connects to payment schemes through its own hardware in its own data centres. In 2019 it wrote that it had built its own Mastercard processor for current accounts. So the request lands on Monzo's code, not a third party's. From the data centre, the request goes to the Primary Platform on AWS. There, in this design, a card service runs the checks. Is the card frozen? Is the account open? Is there enough money? The balance comes from the ledger service. In 2022 Monzo wrote that the ledger is double-entry and the source of truth for all money. Services are small programs on Kubernetes. In 2019 Monzo wrote that it stores its data in Cassandra, a database spread over many servers. The answer goes back to Mastercard within tens of milliseconds. Slower work, like the notification in the app, happens afterwards. Beside all this sits Monzo Stand-in, a small separate platform on Google Cloud. It holds a copy of balances and can approve payments if AWS fails.
In a real interview, sketch this on the whiteboard before diving into any single box.

04One request
What happens when you tap your Monzo card, step by step
Steps 1, 2 and 5 follow Monzo's own posts. Monzo has not published the inside of steps 3, 4 and 6, so that order is this design's. Clearing and settlement in step 6 are how card schemes work in general.
- 1
The terminal asks
You tap your card. The terminal sends an authorisation request through the merchant's bank to Mastercard. Mastercard sends it on to Monzo.
- 2
It enters Monzo's data centre
Monzo connects to Mastercard through its own hardware and software in its own data centres. Monzo's processor reads the message and passes it to the card service.
- 3
The quick checks run
Read-only checks run side by side. Is the card frozen? Is the account open? Monzo's 2025 Stand-in post describes checks like these. This design uses the same idea on the main path.
- 4
Lock, check and hold
The card service takes a short lock on the account. It checks the balance, records the authorisation and writes a pending hold. Then it releases the lock. A second payment now sees the hold.
- 5
Answer within tens of milliseconds
Monzo sends approve or decline back to Mastercard. If the answer is too late, the terminal times out and rejects the payment.
- 6
Clearing, then settlement
The app shows the new balance. A day or more later, the merchant's bank sends a clearing record with the final amount. The pending hold is replaced by the final entry. Separately, the card scheme settles the net money between banks each day.
05Components
Core components
Walk through each service. The interviewer wants to hear what each one owns, not just the names.
Mastercard connection in Monzo's data centres
In 2025 Monzo wrote that it connects to payment schemes through its own hardware in its own data centres. It called these edge services, the first programs a payment message reaches, stateless with very few dependencies. That keeps the front door simple and quick to restart.
Card processor and card service
In 2019 Monzo wrote that it had built its own Mastercard processor for current accounts. It turns each Mastercard message into a decision: approve or decline. Monzo's 2025 post names a service.mastercard that moves money in the ledger.
Validators
Small checks that each answer one question. Monzo's 2025 post on Stand-in describes validators like these. Examples check whether the card is frozen and whether the account is open. They run in parallel there. This design uses the same idea on the Primary Platform.
Ledger service
In 2022 Monzo called the ledger the source of truth for all money moving around the bank. It is double-entry bookkeeping: every movement has an equal and opposite movement. A balance is the sum of the entries for an account.
Account lock (in this design)
A short lock per account, held while the balance is checked and the hold is written. It stops two payments from spending the same money. Monzo's 2025 Stand-in post lists locking mechanisms among the platform parts both platforms have.
Cassandra
A distributed database that spreads data over many servers and keeps several copies. In 2019 Monzo ran 21 servers, with each piece of data on 3 of them. Every read and write used quorum.
Kubernetes and the service mesh
Kubernetes runs Monzo's thousands of services and moves them when a server dies. A service mesh carries calls between services. In Monzo's 2016 design it was linkerd, which balanced load and retried safe requests.
Monzo Stand-in
A separate backup platform on Google Cloud with 18 microservices, from Monzo's 2025 post. It keeps a copy of balances and recent transactions. It can approve card payments and cash withdrawals, send transfers and freeze cards. Monzo also runs it in production for small test groups and shadow-tests it with real payment traffic.
06Data model
Data model
Pick the right store per table. Justify each choice with the access pattern, not by reflex.
ledger_entries (an entry set per movement)entry_set_idaddress (e.g. com.monzo.account:main)amount (+ or -)currencycommitted (when stored)reporting (when it has accounting impact)Field names follow Monzo's 2022 post on balances: an EntrySet, addresses, a currency, and two timestamps. That post says "the sum of all credit entries equals the sum of all debit entries". In this design, entries are only added, never edited.
authorisationsnetwork_trace_id (Mastercard's reference for the original authorisation)card_idaccount_idamountmerchantdecisionstatus (pending, reversed, cleared, expired)In this design, one row per authorisation, keyed by the network's trace reference for the original authorisation. A repeat of the same message carries the same reference and returns the stored decision. A reversal or a clearing record carries a pointer back to it and finds the same row.
cardscard_idaccount_idfrozenlimitspin_attemptsIn this design, read on every payment by the validators. Small and read-heavy, so it caches well. Freezing a card in the app must take effect on the next payment.
named_balances (definitions)balance_name (e.g. customer-facing-balance)addresses[]time boundariesIn 2022 Monzo had tens of named balances. The customer-facing balance is what you see in the app; it reflects your real-time transactions. The interest-chargeable balance leaves out pending transactions that have not settled.
07Deep dives
Deep dives
These are the conversations the interviewer is steering you toward. Practice each one until you can talk through it without notes.
The authorisation: answer within tens of milliseconds
In 2016 Monzo wrote that it wants to respond to payment networks within tens of milliseconds. Its 2017 post explains why this matters. If the answer takes too long, the terminal times out and rejects the payment. So the design splits the work in two. The decision runs on the fast path: checks, balance, hold, answer. Everything else runs afterwards and asynchronously, meaning later and without making the shop wait. That includes the app notification. The quick read-only checks can run in parallel, as Monzo's 2025 Stand-in post describes. But the balance check and the hold must happen together under a lock. Otherwise two payments can both see enough money. The sketch below is an illustration, not Monzo's code.
async def decide(auth, card, account, ledger, store):
seen = await store.get_decision(auth.network_trace_id)
if seen: return seen # a repeat: same answer
ok = await asyncio.gather(card_not_frozen(card), account_open(account))
if not all(ok): return "decline"
async with account_lock(account.id): # one payment at a time
if await ledger.available(account.id) < auth.amount: return "decline"
await ledger.write_hold(account.id, auth) # pending entries
await store.save_decision(auth.network_trace_id, "approve")
return "approve"The ledger: double-entry, and a balance is a sum
In 2022 Monzo wrote that the ledger is the source of truth of all the money moving around the bank. It is built as double-entry bookkeeping. Every movement of money has an equal and opposite movement. In Monzo's 2018 post, a Monzo-to-Monzo payment debits the sender's account and credits the recipient's account inside the ledger. For a card payment, the other side is not another customer. In this design, the customer's account is debited and a Mastercard settlement account inside Monzo is credited. When the daily settlement with Mastercard happens, that account is cleared. Reconciliation then checks that the clearing records, the ledger and the money moved all agree. Reconciliation means comparing records to find anything missing or different. To get a balance, a service calls the balances endpoint on service.ledger. The ledger fetches the amounts for the account's addresses within a time window and adds them up. Each entry carries two timestamps: when it was stored, and when it has an accounting impact. In an interview, say why you never store a single balance number and overwrite it. A sum of entries can be checked, replayed and audited.
One payment, many messages: make every step idempotent
Monzo's 2025 post says it plainly: a payment is not just a single request. The same payment may be processed multiple times. First comes the authorisation request. If the terminal disconnects before it gets the answer, Mastercard sends a reversal to undo it. Networks also retry, so the same message can arrive twice. In card schemes in general, a clearing record arrives later with the final amount. It can differ from the authorised amount, for example with tips, hotels and fuel pumps. In this design, everything is keyed on Mastercard's trace reference for the original authorisation. A repeated authorisation returns the decision already stored. A reversal finds the original and writes the opposite ledger entries. A clearing record finds the original and replaces the hold with the final entry. The rule for the interview: never move money because a message arrived. Move money because a message you have not seen before arrived.
Cassandra at Monzo: quorum, and the 2019 scaling incident
In 2019 Monzo wrote that it uses Cassandra to store its data. It ran a cluster of 21 servers. Each piece of data was stored on 3 of them. Every read and write used quorum, so 2 of 3 copies had to respond. That lets one copy fail with no harm. On 29 July 2019 the cluster was running close to its limits at peak, so Monzo added six servers. The setting auto_bootstrap was turned off. Bootstrap is the step where a new server copies its share of data before serving. Without it, the new servers took responsibility for data they did not yet hold. That data appeared to be missing, and a small share of card payments failed. The immediate impact ended at 15:08, about two hours after the change began at 13:10. Monzo then checked every write made during that window with its reconciliation processes. Its long-term plan was to split one large cluster into several smaller ones. Monzo has not published which database its ledger uses today.
Thousands of microservices on Kubernetes, and what can break
Monzo built its backend as small services from the start. It had about 150 in 2016 and over 1,500 in 2019. Its 2025 post shows about 3,000. In 2016 Monzo said Go was its dominant language. The services run on Kubernetes, which places them on servers and restarts them when a server dies. Many services means many network calls. Monzo's 2016 design sent every call through linkerd, a proxy that load-balances and retries safe requests. In October 2017 this part of the system failed. A bug in Kubernetes and its etcd client caused timeouts. Etcd is the database Kubernetes keeps its own state in. Its cluster had just grown from three to nine nodes. Restarting every linkerd instance then made it worse. The outage affected both Monzo's prepaid card and its new current account for about one and a half hours. In 2019 Monzo also limited which services may call which. It used network policies, rules that say which services may talk, built on a tool called Calico.
Monzo Stand-in: a second bank on a second cloud
In 2025 Monzo wrote about Stand-in, a backup of last resort. The Primary Platform runs on AWS with about 3,000 microservices. Stand-in runs on Google Cloud with 18. It costs about 1% of the primary. Each platform has its own connection to the payment networks and makes its own decisions. Stand-in keeps a copy of balances and recent transactions. The copy is synced from the primary in the background. Monzo calls it eventually consistent, meaning it may lag a little behind. So Stand-in can approve a payment the primary would have declined. That can take a customer into an unapproved overdraft, a negative balance they never agreed to. Monzo accepts that risk for a rare outage. Every payment Stand-in processes becomes a Monzo Advice, a message that tells the primary what was decided. When the primary is back, it applies each advice and moves the money in the ledger. It does not re-run the decision. In August 2024 an incident lasted about an hour. Monzo then turned on all of Stand-in for all customers for the first time. Do not confuse this with the card networks' own stand-in services. In general, a card network can answer for an issuer that does not reply in time. It stays within limits the issuer sets. Monzo has not published whether or how it uses Mastercard's.
Why not run everything active-active across two clouds?
Active-active means two sites both serve live traffic at once. It sounds like the obvious answer to a cloud outage. In 2025 Monzo explained why it did not do it for the whole bank. Copying every service's data to both clouds with strong consistency means a write succeeds only when both clouds confirm it. Then if either cloud fails, writes stop, and availability gets worse, not better. Copying with eventual consistency avoids that. But systems like the ledger cannot work on data that may be out of date. Monzo wrote that full replication could potentially double its total platform costs. So it built a small platform for the few things that must never stop. In an interview, say this trade-off out loud. Decide which features must survive a cloud outage, and accept a known, small risk for them.
Common mistakes candidates make
The first mistake is reading a balance and approving without holding anything. Two payments at the same moment can both read 100 pounds and both approve. Summing ledger entries does not fix this by itself. Say instead: take a short lock on the account, check, write the pending hold, then answer. The second mistake is treating a card payment as one request. Reversals, retries and clearing records all arrive as separate messages. Say instead: key every step on the network's trace reference and make it idempotent. The third mistake is calling the final movement settlement. In card schemes in general, clearing confirms the customer's final amount; settlement is the daily net transfer between banks. The fourth mistake is doing everything before answering Mastercard. Notifications do not belong on a path measured in tens of milliseconds. The fifth mistake is saying multi-region and stopping there. The two incidents Monzo has explained in detail came from adding database servers and from the service mesh. Say how you change a running database safely, and what your backup can and cannot do. Spend 45 minutes like this: requirements and numbers (5), the authorisation path (10), the ledger and lock (10). Then cover repeats, reversals and clearing (10), and finally failure (10).
08Trade-offs
Trade-offs to discuss
Every senior interviewer expects you to surface at least 3 of these. Pick the decisions, state the alternatives, and justify your choice.
Own Mastercard processor vs a third-party processor
A third-party processor is quicker to start with. In 2018 Monzo wrote that its prepaid card had used one, and that processor kept each user's balance. Building its own processor gave Monzo control of the decision and the data, in its own code. The cost is running scheme connections, hardware in data centres, and certification yourself.
Append-only double-entry ledger vs a balance column
A balance column is one fast read. A ledger needs a sum, so it is more work to read. But it can be audited, replayed and reconciled, and two movements can never silently overwrite each other. For a bank, that is not optional. Speed the read up with caching or snapshots, not by giving up the entries.
Cassandra with quorum vs a single relational database
Cassandra spreads data over many servers and keeps working when one copy fails. Quorum reads and writes mean a read sees the latest acknowledged write for that key. They do not stop two writers racing: the last write wins. For a check such as 'have I seen this authorisation?', use a lock or Cassandra's lightweight transactions. These are a compare-and-set on one partition. You give up joins and transactions across rows. Scaling it is not free: Monzo's 2019 incident came from adding servers.
Thousands of small services vs a few large ones
Small services let many teams ship on their own and limit what each one can touch. The cost is many network calls and a service mesh to run. Outages can also spread through the mesh, as in October 2017. In 2019 Monzo paired the many services with network policies, so only approved services could talk.
A small Stand-in platform vs full active-active across clouds
Monzo wrote in 2025 that full replication could potentially double its platform costs. Strong consistency across two clouds would also stop writes whenever either failed. Stand-in costs about 1% and covers only the key features. The price is eventual consistency: a payment may be approved that the primary would decline.
Decide on the fast path, do the rest later
Answering Mastercard within tens of milliseconds leaves no room for slow work. Anything the shop does not need to wait for, like the app notification, runs after the answer. The cost is that the app may update a moment after the shop's terminal says approved.
Free PDF · 18 pages
Get the free System Design Interview Cheat Sheet
The interview in seven stages, the numbers worth knowing by heart, and twelve classic systems on one page each, every line linked to the lesson it comes from.
09Follow-ups
Follow-up questions to expect
After the main design, the interviewer usually picks one part and asks more. Here is what to say.
The same authorisation arrives twice. What happens?
In this design, the second copy finds the first by Mastercard's trace reference. It returns the decision already stored and writes nothing new to the ledger. In 2025 Monzo wrote that it may process the same payment more than once, so every step must be idempotent.
The clearing amount is higher than what you authorised. What do you do?
In this design, you post the cleared amount, release the pending hold, and record the difference. In card payments in general, tips, hotels and fuel pumps do this routinely. You decline nothing at this stage, because the merchant's bank is already owed the money.
An authorisation is never cleared. What happens to the hold?
In this design, the hold expires after a set number of days. The pending entries are reversed, so the money comes back into the customer's balance.
AWS is down. Can customers still pay?
At Monzo, yes, through Stand-in on Google Cloud, as Monzo described in 2025. It has its own connection to the payment networks and a lagging copy of balances. It approves or declines, and records each decision as an advice. When AWS is back, the primary applies the advices to the ledger without re-running the decision.
Your Cassandra cluster is near its limits at peak. How do you add servers safely?
Make sure each new server copies its share of the data before it serves reads. In Cassandra this is bootstrapping. Monzo's 2019 incident happened because it was turned off, so new servers answered for data they did not hold. Add servers one at a time, watch for missing reads, and reconcile anything written during the change.
10In production
How Monzo actually does it
Every fact about Monzo on this page comes from Monzo's own writing. The estimates and anything marked 'in this design' or 'assume' are ours. Facts about card schemes in general, such as clearing and settlement, are marked as general knowledge. The tens of milliseconds goal, Kubernetes, Go, Kafka and linkerd are from the 2016 post Building a modern bank backend. The terminal timeout is from a 2017 post on declined payments. The Kubernetes and linkerd outage is from Monzo's own post-mortem on its community forum, October 2017. The Monzo-to-Monzo debit and credit is from 2018. The Cassandra cluster and the 29 July incident are from Monzo's 2019 write-up. The 1,500 services and Calico network policies are from a 2019 post. The in-house Mastercard processor is from the 2019 Faster Payments post. Double-entry, named balances and the two timestamps are from the 2022 post on balances. Stand-in, its 18 services, its cost and the advice flow are from two 2025 posts. The customer count and card spend are from the 2026 annual report. Older posts describe the system at that date, so say the year when you quote a number.
Sources
- Monzo: Building a modern bank backend (2016)
- Monzo: Terminal decline, why some payments fail (2017)
- Monzo community: post-mortem of the 27 October 2017 outage
- Monzo: A technical look at how Monzo-to-Monzo payments work (2018)
- Monzo: Why Monzo wasn't working on 29 July (2019)
- Monzo: We built network isolation for 1,500 services (2019)
- Monzo: We brought our Faster Payments connection in-house (2019)
- Monzo: How we calculate balances (2022)
- Monzo: Tolerating full cloud outages with Monzo Stand-in (2025)
- Monzo: Processing payments in Monzo Stand-in (2025)
- Monzo: Year in review, annual report 2026
Lessons to study before this interview
If any of these topics are fuzzy, the interviewer will catch it. Each lesson is 15 to 60 minutes with diagrams, code, and a quiz.
Idempotency
foundation / core fundamentals
Idempotency Keys
intermediate / api design protocols
ACID Properties
foundation / core fundamentals
Quorum in Distributed Systems
advanced / distributed systems core
Column-Family Stores
intermediate / database types storage
Microservices Architecture
intermediate / microservices architecture
Service Mesh Concepts
intermediate / microservices architecture
Timeout Patterns
advanced / reliability resilience
Replication Lag
intermediate / data replication distribution
Active-Active Failover
advanced / reliability resilience
Capstone: Design a Payment System
capstone / capstone
System design interviews at companies in the US, UK, Canada and Singapore
41 walkthroughs of real systems at well-known companies, each built from that company's own engineering blog, talks or filings, with the numbers cited.
Banking, payments and trading
- Monzo system design (this page) (UK)
- Wise system design (UK)
- Stripe system design
- PayPal system design
- Robinhood system design
- Coinbase system design
Commerce and delivery
Rides and maps
- Grab system design (Singapore)
- Uber system design
Feeds, social and messaging
Streaming and media
AI labs and big tech
Developer and collaboration tools
11FAQ
Frequently asked questions
Go deeper
This guide is built on these 6 lessons. Each one teaches one piece of the Monzo design above, step by step.
- IdempotencySystem Design · core fundamentals · 28 min
- Idempotency KeysSystem Design · api design protocols · 18 min
- ACID PropertiesSystem Design · core fundamentals · 25 min
- Quorum in Distributed SystemsSystem Design · distributed systems core · 55 min
- Column-Family StoresSystem Design · database types storage · 15 min
- Microservices ArchitectureSystem Design · microservices architecture · 20 min
Practice with 770 system design lessons
Lifetime access for ₹1,111 in India or $35 elsewhere. Interactive diagrams, quizzes, and 20 capstone projects to practise on.
This one question is not enough for the interview.
Get all 200 questions in the System Design and Distributed Systems pack
Each question has why it is asked, a full answer, what the interviewer listens for, the follow-ups, the common mistakes and a diagram (268 diagrams in all). A PDF you keep, junior to staff level.
Pay by UPI, cards or netbanking through Razorpay. Pay by card or PayPal, in US dollars. Download at once from My packs.
NEWSystem Design Hands-On
Included in the System Design course: real systems, built live
Postgres Sharding: Complete Hands-On (PgBouncer + Citus). 2 h 36 min and 20 chapters: one PostgreSQL loaded until it breaks, then four shards behind a router you write, PgBouncer and Citus, with the 139-page slide deck. The first 15 minutes are free to watch.


