Flipkart Marketplace Platform
A horizontal multi-vendor marketplace sized to the published Flipkart scale — 500M registered customers, 150M products, 1.4M sellers, 6M orders a day, and sale events assumed at ten times the daily average concentrated into a few hours. Eight decisions carry the design: stock is reserved before money is requested, so a failure lands on inventory rather than on a payment; inventory contention is settled by an atomic Redis compare-and-set with an append-only ledger behind it, because 100,000 buyers on one SKU is a queue with a database attached in any other design; the transactional core is sharded PostgreSQL (Citus) because financial correctness has to be a database guarantee rather than an application convention; cart lives on the server, because the deepest trough on the shopper journey is a basket lost to a UPI redirect; the cardholder data environment is a separate Azure subscription, so PCI scope stops at a boundary that is also an RBAC, network and billing boundary; the event backbone is self-managed Kafka, because every derived store in the estate is rebuilt by replaying it and none of them are backed up; the Buy Box is a precomputed multi-factor score, so delivery reliability competes with price; and what degrades at ten times traffic is a written contract behind feature flags, agreed before the sale rather than invented during it.
25 views, each in three formats.
Open a view to read it in full. Every SVG carries its diagram source inside it, so it opens in diagrams.net fully editable with no import step; the draw.io files are the same diagrams as plain source.
-
01
System Context
Who uses the marketplace, what it depends on, and what has deliberately been left outside the line.
-
02
High-Level Architecture
The shape of the platform in one picture, for the reader who will see only one.
-
03
Actors and Their Core Journeys
Who this is for, and what each of them actually gets to do with it — including the machines that act without being asked.
-
04
Journey — Buying in a Sale Hour
The journey that carries the most value and breaks in the most expensive place. Its trough is a structural requirement, not a UX complaint.
-
05
Journey — Seller, Listing to Settlement
The supply side of the marketplace, from a phone-only signup to money in a bank account seven days later.
-
06
Journey — Return and Refund
The journey nobody designs for, which decides how much working capital the platform carries and who eats the loss.
-
07
Layered Architecture
What depends on what, and the one dependency that points the wrong way.
-
08
Container Architecture
The deployable units, the technology each is written in, and the store each one owns.
-
09
Integration Catalogue
Every way this platform touches another system, in both directions, with who owns the contract.
-
10
Data Architecture and Ownership
Which store is the record, which is authored, which is derived — and therefore what has to be backed up.
-
11
Data Flow
Where data comes from, what happens on the way, and who is allowed to consume it.
-
12
Event Backbone
Who publishes, what the topic guarantees, who reacts, and where the result is finally readable.
-
13
Core Data Model
The twelve entities that make this a marketplace rather than a shop, and the key that shards them.
-
14
Checkout and Payment Sequence
The one flow that must never take money without creating an order, or create an order without taking money.
-
15
Inventory Reservation Lifecycle
The hardest component in the marketplace, drawn as the loop it actually is.
-
16
Order Lifecycle and Failure Paths
The state machine the Order service owns, including every way out of it.
-
17
Discovery Pipeline
How 150M listings become a ranked page in under 300 ms, and how the ranking learns.
-
18
Fulfilment and Last Mile
Three supply models, one delivery promise, and the cash that has to come back.
-
19
Deployment Topology
What runs where, what is redundant, and what a region loss actually costs.
-
20
Delivery Pipeline and Environments
How a change reaches production, and every gate that can stop a bad one.
-
21
Observability and Operations
How anyone knows it is working, and who gets woken up when it is not.
-
22
Peak Load and Graceful Degradation
The load-shedding contract, agreed in advance so nobody has to invent it at 02:00.
-
23
Security Zones
Where the trust boundaries are, what crosses them, and where an attacker actually arrives.
-
24
Identity and Access Flow
Who proves what, to whom, in what order — and what happens when a token is stolen.
-
25
Trust and Marketplace Governance
How the marketplace polices itself, from a signal to an enforcement anyone can appeal.
The written architecture.
Everything as it was delivered.
These files are served exactly as they were produced — the diagram pages keep their own house style because that is the artifact, not a rendering of it.