System design interview guide
Wise System Design Interview: How Cross-Border Money Transfers Work
Short answer
A strong scenario to practise for a Wise system design interview is sending money abroad. Wise does it without the money crossing a border. We have no public source that Wise asks this exact question. The key idea is two local payments. The sender pays Wise in their country, and Wise pays the recipient in theirs. A quote locks the mid-market rate for 30 minutes. The transfer is created exactly once, using an idempotency key the client sends. Checks run, the currency is converted, and a ledger records both sides. In this design, the ledger is then reconciled against bank statements. Wise reported 78% of transfers completed instantly in the quarter to September 2026.
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
In the quarter to 30 September 2026, Wise moved $71.7 billion across borders for 12.5 million active customers. It says 78% of those transfers were completed instantly. Wise's speed updates describe instant as arriving in under 20 seconds.
Wise, once called TransferWise, moves money between countries. Designing it means designing a transfer that mostly avoids crossing a border. The sender pays in to Wise's own account in their country. Wise pays out from its own account in the recipient's country. In between sit a quote with a locked rate and a transfer that must be created exactly once. Then come compliance checks, and a ledger that records every movement. The hard parts are correctness and speed together. A payment must never be sent twice. Every pound and euro must be accounted for. And most transfers should still arrive in seconds.
Where it shows up
A common type of question for backend and payments roles at money transfer companies. Wise's careers site describes its own backend system design interview. It lasts about an hour, with two engineers and a product task. Its suggested topics include high-volume transaction processing, distributed transactions, and concurrency, data consistency and idempotency. We have no public source that Wise uses this exact question. This guide is built from Wise's own engineering blog, API docs and investor reports. So you can reason with real numbers.
Spec sheetWise
- 01Volume per day
- ~$780M
- 02Transfers per day, estimated
- ~390,000
- 03Transfers per second, estimated
- ~4.5 avg, ~45 peak
- 04Ledger entries per day, estimated
- ~3.1M
worked through below, with the maths
Wise in its own numbers
Every figure below is quoted from Wise's own engineering writing. Tap a source to check it.
$71.7B
cross-border volume in one quarter (Q2 FY27, to Sept 2026)
Wise Q2 FY27 results, Oct 202612.5M
active customers in that quarter
Wise Q2 FY27 results, Oct 202678%
of transfers completed instantly in that quarter
Wise Q2 FY27 results, Oct 2026< 20 s
how Wise's speed updates describe an instant transfer
Wise mission update, Oct 202530 min
an authenticated quote locks the mid-market rate
Wise API docs1,000+
services in total at Wise; the backend is mostly Java and Kotlin
Wise Engineering, Feb 2025
Why this question is asked
Money transfer design tests whether you can keep a system correct while parts of it fail. Networks time out, banks answer late and messages arrive out of order. A candidate must show how a retry never sends money twice. They must show how every movement is recorded, and how the books are checked against the banks. It also tests product sense. Wise's model is to avoid the slow chain of banks a normal international wire goes through. That wire travels on SWIFT, the network banks use to send international payment messages. If you design a SWIFT wire with a nicer screen, you have missed the point.
What the interviewer asks
“Design the system behind a Wise transfer. A customer in the UK wants to send pounds to someone in Germany, who receives euros. Cover the quote, the payment in, the conversion and the payment out. Then show how no money is lost or sent twice.”
Ask these back before you draw
- 1.Is this one route (GBP to EUR) or any currency pair? (Design for any pair; walk through GBP to EUR.)
- 2.How does the sender pay: a bank transfer, a card, or money already in a Wise balance?
- 3.Does the recipient need a Wise account? (No. Wise says the recipient only needs a bank account.)
- 4.How long must the exchange rate be guaranteed? (Wise locks it for 30 minutes on a quote.)
- 5.Are compliance checks such as anti-money-laundering in scope, or a black box?
This page is the free part.
The course goes deeper on the Wise design
₹1,111 in India$35 everywhere elseonce, for the whole course
The System Design course covers the Wise design across a run of lessons, not one page. These 4 alone are about 96 minutes of step-by-step reading, 1 of them with code you run in the browser, all 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.
- State Machine
Model system behavior as a finite set of states and transitions, the foundation of distributed protocols.
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 Wise, 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
- Show the exchange rate and fee before the customer commits, then lock that rate
- Create a transfer from a quote and a recipient's bank details
- Accept the money in by a local bank transfer, a card or a Wise balance
- Run compliance and fraud checks before money leaves
- Convert the currency and pay the recipient's bank account in their country
- Show the transfer's status and a delivery estimate at every step
- Handle returns: a payment that bounces back is refunded to the sender
Non-functional requirements
- Correctness first: no transfer created twice, no payout sent twice, no money unaccounted for
- Speed: most transfers should arrive in under 20 seconds (Wise reported 78% instant in Q2 FY27)
- Every movement of money recorded in a ledger that balances, and checked against the banks
- Availability measured on the whole send-money flow: quote, set up transfer, pay in
- Each country's payment systems differ, so local integrations must be isolated from each other
- A full audit trail for regulators in every country where Wise is licensed
02Scale estimates
Back-of-envelope scale estimates
Show your math. Pulling numbers from thin air signals you have not thought about the load.
Volume per day
~$780M
Wise reported $71.7 billion of cross-border volume for the quarter to 30 September 2026. That quarter has 92 days. 71.7 billion / 92 is about $780 million a day.
Transfers per day, estimated
~390,000
Wise does not publish the number of transfers in these results. Assume an average transfer of $2,000. That is our assumption, not Wise's figure. $780 million / $2,000 is about 390,000 transfers a day.
Transfers per second, estimated
~4.5 avg, ~45 peak
390,000 / 86,400 seconds is about 4.5 transfers a second on average. Assume the busiest minutes run at ten times the average. That gives about 45 a second. The rate is small; correctness is the hard part.
Ledger entries per day, estimated
~3.1M
In this design a simple transfer writes about eight ledger entries. That is two for the pay-in, four for the conversion (two in each currency) and two for the payout. 390,000 x 8 is about 3.1 million entries a day, before returns and fees.
Instant transfers per day, estimated
~300,000
78% of an estimated 390,000 transfers. Each of these must pass every check and reach the recipient's bank in under 20 seconds. So the checks cannot be a slow batch job.
03Architecture
High-level architecture
Draw the money path first, then the services. The sender pays in to Wise's own bank account in the sender's country. Wise pays out from its own bank account in the recipient's country. Wise describes this itself. If you send euros to someone in the US, your euros stay in Wise's European account. Wise sends the dollars from its US account. Above that path sit the services. A quote service prices the transfer and locks the rate. A transfer service creates the transfer exactly once and moves it through its states. A pay-in service matches incoming money to transfers. A checks step runs compliance and fraud checks. A payout service sends the local payment. It uses a direct link to the country's payment scheme, or a partner bank. A payment scheme is a country's system for moving money between banks, such as Faster Payments in the UK. A ledger, the record of every movement of money, writes each movement as balanced entries. Events about each state change go onto Kafka, a log that many services can read from. Other teams then react without slowing the transfer down. Treasury watches how much money sits in each account and currency. In this design it moves money between accounts when one runs low.
In a real interview, sketch this on the whiteboard before diving into any single box.

04One request
One GBP to EUR transfer, step by step
The states in this walk-through are the ones Wise publishes in its API documentation. The services behind them are this design's choice.
- 1
Quote and lock the rate
The customer asks to send pounds and receive euros. The quote service returns the mid-market rate, the fee and a delivery estimate. The mid-market rate is the midpoint between the buy and sell prices, with no markup. Wise locks it for 30 minutes on an authenticated quote.
- 2
Create the transfer once
The app creates a transfer from the quote and the recipient. It sends its own unique ID with the request. Wise's API calls this field customerTransactionId and uses it for idempotency. Idempotency means a repeated request has the same effect as one. So a retry cannot create a second transfer. The state is incoming_payment_waiting.
- 3
Pay in locally
The sender pays Wise's UK account by a normal UK bank transfer. The pay-in service matches the money to the transfer and posts it to the ledger. The state becomes processing.
- 4
Check and convert
Wise runs anti-money-laundering, compliance and fraud checks. When they pass, the pounds are converted to euros at the locked rate and the ledger records both sides. The state becomes funds_converted.
- 5
Pay out locally
The payout service sends euros from Wise's own account in Europe to the recipient's bank. The state becomes outgoing_payment_sent. Wise notes this means it has sent the money, not that the recipient's bank has credited it.
- 6
Reconcile
In this design, the ledger is compared with the banks' statements. A payment that bounces back moves the transfer to bounced_back and then to a refund. Wise's docs say most bounces come within 2 to 3 business days, but some take weeks.
05Components
Core components
Walk through each service. The interviewer wants to hear what each one owns, not just the names.
Quote service
Prices a transfer: rate, fee, payment options and a delivery estimate. An authenticated quote locks the mid-market rate for 30 minutes. A quote that is not used in time expires, and the customer must ask for a new one.
Transfer service
Owns the transfer and its state machine, from incoming_payment_waiting to outgoing_payment_sent. Creation is idempotent on the client's own ID. In this design it is the only writer of transfer state, and it publishes every state change as an event.
Pay-in service
Receives money from bank transfers, cards and balances, and matches it to the right transfer. For euro bank pay-ins, Wise uses outside vendors that connect it to many European banks. It switches between them, per bank, when one starts failing. Some bank pay-ins arrive with a missing reference or the wrong amount. In this design these go to a suspense account in the ledger until they are matched or returned.
Checks (compliance and fraud)
Runs anti-money-laundering, sanctions and fraud checks before money leaves. Wise's API docs say processing is when these checks happen. Wise's speed updates link faster internal checks to more instant transfers.
Payout service and scheme adapters
Sends the local payment in the recipient's country. Each country is a separate adapter. It is either a direct link to a scheme, such as UK Faster Payments or InstaPay, or a partner bank. One adapter's failure must not touch the others.
Ledger
Records every movement of money as balanced entries, per account and per currency. Wise has not published how its transfer ledger is built. In this design it is append-only: entries are never edited, only reversed by new entries.
Treasury ledger
A separate, real-time view of how much money Wise holds in each account and currency. It also tracks the FX position: how much of each currency Wise is long or short. An undated, now expired Wise job posting says the team builds it on Kafka and Flink, a stream-processing engine. It names real-time reconciliation and exactly-once processing as its problems.
Event bus (Kafka)
Carries transfer state changes to everyone who needs to react: notifications, analytics and fraud models. Wise wrote in 2016 that it wanted to move these reactions out of the transaction. It also wrote that most of its messaging had moved to Kafka. In 2025 it wrote that Kafka underpins most of its real-time data movement.
06Data model
Data model
Pick the right store per table. Justify each choice with the access pattern, not by reflex.
quotesquote_id (UUID)profile_idsource_currency, target_currencysource_amount, target_amountraterate_expires_at (+30 min)status (PENDING, ACCEPTED, FUNDED, EXPIRED)The locked rate lives here. The transfer copies the rate when it is created. A later rate change cannot alter a transfer that is already set up. The statuses are the ones Wise's quote API returns.
transferstransfer_idprofile_idcustomer_transaction_id (unique per profile)request_hashquote_idrecipient_account_idstatusversioncreated_at, updated_atA unique index on (profile_id, customer_transaction_id) makes creation idempotent. request_hash lets a retry with the same key but a different body be rejected. Status changes are guarded on status and version, so two workers cannot both move one transfer.
ledger_entries (this design)entry_idjournal_id (one per business event)account (e.g. wise_uk_bank_gbp, owed_to_transfer_gbp, fx_gbp)currencyamount (signed, minor units)transfer_idcreated_atAppend-only. Every journal sums to zero within each currency. Amounts are integers in minor units, such as pence and cents, never floating point. Balances are sums of entries, cached for speed.
bank_statement_linesaccountbank_referenceamountcurrencyvalue_datematched_entry_id (nullable)Loaded from each bank or scheme. Reconciliation matches every line to a ledger entry. An unmatched line on either side is a break, and someone must explain it.
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.
Two local payments instead of one international wire
A normal international wire hops through a chain of banks. Each hop adds time and cost. Wise avoids this. It holds its own bank accounts in many countries. Wise gives an example. If you send euros to someone in the US, your euros stay in Wise's European account. Wise sends the equivalent dollars from its US account. So one transfer becomes two domestic payments joined by an entry in Wise's books. Wise's UK guide adds a second idea: it can often use money from a customer sending the other way. Pounds flowing to Europe and euros flowing to the UK partly cancel out. In this design, Treasury still moves money between countries. But it moves only the net amount, in batches, not each customer's transfer. In the interview, say this early. It changes the design. The hard problems are now keeping enough money in each account, and keeping the books right across many countries.
The quote: lock the rate, then let it expire
The customer must see the rate and fee before paying. But exchange rates move every second. Wise's answer is a quote with a time limit. Its API docs say an authenticated quote locks the mid-market rate for 30 minutes. That rate is then used in the transfer. If the quote is not turned into a transfer in time, it expires, and the customer needs a new one. Wise also offers unauthenticated quotes, which are only for display and cannot create a transfer. In this design the quote service stores the rate and its expiry time. The transfer copies the rate when it is created. Whoever offers a locked rate carries the risk that the market moves during those 30 minutes. Wise does not say how it manages that risk. Treat it as a business question, and mention it.
Creating a transfer exactly once: idempotency
The app sends create transfer. The network times out. Did Wise create it or not? If the app simply retries, the customer may get two transfers. The fix is an idempotency key: a unique ID the client chooses and sends with the request. Wise's API makes this field, customerTransactionId, required. Its docs say to retry with the same value after a server error. The same goes when a request may have partly succeeded. On the server, store the key with a unique index. The unique index is what stops two racing retries: only one insert can win. If the same key arrives again, return the transfer you already made. Also store a hash of the request. If the same key arrives with a different quote or recipient, reject it with an error. The same idea repeats at every step: one pay-in matched once, one payout sent once.
import hashlib
def create_transfer(db, profile_id, client_id, quote_id, recipient_id):
# UNIQUE (profile_id, customer_transaction_id) on the transfers table
body = f"{quote_id}|{recipient_id}".encode()
req_hash = hashlib.sha256(body).hexdigest() # stable across processes
row = db.execute("""
INSERT INTO transfers (profile_id, customer_transaction_id, request_hash,
quote_id, recipient_id, status)
VALUES (%s, %s, %s, %s, %s, 'incoming_payment_waiting')
ON CONFLICT (profile_id, customer_transaction_id) DO NOTHING
RETURNING transfer_id""",
(profile_id, client_id, req_hash, quote_id, recipient_id))
if row: # first time we saw this key
return row.transfer_id
old = db.one("""SELECT transfer_id, request_hash FROM transfers
WHERE profile_id = %s AND customer_transaction_id = %s""",
(profile_id, client_id))
if old.request_hash != req_hash: # same key, different request
raise ValueError("idempotency key reused with a different request")
return old.transfer_id # a retry: the same transferThe transfer as a state machine, with side effects on Kafka
Wise publishes the states of a transfer in its API docs. The happy path is incoming_payment_waiting, then processing, then funds_converted, then outgoing_payment_sent. Other states cover failure and doubt: cancelled, funds_refunded, bounced_back, charged_back and unknown. A state machine like this makes every change explicit and checkable. In this design, give each transfer a version number that goes up by one on every change. Apply a change only from the state and version you expect, and drop anything stale. Wise's docs note that transfers do support deliberate rollback transitions. A bounced payment goes from bounced_back back to processing. So backward moves are allowed, but only as named transitions, never by a stray message. In 2016 Wise wrote that a big part of its business logic swirls around the state changes of a transfer. Fraud checks and analytics then ran in the same step as the change. Wise said it wanted to unbundle the reactions to an event from the change itself. It also said most of its messaging had moved to Kafka. In this design, write the state change and its event in one database transaction. Then publish the event from that table. This is the transactional outbox pattern. The same 2016 post says Wise always prioritises consistency over availability. It wanted its data stores to be ACID. That means a change is fully saved or not saved at all, even with many writers.
The ledger: double-entry, append-only, per currency
Wise has not published how its transfer ledger works, so this part is our design. Use double-entry bookkeeping. Every movement is a journal of two or more entries that sum to zero in each currency. Take an example with made-up numbers. The sender pays 1,000 pounds, and the locked rate gives 1,160 euros. At pay-in, Wise's UK bank account goes up by 1,000 pounds. What Wise owes this transfer goes up by the same 1,000 pounds. The conversion is one journal with four entries. In pounds, what Wise owes the transfer goes down 1,000, and Wise's FX account goes up 1,000. FX means foreign exchange, or currency conversion. In euros, the FX account goes down 1,160, and what Wise owes the recipient goes up 1,160. At payout, what Wise owes in euros goes down 1,160, and so does Wise's euro bank account. Every currency sums to zero at every step. Entries are never edited. A mistake is fixed by a new reversing entry, so the history always explains itself. Store amounts as integers in minor units, such as pence and cents. Wise does describe a related system in an undated job posting, now expired. Its Treasury Ledger gives a real-time view of Wise's FX position and liquidity. It runs on Kafka and Flink, with MariaDB and ClickHouse, a database built for fast analytics. The posting names the hard problems as exactly-once processing, event ordering, replay and real-time aggregation.
SELECT journal_id, currency, SUM(amount_minor) AS imbalance
FROM ledger_entries
GROUP BY journal_id, currency
HAVING SUM(amount_minor) <> 0;Pay-in and payout: own the connection to each payment scheme
Speed depends on how close Wise sits to each country's payment system. In April 2018 the Bank of England made an announcement. TransferWise, now Wise, was the first non-bank payment provider to join a UK payment system settling in central bank money. It became a direct participant in Faster Payments, the UK's instant bank transfer scheme. Wise wrote in 2025 that it went live with InstaPay in the Philippines. It was also granted access to Zengin in Japan and PIX in Brazil. In its Q2 FY27 results it reported its ninth direct integration, in Malaysia. Where Wise is not connected directly, it uses partners, and partners fail. In November 2026 a Wise engineer described an automatic switch for euro bank pay-ins. Two signals decide it. One is the vendor's declared status. The other is the share of payments that succeed for each vendor and bank. That share is tracked in Redis, an in-memory data store. It first ran in shadow mode, recording what it would have done without acting. When its own data is unreliable, it does nothing. In the interview, give each scheme its own adapter and its own health check.
Reconciliation, returns and keeping each account funded
A ledger that balances can still be wrong if it disagrees with the bank. So reconcile. Load every bank and scheme statement, and match each line to a ledger entry. Anything unmatched on either side is a break that someone must explain. Wise's API docs give two reasons this matters. First, outgoing_payment_sent means Wise sent the money, not that it arrived. Second, a payment can come back. Most bounce backs come within 2 to 3 business days, but some arrive weeks later. Events can also arrive out of order. Wise's webhook docs warn API customers that notifications may not arrive in the order the events happened. So a consumer should use the event's own timestamp. Inside your own system, do better: use the per-transfer version number from the state machine. Liquidity is the other side. Paying out from a local account only works if that account holds enough money. Wise wrote in its Q4 2025 speed update that instant payments to Brazil dipped because of liquidity shortages. This is called prefunding: money has to sit in the payout account before the transfer arrives. In this design Treasury forecasts each route's demand, then buys currency and moves it ahead of time. A trade between banks takes time to settle, so a top-up started too late cannot save a busy afternoon.
Common mistakes candidates make
The first mistake is designing a SWIFT wire. The candidate sends one payment from the UK bank to the German bank and adds a progress bar. Say instead that the money moves as two local payments, joined by Wise's ledger. The second mistake is retrying payments without an idempotency key. A timeout on create transfer or send payout then sends money twice. Name the key, the unique index and what a retry returns. The third mistake is using floating point for money. A close cousin is a balance column updated in place, with no entries behind it. Neither can be audited. Use integer minor units and append-only entries. The fourth mistake is treating sent as arrived. Wise itself warns that outgoing_payment_sent is not proof of credit, and returns can come weeks later. Design the bounce and refund path. The last mistake is ignoring compliance. Checks sit on the critical path of every transfer, and their speed decides how many transfers are instant. On timing, Wise's interview page says the session lasts about an hour. It suggests you clarify the question, start simple and then improve. In this guide's suggestion, spend the first few minutes on questions and the money path. Then give most of the time to the transfer, idempotency and the ledger. Keep the last part for failures, reconciliation and trade-offs.
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.
Local accounts in each country vs one international wire per transfer
Local accounts make most transfers two fast, cheap domestic payments. The cost is that Wise must keep money waiting in every account, called the float. It must also move money between accounts and carry currency risk. A wire needs no float, but it is slower and dearer for the customer. Wise's own guides say the local-account model makes transfers faster and cheaper. The cost of the float is the price of that.
Lock the rate for 30 minutes vs charge the rate at payment time
A locked rate means the customer knows exactly what arrives. The provider carries the risk that the market moves before the money comes in. Charging the live rate removes that risk but breaks the promise shown on screen. A short expiry keeps the risk small.
Consistency over availability for money state
Wise wrote in 2016 that, as a financial service, it always prioritises consistency over availability. A transfer that waits a few seconds is a small problem. A balance that is wrong, or a payout sent twice, is a large one. So transfer state and ledger entries go in ACID databases. Slower reactions such as analytics go through Kafka.
Direct scheme membership vs going through a partner bank
A direct link removes a middleman and its delays and outages. It needs a settlement account at the central bank and a team to run each connection. The Bank of England opened that route to non-bank providers in July 2017. TransferWise joined Faster Payments in April 2018. Partners are faster to add, so a mix is normal: direct where volume is high, partners elsewhere.
Run checks inline vs after the money is sent
Inline checks slow every transfer, but they stop bad money before it leaves. Checking afterwards is fast but cannot recall money already paid out. So checks stay on the path, and the work is to make them fast. Wise's speed updates link faster internal checks to more instant transfers.
Synchronous side effects vs events on Kafka
Doing fraud checks, emails and analytics inside the state change is simple. But it couples their failures to the transfer. Wise wrote in 2016 that it wanted these reactions to run as events. The cost is eventual consistency: readers of those events catch up a moment later. That is fine for an email, but not for a balance.
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 payout request to the partner bank times out. Did the money go?
You do not know, so do not send it again blindly. Before sending, write a payout record with your own unique reference and the status sending. If the partner supports duplicate checks on that reference, use them, but many schemes do not. Mark the payout as unknown. Ask the partner for its status, or wait for the statement. Resend only once reconciliation proves the first attempt failed.
Can one quote be used to create two transfers?
In this design, no. Creating a transfer moves the quote from PENDING to ACCEPTED in the same transaction, guarded on the old status. A second transfer on that quote then fails. These quote statuses are the ones Wise's API returns.
The sender paid by card and the recipient got the money in seconds. Then the card payment is charged back. What now?
The money has already left, so the provider carries the loss. Wise's docs list charged_back as a state that can follow any other status. In this design, card pay-ins get stricter fraud scoring, or a short hold, before an instant payout. The loss is recorded in the ledger against a losses account.
Wise's euro account in Europe is running low. What happens to new transfers?
In this design, Treasury sees it coming from its real-time view of each account. It tops the account up ahead of demand. If it still runs short, transfers on that route are slower until the money arrives. Wise reported exactly this effect for Brazil, where liquidity shortages lowered the share of instant payments.
How do you measure whether Wise is up?
Measure the business flow, not one server. Wise wrote in 2024 that send money is made of several operations. Examples are get a quote, set up a transfer and pay in. It reported API uptime for Q2 2024 between 99.904% and 99.958%. The lower number adds up the downtime of every operation; the upper one is the weakest single operation.
10In production
How Wise actually does it
Every fact about Wise on this page comes from Wise's own writing and filings, plus one Bank of England notice. The estimates and anything marked 'in this design' or 'assume' are ours. The volume, customer and instant figures are from Wise's Q2 FY27 results, published on 15 October 2026. The 20-second description of instant is from Wise's 2025 speed updates. The local-account model is from Wise's own guides to how it works. Wise's API docs are the source for the 30-minute rate lock and the customerTransactionId field. They also give the transfer states and the warning about event order. The service count, Kafka, the databases and the ML platform are from the Wise Tech Stack 2025 update. Consistency over availability and the aim to move side effects to events are from Wise's 2016 stack post. Euro pay-in vendor switching is from a Wise Engineering post of November 2026. The interview format is from Wise's careers page on backend system design interviews. The Treasury Ledger stack is from an undated Wise job posting. It was marked as expired but still online on 15 November 2026. Wise has not published the design of its transfer ledger, so that part of this guide is ours. Say the year when you quote a number in an interview.
Sources
- Wise Group plc reports Q2 FY27 results (October 2026)
- Wise careers: Backend System Design Interviews
- Wise: Q4 2025 Mission Update, Speed
- Wise: Q1 2025 Mission Update, Speed
- Wise: How Wise works in Spain, step by step
- Wise: How Wise works in the UK
- Wise API docs: authenticated quotes
- Wise API docs: create standard transfers
- Wise API docs: transfers
- Wise API docs: transfer statuses
- Wise API docs: webhook event ordering
- Wise Engineering: Wise Tech Stack, 2025 update
- Wise Engineering: The TransferWise Stack (2016)
- Wise Engineering: Learnings from Migrating Legacy to Microservices (2019)
- Wise Engineering: Measuring meaningful availability and uptime of Wise (2024)
- Wise Engineering: How I Built Dynamic Vendor Switching at Wise (2026)
- Wise careers: Software Engineer, Treasury Ledger (undated, expired posting, read 15 Nov 2026; archived copy)
- Bank of England: first non-bank PSP directly accesses a UK payment system (2018)
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
State Machine
advanced / distributed systems core
Transactional Outbox Pattern
intermediate / messaging event systems
Idempotent Consumer
intermediate / messaging event systems
Saga Pattern
advanced / distributed systems core
Event Sourcing
advanced / distributed systems core
Exactly-Once Semantics
advanced / stream batch processing
Circuit Breaker for Resilience
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 (UK)
- Wise system design (this page) (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 Wise 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
- State MachineSystem Design · distributed systems core · 25 min
- Transactional Outbox PatternSystem Design · messaging event systems · 22 min
- Idempotent ConsumerSystem Design · messaging event systems · 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.


