Redesign Your Own Project at Scale
- Draw one core flow from your project in minutes, with real numbers and a reason for every box
- Scale its writes, then its regions: sharding, replication, failover and DNS routing at 100,000 payments a second
- Answer the follow-ups on splitting a monolith, sagas across services and the tools you put on the board
Understanding the problem
Something like this: walk me through your current project end to end. Now imagine it has to handle traffic at the level of Facebook or Google. Redesign it so it works at planet scale.
This is the design round Visa candidates report most. There are eight reports of it since 2020, two of them in the last twelve months. In May 2026 a Staff candidate in Bengaluru drew their current project in Excalidraw and then got the planet-scale follow-up above. In August 2026 a Senior candidate in Bengaluru described their whole design round as a deep discussion of their current project.
Older reports look the same. In a May 2025 hiring manager round, a Bengaluru engineer with ten months of experience got about 40 minutes of resume and design questions. They drew their architecture in Excalidraw and defended its choices on scalability and performance. In an early 2025 onsite, a SWE-I candidate talked through a page's architecture on pen and paper in a round on Java, Spring Boot and design basics. Then came the question of how to show a live count of people on that page without a refresh.
The round has two halves. In the first ten or fifteen minutes you explain what exists, and the interviewer finds out whether you understand your own system. The second half is a design round like any other, except that you chose the starting point. Everything you drew is now evidence. Put Kafka on the board and you'll be asked about Kafka.
Get your project ready before the round
Nobody else can prepare your project for you, but the preparation has a shape. Do it once out loud, with a timer running.
Pick one flow you own
One request path you built or changed, such as a merchant issuing a refund or a user loading search results. A whole platform is too big to draw and too easy to get lost in.
Draw it in under five minutes
Eight boxes or fewer: the client, the entry point, the services, the stores and anything asynchronous. Practice in Excalidraw, since Visa candidates in 2025 and 2026 drew their designs in it.
Know your numbers
Requests a second at peak, rows written a day, the slowest call and how slow it is. If you don't know one, estimate it and say it's an estimate. Keep anything confidential vague.
Have a reason for every box
Why this database, why a queue there, why that cache. "It was already there" is an honest answer. Follow it with what you'd pick today and why.
List what breaks at 10x and 1,000x
Usually the single database primary goes first, then the single data center, then the parts of the monolith everything else calls. Those three are the rest of this lesson.
A worked example with a merchant payments backend
The rest of the lesson runs the method on a made-up project, picked because it looks like a lot of the backends candidates bring. It's an example of the method. It doesn't describe any system at Visa, and its numbers are illustrative. Swap in your own flow and the same questions apply.
The project takes card payments for online merchants. A shopper pays on a merchant's checkout page. The backend asks a card processor to authorize the payment and records it, and the merchant sees it on a dashboard. Today it's a Spring Boot monolith on a handful of servers, with one Postgres primary and a read replica. A notification service and a reporting service were split out later, but they still read the monolith's database directly. Peak traffic is about 200 payments a second, roughly 5 million a day.
Draw this first and talk one payment through from click to dashboard. Then point at the weak spots before the interviewer does. Every write lands on one Postgres primary. Everything runs in one data center. Two services reach straight into the monolith's tables, so nobody can change a column without breaking someone else. Those three problems drive the redesign.
Requirements
Functional requirements
Scope the planet-scale version before drawing anything new. Keep the product the same and change the load. Then ask which part the interviewer cares about most, because "planet scale" can mean far more writes, far more reads or users on every continent. In the May 2026 round it meant write traffic and several data centers.
In scope
- Take a payment: authorize it with the processor and record it exactly once
- Show merchants their payments and each payment's status
- Send notifications and feed reporting from the same payment events
- Keep taking payments when a whole data center goes down
- Show merchants a live count of shoppers on their checkout page
Below the line (call it out, then skip)
- Fraud scoring models and their features
- Settlement and payouts between banks
- The card processor's internals, treated as an outside API
- Merchant onboarding and compliance checks
Non-functional requirements
Correctness on money comes first. A payment must be recorded once, even when the client retries, a server crashes mid-request or a region fails over. That makes the payment write the one place that needs strong consistency. The dashboard and reports can trail by a few seconds. Availability comes next. When our system is down, every merchant loses sales at the same moment. Aim for 99.99%, which is about 52 minutes of downtime a year. One data center can't promise that, so this number is what forces a second region. Latency matters on the checkout path only. The shopper is waiting, so our own work should add under 100 milliseconds at p99 on top of the processor's time. Then put numbers on "planet scale." If the interviewer has none, propose some and write them down.
- Payments: 1.7 billion a day. 20,000 a second on average. Peaks run about five times higher, so plan for 100,000 a second.
- Row writes at peak: 400,000 a second. Each payment touches the database about four times: the insert, two state changes and one outbox event.
- Storage: about 620 TB a year. About 1 KB per payment with its history is 1.7 TB a day before copies. Three copies come to nearly 2 PB a year.
- Availability: 99.99%. About 52 minutes down a year. One data center can't promise that, so the design runs in at least two regions.
The core records, in words
Three records carry the design. A payment is one attempt to take money. Each one holds the merchant, the amount and currency, the idempotency key the client sent, and a state. A new payment starts as created, becomes authorized when the processor approves it, then captured when the merchant collects the money. Some end as declined, voided or refunded instead.
Where a payment lives matters at this scale. The service hashes the merchant id together with the idempotency key to pick a shard, and bakes that shard number into the payment_id it hands back. A retry with the same key always lands on the same shard. A lookup by id can read the shard straight out of the id.
An outbox event is a fact about a payment, such as "p1 was authorized," written in the same transaction as the state change. A relay copies these events to Kafka, and every other part of the system learns about payments from there. A merchant payment view is the dashboard's copy of a payment, grouped by merchant and day and built from those events. It may run a few seconds behind.
| Table | Fields |
|---|---|
| payments (Postgres, sharded) | payment_id · merchant_id · amount · currency · idempotency_key · state · created_at |
| outbox (same shard as its payment) | event_id · payment_id · kind · payload · sent |
| merchant_payments (read store) | merchant_id · day · payment_id · amount · state |
The API
Four calls cover it. Only the payment creation moves money, so it's the one that carries an idempotency key. The live count is a stream of server-sent events (SSE): an HTTP response that stays open and carries updates, which browsers reconnect on their own.
The redesign end to end
The redesign keeps the product and changes three things. Writes spread across many database shards instead of one primary. The system runs in two or more regions, and each region takes live traffic. And services stop sharing a database: they learn about payments from an event log. In the diagram, blue is outside our system, violet is a service we run, amber is the event log, and green is stored state.
1) Find a region. The shopper's browser looks up the API hostname, and GeoDNS answers with the nearest healthy region. Each region runs the whole stack. Every merchant has a home where its payments are written, and the API gateway forwards a payment that lands in the wrong place. Homing a merchant this way means two data centers never write the same payment at the same time. How DNS failover behaves when a region dies has its own deep dive.
2) Take the payment. The Payment service hashes the merchant and idempotency key to pick a shard. It inserts the payment as created, and if the key is already there, it returns the earlier result instead. Then it reserves the amount with the Risk limit service and authorizes with the Card processor. One transaction on the Payment shards moves the payment to authorized and writes an outbox event. Then the service posts entries to the Ledger service and answers the shopper. Notifications, the dashboard and reports are all kept off this path. How 400,000 writes a second fit, and what happens when a middle step fails, are the first deep dives.
3) Spread the news. The Outbox relay on each shard reads unsent events and publishes them to the Kafka event log. The Notification service and the consumer that builds the Merchant read store each read the log at their own pace. Why not have the payment service publish to Kafka directly? Because then the database write and the publish are two separate actions, and a crash between them leaves a payment nobody hears about. Writing the event into the same transaction closes that gap.
4) Serve the dashboard. The Dashboard API answers list pages from the Merchant read store, one merchant and one day per query, and keeps settings and today's totals in the Redis cache. Lists trail checkout by a few seconds. A merchant who just made a test payment and opens it by id reads it from its shard, so the one place where lag would confuse someone doesn't have any.
5) Copy everything to another region. Every shard streams its changes to the Other region copy. Within the region, each primary also waits for a replica in a second building before confirming a commit. Losing a machine or a building costs no data. Losing a whole region costs at most the last moment of replication lag, and the regions deep dive is about making that safe.
Technology choices
- The Payment shards are Postgres. Money needs transactions and unique keys, and a relational database does both well. Split the data into 128 logical shards placed on 64 primaries. When a machine fills up, move whole logical shards to new machines, which avoids rehashing every payment.
- The Kafka event log is Kafka, because several consumers need the same events and a new one may need to replay history. Each partition lives on three brokers, and a write counts only once two copies have it. If a broker dies, another copy takes over its partitions.
- The Merchant read store is Cassandra. It handles very high write volume and reads one partition fast, and every dashboard query is "this merchant, this day." It's eventually consistent, which is fine for a view that's allowed to trail.
- The Redis cache holds what the dashboard reads constantly. It's a cache, never the record. When it's cold or gone, reads fall through to the read store, and a short lock per key stops a thousand requests rebuilding the same entry at once.
- GeoDNS is a managed DNS service such as Route 53 with latency-based routing and health checks. Keep the record's TTL short, around 60 seconds, so a failover reaches most clients within a couple of minutes.
Name the popular tool, then defend the category. If the interviewer's team runs something else, they're checking that you know why you need a log several readers can replay, or a store with transactions.
Potential deep dives
How does the write path take 100,000 payments a second?
Massive write traffic was the first thing the May 2026 interviewer pushed on. Do the arithmetic on the board. At 100,000 payments a second and about four row writes per payment, the database takes 400,000 writes a second at peak. A rough planning figure for one well-tuned Postgres primary, with rows this size and indexes this simple, is around 10,000 writes a second. One machine is short by a factor of 40.
Approach
Move the primary to the largest machine available and add replicas until reads stop hurting.
Challenges
Replicas copy every write, so they take read load and nothing else. Every write still lands on one machine. A bigger box buys maybe two or three times the headroom, nowhere near 40. It also leaves one machine whose failure stops every payment. This is a fine first step at 10x, and you should say exactly that before moving on.
Approach
Split payments across many primaries by hashing the merchant id. All of a merchant's payments sit on one shard, so the dashboard's "this merchant's payments today" query stays a single-shard read, and the idempotency check is a local unique key. Adding shards multiplies write capacity.
Challenges
Merchants aren't the same size. One large retailer on a sale day can send more traffic than thousands of small shops combined, and all of it hits one shard. You can't split that merchant without changing the shard key. Moving a big merchant to a new machine means copying years of its history while it keeps taking payments.
The merchant key keeps the dashboard simple and makes checkout fragile. Flip the priority. Checkout needs even load and the dashboard can tolerate a separate copy, so pick the shard key for checkout and serve the dashboard from somewhere else.
Approach
Hash the merchant id together with the idempotency key. Every checkout attempt has its own key, so even the biggest merchant's traffic spreads over all 128 logical shards. A retry carries the same key and lands on the same shard, so the unique key still catches it. The shard number goes into the payment id, so a lookup by id finds its shard directly. Dashboard lists move to the read store, fed from Kafka. At peak, 64 primaries take about 6,250 writes a second each, well under the planning figure.
Challenges
The write store can no longer answer "all of this merchant's payments" without asking every shard, so nothing on the request path may ask it. The read store trails by seconds, which has to be acceptable. You now run two stores and a pipeline between them, which is real work. It's justified only because the load is real.
Don't put the authorization on a queue to smooth out bursts. The shopper is waiting for approved or declined, so the authorization stays synchronous. Everything after it goes through the outbox. The payment row and the event that announces it commit together:
BEGIN update payment p1: created -> authorized insert outbox event "p1 authorized"COMMITrelay: publish unsent outbox events to Kafka, then mark them sentSeparating the write model from the read model this way is called CQRS. A 2024 Bengaluru Staff round asked about it by name, next to the saga pattern. The scaling writes playbook covers sharding and hot keys in general.
How does it survive losing a whole data center?
Resiliency, a multi data center setup, database replication and DNS routing made up the rest of the May 2026 follow-up list. They're one question really: what happens to a payment in flight when a region disappears? Start from the replication choice, because everything else follows from it. Synchronous replication across regions means waiting for a round trip to another continent, often 70 to 150 milliseconds, on every commit. That breaks the latency budget. So copies to another region are asynchronous, and some lag is unavoidable.
Approach
Run everything in one region and copy nightly backups to another. If the region dies, restore the backups and point DNS at the new place.
Challenges
Restoring hundreds of terabytes takes hours, and everything since the last backup is gone. At 20,000 payments a second, that's up to a day of payments the system has no record of. Even one long outage per year blows through 52 minutes.
Approach
Every shard streams its changes to a replica in a standby region. Health checks watch the primary region. When it fails, promote the standby replicas to primaries and have GeoDNS hand out the standby's address. With a 60-second TTL and about 30 seconds to detect the failure, most traffic moves in two or three minutes.
Challenges
Replication lag is the trap. With half a second of lag at 20,000 payments a second, about 10,000 recent payments never reached the standby. A shopper retrying one of them hits a region that has never seen the key and would authorize again. The processor key stops that, and a daily reconciliation against the processor's records finds the rest. The standby also sits idle, and a failover path that never runs tends to fail the first time it's needed.
Approach
Every region takes live traffic. Each merchant is homed to one region, where its payments are written, and the other side holds copies. Inside a data center, each primary waits for a replica in a second building before confirming, so losing a building loses nothing. When a region dies, the survivor promotes its replicas for the lost merchants, flips the home map, and GeoDNS stops answering with the dead address. Both sides serve real payments every day, so the failover path stays exercised.
Challenges
Each region needs spare capacity to absorb the other's load, so run them at under half capacity. The home-region map becomes critical config: replicate it everywhere and cache it. The cross-region lag still exists, so the processor key and reconciliation still matter. Moving a merchant between regions needs a short write pause for that merchant.
Expect the follow-up "why not let both regions write the same payment?" That setup is called multi-leader replication. Two regions could each authorize the same checkout during a network split. When they reconcile, nothing can take a charge back off the shopper's card automatically. Homing each merchant keeps one writer per payment, which removes those conflicts.
DNS routing has a weakness to name before you're asked. Resolvers and some clients cache answers longer than the TTL says, so a few clients keep trying the dead region for minutes. Many large systems put a global load balancer with anycast addresses in front: the same IP address announced from every region, so the network itself steers traffic to a live one. DNS still picks the nearest region in normal times. Anycast covers the failover gap.
How do you split the monolith without stopping the business?
In the same May 2026 Staff loop, an earlier round asked this as its own question: how would you break a monolith into microservices? The tools that came up were the strangler fig pattern, an API gateway, feature flags and canary deployments. They hold up, and the order you use them in matters.
Approach
Freeze the monolith, build the new services alongside it, and cut all traffic over on a chosen date.
Challenges
For months, every new feature has to be built twice or not at all. The cutover tests everything at once, under real load, with no way back once new payments land in the new databases. Rewrites like this usually miss behavior nobody wrote down, like a rounding rule or a retry quirk merchants rely on.
Put the gateway in front first
Route all traffic through the API gateway, still pointed entirely at the monolith. Nothing changes for users, but every route can now be redirected one at a time.
Pick a seam at the edge
Start with something that has clear inputs and few callers, like notifications or reporting. Leave the payment core for last, once the team has done this a few times.
Give the new service its own data
Stop it reading the monolith's tables. Feed it events instead, at first through change data capture, which reads the database's change log (Debezium does this), until the monolith publishes events itself.
Shift traffic behind a flag, in steps
A feature flag per merchant sends 1% of traffic to the new path, then 5%, 25% and 100%. Watch error rates, latency and a comparison of old and new answers. A bad step flips back in seconds.
Delete the old code
Once the new path has run at 100% for a while, remove the old one from the monolith. Skip this and you run two systems forever.
The name comes from a vine that grows around a tree until it stands on its own. The monolith shrinks one route at a time, and at every point there's a working system and a way back. A canary deployment is the same idea for one release: send it to a small slice of servers or users first, and widen it only while the numbers look normal.
How do transactions work once the data lives in different services?
In that May 2026 Staff loop, the saga came up in the same round as the monolith question. In the monolith, reserving the merchant's limit, recording the payment and posting ledger entries could share one database transaction. Now the risk service, the payment service and the ledger each own their own database, and the card processor is outside entirely. A payment touches all four, and any of them can fail partway through.
Approach
A coordinator asks every service's database to prepare, and commits everywhere only if all of them say yes.
Challenges
While the coordinator waits, every participant holds locks. If the coordinator dies between prepare and commit, those locks stay held until it comes back. Latency becomes the slowest participant's. And the card processor won't take part in our transaction at all, so the most important step can't be covered anyway.
Approach
Break the payment into local steps, each with an undo. Each service listens for the previous step's event and emits its own: the risk service reserves and emits "reserved," the payment service authorizes and emits "authorized," and so on. On a failure, a service emits a failure event and the others run their undo steps.
Challenges
Nobody owns the whole flow. To learn where a payment is stuck, you piece together events from four services. Adding a step means changing several services. Two services that each wait for the other's event can stall forever without anyone noticing.
Approach
The payment service runs the steps in order: reserve the amount, authorize, post ledger entries. The payment's own state records how far the saga got. Each step is retried a few times with backoff and jitter, and each carries a key derived from the payment id, so a repeat is harmless. If a step still fails, the service undoes the finished steps in reverse: void the authorization, then release the reservation. Undo steps are retried until they succeed.
Challenges
There's no isolation. For a few hundred milliseconds other readers can see the amount reserved for a payment that will fail, so the state must say "pending" honestly. Undo steps must also be idempotent. And the orchestrator becomes critical code, so it needs the same care as the payment shards.
Jitter means each retry waits a slightly random time, so a thousand payments that failed together don't all retry in the same millisecond and knock the service over again. Visa interviewers have asked about it by name: a February 2026 Lead Engineer round asked what goes wrong with retries and why jitter helps. Once captured, a payment is no longer undone by voiding. It's refunded, which is a new payment going the other way.
How do you show a live visitor count without a page refresh?
An early 2025 SWE-I onsite asked how to show the live count of users visiting a page without a refresh, after the candidate explained that page's architecture. In the example project, the merchant wants to see how many shoppers are on their checkout page right now. Say there are a million shoppers on checkout pages at peak, and some merchants have tens of thousands at once.
Approach
The dashboard asks for the count every second, and the server counts recent page views in the database.
Challenges
Each poll runs a count query against a busy table. Ten thousand open dashboards make ten thousand queries a second, most of them returning the number they returned a second ago. It also leaves the hard part unanswered: how the server knows who is still on the page.
Approach
Each checkout page opens a WebSocket to a gateway. On connect, the gateway increments the merchant's counter in Redis. On disconnect, it decrements it. The dashboard holds an SSE stream and gets each new count pushed.
Challenges
A gateway that crashes never sends its decrements, so the count drifts upward and stays wrong. Phones drop connections without a clean close. And a merchant with 50,000 shoppers changes its count hundreds of times a second, which no human can read.
Approach
Each checkout page sends a heartbeat every 15 seconds. The gateway records it in a Redis sorted set per merchant, scored by time. The live count is the number of entries newer than 30 seconds, and older entries are trimmed as it goes. Nobody has to say goodbye: a shopper who closes the tab simply stops sending. Every two seconds, the live count gateway reads each watched merchant's count and pushes it to that merchant's open dashboards.
Challenges
A million shoppers at one heartbeat per 15 seconds is about 67,000 Redis writes a second, which needs a few Redis shards split by merchant. One huge merchant makes one hot key. For those, each gateway keeps its own count in memory and writes a total every few seconds. The count then becomes the sum of gateway totals, slightly stale and far cheaper.
Say out loud that the count is approximate and that's fine. A merchant can't tell 10,412 shoppers from 10,398, and nobody's money depends on it. That's the opposite of the payment path, and naming the difference shows you match each consistency choice to what's at stake. The real-time updates playbook compares polling, SSE and WebSockets in general.
What will they ask about Kafka, the cache and the database?
Whatever you draw gets questioned. Across levels, Visa interviewers follow your own diagram with Kafka, caching and database-choice questions, and the 2026 Staff loop asked how Kafka partitions are copied to a second data center. Have one solid answer per box.
| You drew | Expect to be asked | An answer that holds |
|---|---|---|
| Kafka | Why not a plain queue? | Several consumers read the same events, and a new one can replay history. A work queue hands each message to one consumer and then deletes it. |
| Kafka | What if a consumer gets an event twice? | It will, after a crash or a rebalance. Each consumer stores the event ids it has handled, or makes its write an upsert keyed on the payment. |
| Kafka | What if a broker dies? | Each partition has three copies and a write needs two. Another copy takes over, and producers retry. |
| Redis cache | What happens when it goes down? | Reads fall through to the read store and get slower. Checkout never reads the cache, so payments keep working. |
| Redis cache | How stale can it be? | Settings for a minute, totals for a few seconds. Never cache a payment's status for the merchant who just made it. |
| Postgres | Why not Cassandra or MongoDB for payments? | Payments need multi-row transactions and unique keys. Cassandra takes the read model, where queries are known and volume is high. |
| Microservices | Why split at all? | Teams deploy and scale independently. The cost is network calls, sagas and harder debugging, so split only where those pay off. |
Practice the core in code
The saga is the part of this design that's easiest to get subtly wrong, so shrink it to one function. It runs the payment's steps in order, retries a failing step a fixed number of times, and if the step still fails, undoes the finished ones newest first. Each service and network call is replaced by a count of how many times that step fails before it works.
Payment saga: retry, then compensate
Problem
max_attempts tries, it undoes every finished step.Write
run_saga(steps, fail_counts, max_attempts). steps is a list of step names, and fail_counts[i] is how many times step i fails before its first success. Run the steps in order and return a log as a list of strings.For every attempt at a step, log "do" plus the step name if it succeeds. If it fails and attempts remain, log "retry" plus the name. If it fails on its last allowed attempt, log "fail" plus the name.
After a fail, log "undo" plus the name of each finished step, newest first, then "compensated", and stop. If every step succeeds, end the log with "committed". Undo steps always succeed, and
max_attempts is at least 1.The authorization fails once, has attempts left, and works on the retry. Every step finishes, so the saga commits.
Simulate it. Keep a list of finished steps as a stack. For each step, try up to max_attempts times. On a final failure, pop the stack to log the undo steps.
Payment saga: retry, then compensate
Click "Run" to execute your code
What is expected at each level
Software Engineer and SWE-I
Mostly breadth, about 80/20. You explain your flow end to end without gaps, from the browser to the database and back, and you know why each piece is there. When asked to scale it, you reach for the standard moves in a sensible order: cache the hot reads, add replicas, then shard, and say what each one fixes. In one May 2025 Bengaluru loop, this conversation filled about 40 minutes of the hiring manager round, with questions on scalability and performance trade-offs. The bar: a clear drawing of your own system, honest numbers, and one scaling step you can defend in detail.
Senior
About 60/40. Find the bottleneck yourself: do the write arithmetic and conclude one primary can't take it. Choose a shard key and defend it against hot merchants. Close the dual-write gap with an outbox without being led there. An August 2026 Bengaluru Senior candidate described the round as a "deep discussion on current project," so the questions follow whatever you drew. The bar: you reach the Great tier on writes unprompted and can explain why sharding by merchant wasn't enough, or you lay out the monolith split in a safe order.
Staff
About 40/60. The planet-scale version reported in 2026 came at this level. Lead the whole way: requirements, numbers, then the redesign, with the interviewer redirecting rather than rescuing. Pick replication per data type and explain what a region failure costs in lost writes and minutes. Plan the migration from today's system without a big-bang cutover. Expect sagas, multi data center consistency and Kafka's failure modes. One July 2026 Staff candidate had an interviewer with the camera off who allowed no hints, so practice without help. The bar: you can say what happens to one payment in flight at the moment a region dies, and why the shopper is charged exactly once.
Common questions
Does the Visa system design interview ask about your own project?
Often, yes. It's the most reported design format at Visa, with eight reports since 2020 and two in the last twelve months. Sometimes the whole round is a deep discussion of your current project. Other times you explain it first and then redesign it for much larger scale.
What if my current project is small?
That's normal, and the round is built for it. The interviewer wants to see how you'd change it, so the starting size doesn't matter much. Know its real numbers, then show what breaks first as traffic grows 10 times, then 1,000 times, and what you'd change at each step.
What does "planet scale" mean in a Visa design round?
In the May 2026 Staff round it meant Facebook or Google traffic. The follow-ups were heavy write traffic, resilience, several data centers, database replication and DNS routing. Ask which of those the interviewer cares about most, propose numbers, and design for them.
Key Takeaways
- ✓Prepare one flow you own: drawn in five minutes, with real numbers and a reason for every box.
- ✓At planet scale, shard writes by a key that spreads load, and serve merchant queries from a separate read store.
- ✓Run every region live, home each merchant to one region, and make retries safe with idempotency keys.
- ✓Split the monolith with a gateway, flags and canaries, then hold cross-service payments together with an orchestrated saga.
Visa interview guideKnow what Visa asks before you walk in.
30 coding · 8 system design · 20 behavioral questions
Get their questions first.
InterviewLegend is independent and not affiliated with or endorsed by any company it covers.