1. Introduction — Flipkart, 500M+ Users, Big Billion Days Scale

Flipkart is India's largest e-commerce marketplace, serving over 500 million registered users with more than 150 million products across thousands of categories. Founded in 2007 by Sachin and Binny Bansal, Flipkart has grown from a simple online bookstore into one of the world's most complex distributed e-commerce platforms. In October 2024, Flipkart's flagship event — Big Billion Days (BBD) — recorded over 1.5 billion page views in a single day and processed peak traffic of approximately 1.2 million requests per second (RPS).

Designing a system of this magnitude requires solving incredibly hard engineering problems: maintaining real-time inventory accuracy across millions of sellers, processing flash-sale traffic spikes that exceed 100x normal load within seconds, guaranteeing sub-200ms search latency across a catalog of hundreds of millions of SKUs, and orchestrating a supply chain that delivers orders across 19,000+ pin codes in India within 1–2 days.

This article walks through every major subsystem you would need to build — from the product catalog and inventory management to flash-sale infrastructure, payment processing, fraud detection, and multi-region deployment. We approach this from a Senior+ system design interview perspective, meaning we focus on trade-offs, scaling bottlenecks, and the kind of deep technical decisions that distinguish a Staff Engineer from a mid-level engineer.

Whether you are preparing for a Staff Engineer interview at a FAANG company, building your own marketplace startup, or simply want to understand how massive-scale e-commerce systems work, this guide provides the depth and breadth you need.

2. Requirements — Functional & Non-Functional

Functional Requirements

Non-Functional Requirements

3. Capacity Estimation

Storage Estimation

Bandwidth Estimation

QPS Breakdown by Service

4. Data Model

The data model for an e-commerce platform like Flipkart is one of the most complex in distributed systems. We need to model products, sellers, inventory, orders, payments, users, carts, and their intricate relationships.

Product Entity

public class Product
{
    public long ProductId { get; set; }
    public string Name { get; set; }
    public string Slug { get; set; }
    public long CategoryId { get; set; }
    public long BrandId { get; set; }
    public string Description { get; set; }
    public string MainImageUrl { get; set; }
    public List<string> AdditionalImages { get; set; }
    public ProductStatus Status { get; set; }
    public Dictionary<string, string> Attributes { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
    public double AverageRating { get; set; }
    public int TotalReviews { get; set; }
    public int TotalSold { get; set; }
}

public enum ProductStatus
{
    Active, Inactive, Discontinued, PendingApproval
}

Variant (SKU) Entity

public class ProductVariant
{
    public long VariantId { get; set; }
    public long ProductId { get; set; }
    public string SkuCode { get; set; }
    public decimal Price { get; set; }
    public decimal MrpPrice { get; set; }
    public decimal CostPrice { get; set; }
    public string Size { get; set; }
    public string Color { get; set; }
    public string Material { get; set; }
    public decimal Weight { get; set; }
    public bool IsActive { get; set; }
    public Dictionary<string, string> VariantAttributes { get; set; }
}

Seller Entity

public class Seller
{
    public long SellerId { get; set; }
    public string BusinessName { get; set; }
    public string LegalName { get; set; }
    public string GstNumber { get; set; }
    public string PanNumber { get; set; }
    public SellerStatus Status { get; set; }
    public SellerTier Tier { get; set; }
    public string WarehouseAddress { get; set; }
    public decimal CommissionRate { get; set; }
    public double SellerRating { get; set; }
    public int TotalProducts { get; set; }
    public DateTime OnboardedAt { get; set; }
}

public enum SellerTier
{
    Platinum,  // less than 24h shipping, less than 2% cancellation
    Gold,      // less than 48h shipping, less than 5% cancellation
    Silver,    // Standard SLA
    Bronze     // New sellers
}

Inventory Entity

public class InventoryRecord
{
    public long InventoryId { get; set; }
    public long VariantId { get; set; }
    public long SellerId { get; set; }
    public long WarehouseId { get; set; }
    public int TotalQuantity { get; set; }
    public int ReservedQuantity { get; set; }
    public int AvailableQuantity => TotalQuantity - ReservedQuantity;
    public int ReorderLevel { get; set; }
    public DateTime LastUpdatedAt { get; set; }
    public InventoryStatus Status { get; set; }
}

public enum InventoryStatus
{
    InStock, LowStock, OutOfStock, PreOrder
}

Order Entity

public class Order
{
    public long OrderId { get; set; }
    public string OrderNumber { get; set; }
    public long UserId { get; set; }
    public OrderStatus Status { get; set; }
    public decimal TotalAmount { get; set; }
    public decimal DiscountAmount { get; set; }
    public decimal TaxAmount { get; set; }
    public decimal ShippingCharge { get; set; }
    public decimal PayableAmount { get; set; }
    public long ShippingAddressId { get; set; }
    public PaymentMethod PaymentMethod { get; set; }
    public List<OrderItem> Items { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? ConfirmedAt { get; set; }
    public DateTime? ShippedAt { get; set; }
    public DateTime? DeliveredAt { get; set; }
    public DateTime? CancelledAt { get; set; }
}

public enum OrderStatus
{
    Created, PaymentPending, PaymentConfirmed, Processing,
    Shipped, OutForDelivery, Delivered, Cancelled,
    Returned, Refunded
}

Order Item Entity

public class OrderItem
{
    public long OrderItemId { get; set; }
    public long OrderId { get; set; }
    public long VariantId { get; set; }
    public long SellerId { get; set; }
    public string ProductName { get; set; }
    public string SkuCode { get; set; }
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal DiscountAmount { get; set; }
    public decimal TotalPrice { get; set; }
    public OrderItemStatus Status { get; set; }
    public string? TrackingNumber { get; set; }
    public string? CarrierName { get; set; }
}

Cart Entity

public class ShoppingCart
{
    public long CartId { get; set; }
    public long UserId { get; set; }
    public List<CartItem> Items { get; set; }
    public string? CouponCode { get; set; }
    public decimal CouponDiscount { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime ExpiresAt { get; set; }
}

public class CartItem
{
    public long CartItemId { get; set; }
    public long VariantId { get; set; }
    public int Quantity { get; set; }
    public decimal AddedPrice { get; set; }
    public DateTime AddedAt { get; set; }
}

Category Hierarchy

5. API Design

We design RESTful APIs with versioning (/api/v1/), consistent error handling, and rate limiting. All endpoints require JWT authentication except public catalog browsing.

Standard API Response Format

{
    "status": "success",
    "data": {
        "productId": 12345,
        "name": "Samsung Galaxy S24 Ultra",
        "price": 129999,
        "inStock": true
    },
    "metadata": {
        "requestId": "req_abc123",
        "latencyMs": 42,
        "version": "v1"
    }
}

6. High-Level Architecture

The Flipkart-scale e-commerce platform follows a microservices architecture with domain-driven service boundaries. Each service owns its data, communicates via async events (Kafka) for most flows, and sync gRPC for latency-critical paths.

Architecture Principles

Kafka Event Topics

7. Product Catalog & Search — Elasticsearch

The product catalog is the heart of the e-commerce platform. Flipkart manages over 150 million product listings across thousands of categories, each with varying attributes. The catalog service must support complex queries like "show me red smartphones under 20,000 with 8GB RAM from Samsung, sorted by rating."

Service Architecture

Elasticsearch Index Schema

{
    "mappings": {
        "properties": {
            "product_id": { "type": "long" },
            "name": { "type": "text", "analyzer": "custom_hindi_english" },
            "description": { "type": "text" },
            "category_id": { "type": "keyword" },
            "brand": { "type": "keyword" },
            "seller_id": { "type": "long" },
            "seller_rating": { "type": "float" },
            "price": { "type": "scaled_float", "scaling_factor": 100 },
            "mrp": { "type": "scaled_float", "scaling_factor": 100 },
            "discount_percent": { "type": "integer" },
            "average_rating": { "type": "float" },
            "total_reviews": { "type": "integer" },
            "total_sold": { "type": "integer" },
            "in_stock": { "type": "boolean" },
            "tags": { "type": "keyword" },
            "updated_at": { "type": "date" }
        }
    },
    "settings": {
        "number_of_shards": 50,
        "number_of_replicas": 2,
        "refresh_interval": "3s"
    }
}

Search Ranking Algorithm

Flipkart uses a multi-signal ranking algorithm that considers:

Autocomplete Implementation

Catalog Caching Strategy

8. Inventory Management System

Inventory management is arguably the most critical and challenging component of an e-commerce platform. Getting inventory wrong leads to either overselling (ordering a product that is actually out of stock) or underselling (showing out-of-stock when items are available). Both cost real money.

Inventory Reservation Flow

Inventory Reservation with DynamoDB

We use DynamoDB's conditional writes to implement optimistic concurrency control for inventory updates. This prevents overselling even under extreme concurrency.

public class InventoryService
{
    private readonly IAmazonDynamoDB _dynamoDb;
    private readonly IKafkaProducer _kafkaProducer;

    public async Task<ReservationResult> ReserveInventoryAsync(
        long variantId, int quantity, long orderId)
    {
        var request = new UpdateItemRequest
        {
            TableName = "Inventory",
            Key = new Dictionary<string, AttributeValue>
            {
                { "variant_id", new AttributeValue { N = variantId.ToString() } }
            },
            UpdateExpression = "SET available_qty = available_qty - :qty, " +
                               "reserved_qty = reserved_qty + :qty, " +
                               "last_updated = :now",
            ConditionExpression = "available_qty >= :qty",
            ExpressionAttributeValues = new Dictionary<string, AttributeValue>
            {
                { ":qty", new AttributeValue { N = quantity.ToString() } },
                { ":now", new AttributeValue { S = DateTime.UtcNow.ToString("O") } }
            },
            ReturnValues = ReturnValues.ALL_NEW
        };

        try
        {
            var response = await _dynamoDb.UpdateItemAsync(request);
            var remaining = int.Parse(response.Attributes["available_qty"].N);

            await _kafkaProducer.PublishAsync("inventory.reserved", new
            {
                VariantId = variantId,
                OrderId = orderId,
                Quantity = quantity,
                RemainingStock = remaining
            });

            return new ReservationResult
            {
                Success = true,
                RemainingStock = remaining,
                ReservationId = Guid.NewGuid().ToString()
            };
        }
        catch (ConditionalCheckFailedException)
        {
            return new ReservationResult
            {
                Success = false,
                RemainingStock = await GetAvailableStockAsync(variantId)
            };
        }
    }

    private async Task<int> GetAvailableStockAsync(long variantId)
    {
        var response = await _dynamoDb.GetItemAsync(new GetItemRequest
        {
            TableName = "Inventory",
            Key = new Dictionary<string, AttributeValue>
            {
                { "variant_id", new AttributeValue { N = variantId.ToString() } }
            },
            ProjectionExpression = "available_qty"
        });
        return int.Parse(response.Item["available_qty"].N);
    }
}

Multi-Warehouse Inventory Strategy

9. Shopping Cart Service

The shopping cart is a high-write, high-read service that must persist across sessions and devices. Flipkart's cart handles an average of 8 million concurrent carts with real-time price recalculation.

Cart Storage Design

Cart Data in Redis

{
    "cart:user:12345": {
        "user_id": 12345,
        "items": [
            {
                "variant_id": 98765,
                "product_name": "iPhone 15 Pro Max",
                "seller_id": 101,
                "quantity": 1,
                "price_at_add": 159900,
                "current_price": 154900,
                "added_at": "2026-07-14T10:30:00Z",
                "in_stock": true,
                "delivery_eta": "2 days"
            },
            {
                "variant_id": 87654,
                "product_name": "AirPods Pro 2",
                "seller_id": 102,
                "quantity": 2,
                "price_at_add": 24900,
                "current_price": 22900,
                "added_at": "2026-07-13T15:45:00Z",
                "in_stock": true,
                "delivery_eta": "1 day"
            }
        ],
        "coupon_code": "FLAT1000",
        "total_items": 3,
        "last_updated": "2026-07-14T10:30:00Z"
    }
}

Price Reconciliation Flow

On every cart view and at checkout, the Cart Service calls the Pricing Service to fetch current prices for all items. If the price has changed, the response includes both price_at_add and current_price. The frontend displays: "Price updated: was 1,59,900, now 1,54,900 — you save 5,000!"

10. Order Management & State Machine

Order management is the most complex stateful workflow in e-commerce. An order goes through 10+ states, involves multiple services (inventory, payment, shipping, seller), and must handle edge cases like partial fulfillment, split shipments, and refunds.

Order State Machine

Order State Machine Validation

public static class OrderStateMachine
{
    private static readonly Dictionary<OrderState, HashSet<OrderState>> 
        Transitions = new()
    {
        [OrderState.Created] = new() { OrderState.PaymentPending },
        [OrderState.PaymentPending] = new()
        {
            OrderState.PaymentConfirmed,
            OrderState.Cancelled
        },
        [OrderState.PaymentConfirmed] = new()
        {
            OrderState.Processing,
            OrderState.Cancelled
        },
        [OrderState.Processing] = new()
        {
            OrderState.Shipped,
            OrderState.Cancelled
        },
        [OrderState.Shipped] = new()
        {
            OrderState.OutForDelivery,
            OrderState.Delivered
        },
        [OrderState.OutForDelivery] = new()
        {
            OrderState.Delivered,
            OrderState.Shipped
        },
        [OrderState.Delivered] = new()
        {
            OrderState.ReturnRequested
        },
        [OrderState.ReturnRequested] = new()
        {
            OrderState.Returned,
            OrderState.Delivered
        },
        [OrderState.Returned] = new() { OrderState.Refunded },
        [OrderState.Cancelled] = new() { OrderState.Refunded }
    };

    public static bool CanTransition(OrderState from, OrderState to)
    {
        return Transitions.ContainsKey(from) && Transitions[from].Contains(to);
    }
}

Order Placement Service

public class OrderService
{
    private readonly IOrderRepository _orderRepo;
    private readonly IInventoryService _inventoryClient;
    private readonly IPaymentService _paymentClient;
    private readonly IKafkaProducer _kafkaProducer;

    public async Task<OrderResult> PlaceOrderAsync(PlaceOrderRequest request)
    {
        // 1. Validate cart items and prices
        var cartItems = await ValidateCartItemsAsync(request.UserId, request.Items);
        if (!cartItems.IsValid)
            return OrderResult.Fail("Cart validation failed");

        // 2. Reserve inventory for each item
        var reservations = new List<InventoryReservation>();
        foreach (var item in cartItems.Items)
        {
            var reservation = await _inventoryClient.ReserveAsync(
                item.VariantId, item.Quantity);
            if (!reservation.Success)
            {
                await RollbackReservationsAsync(reservations);
                return OrderResult.Fail(
                    $"Item {item.ProductName} is out of stock");
            }
            reservations.Add(reservation);
        }

        // 3. Calculate pricing (taxes, discounts, shipping)
        var pricing = await CalculatePricingAsync(cartItems, request);

        // 4. Create order
        var order = new Order
        {
            OrderId = GenerateOrderId(),
            UserId = request.UserId,
            Status = OrderState.PaymentPending,
            TotalAmount = pricing.Subtotal,
            DiscountAmount = pricing.Discount,
            TaxAmount = pricing.Tax,
            ShippingCharge = pricing.Shipping,
            PayableAmount = pricing.Total,
            CreatedAt = DateTime.UtcNow
        };

        await _orderRepo.SaveAsync(order);

        // 5. Initiate payment
        await _paymentClient.InitiatePaymentAsync(
            order.OrderId, order.PayableAmount, request.PaymentMethod);

        // 6. Publish event
        await _kafkaProducer.PublishAsync("order.created", new
        {
            OrderId = order.OrderId,
            UserId = order.UserId,
            TotalAmount = order.PayableAmount,
            ItemCount = order.Items.Count
        });

        return OrderResult.Success(order);
    }
}

Split Shipment Handling

11. Flash Sale & High-Traffic Events

Flash sales like Big Billion Days are the single most challenging engineering event for Flipkart. Traffic spikes from 50K RPS to 1.2M RPS (24x) within minutes. Every component must be pre-scaled and battle-tested.

Flash Sale Infrastructure

Virtual Waiting Room

Flash Sale Flow

1. Pre-sale (T-24h): Deal pages are pre-rendered and cached on CDN. Inventory is pre-allocated in Redis. Elasticsearch indexes updated with sale prices.
2. Sale opens (T-0): CDN serves cached pages. Users see the deal page with a countdown timer reaching zero.
3. Grab phase (T+0 to T+5min): Users click "Buy Now." Rate limiter allows 1 attempt per 10 seconds per user. Queue manager assigns positions.
4. Reservation (T+5s to T+30s): For users at the front of the queue, the Grab Service attempts to reserve inventory using Redis Lua atomic scripts.
5. Checkout (T+30s to T+10min): Successfully reserved items move to checkout. User has 10 minutes to complete payment before reservation expires.
6. Payment (T+30s to T+15min): Payment is initiated. On success, order is created. On failure, inventory is released back to the pool.

Redis Lua Script for Atomic Inventory Grab

// Lua script for atomic inventory decrement
// KEYS[1] = inventory:{variant_id}
// ARGV[1] = quantity to reserve
// ARGV[2] = user_id (for idempotency)

local inventory_key = KEYS[1]
local quantity = tonumber(ARGV[1])
local user_id = ARGV[2]

-- Check if already reserved by this user
local existing = redis.call('HGET', inventory_key, 'user:' .. user_id)
if existing then
    return {0, 'ALREADY_RESERVED'}
end

-- Get current stock
local stock = tonumber(redis.call('HGET', inventory_key, 'stock') or '0')
if stock < quantity then
    return {0, 'OUT_OF_STOCK', stock}
end

-- Decrement stock and add reservation
redis.call('HINCRBY', inventory_key, 'stock', -quantity)
redis.call('HSET', inventory_key, 'user:' .. user_id, quantity)

-- Set TTL for reservation (10 minutes)
redis.call('EXPIRE', inventory_key, 600)

return {1, 'RESERVED', stock - quantity}

Pre-Sale Load Testing Results

12. Pricing & Discount Engine

Flipkart's pricing engine handles complex pricing rules: seller-set prices, platform discounts, bank offers, coupon codes, flash sale prices, bundle pricing, and dynamic pricing. The engine must calculate the final price for a cart with items from multiple sellers and applicable offers.

Pricing Calculation Pipeline

Discount Rules Engine

public class PricingEngine
{
    private readonly ICouponRepository _couponRepo;
    private readonly IBankOfferRepository _bankOfferRepo;
    private readonly ILoyaltyService _loyaltyService;

    public async Task<PricingResult> CalculatePriceAsync(
        List<CartLineItem> items, UserContext user, OrderContext context)
    {
        var result = new PricingResult();
        var sellerGroups = items.GroupBy(i => i.SellerId);

        foreach (var group in sellerGroups)
        {
            var sellerPricing = new SellerPricing { SellerId = group.Key };

            foreach (var item in group)
            {
                var linePrice = new LineItemPricing
                {
                    VariantId = item.VariantId,
                    BasePrice = item.MrpPrice,
                    Quantity = item.Quantity
                };

                // Step 1: Platform discount
                linePrice.PlatformDiscount =
                    await CalculatePlatformDiscountAsync(item);

                // Step 2: Seller discount
                linePrice.SellerDiscount =
                    await CalculateSellerDiscountAsync(item, group.Key);

                // Step 3: Flash sale price (overrides if applicable)
                linePrice.FlashSalePrice =
                    await GetFlashSalePriceAsync(item.VariantId);

                linePrice.SellingPrice = linePrice.FlashSalePrice
                    ?? (linePrice.BasePrice - linePrice.PlatformDiscount
                        - linePrice.SellerDiscount);

                sellerPricing.LineItems.Add(linePrice);
            }

            // Step 4: Shipping per seller
            sellerPricing.Shipping = await CalculateShippingAsync(
                group.ToList(), context.DeliveryPincode, group.Key);

            // Step 5: Tax per seller (GST)
            sellerPricing.Tax = CalculateGST(
                sellerPricing.LineItems, context.DeliveryState);

            result.SellerPricings.Add(sellerPricing);
        }

        // Step 6: Coupon discount
        if (!string.IsNullOrEmpty(context.CouponCode))
        {
            result.CouponDiscount = await ApplyCouponAsync(
                context.CouponCode, result, user);
        }

        // Step 7: Bank offer
        if (!string.IsNullOrEmpty(context.BankOfferId))
        {
            result.BankCashback = await ApplyBankOfferAsync(
                context.BankOfferId, result.Total);
        }

        // Step 8: Loyalty points discount
        result.LoyaltyDiscount = await _loyaltyService
            .CalculateDiscountAsync(user.UserId, result.Total);

        result.Total = result.SellerPricings.Sum(s => s.Total)
            - result.CouponDiscount - result.LoyaltyDiscount;
        result.TotalTax = result.SellerPricings.Sum(s => s.Tax);
        result.TotalSavings = result.SellerPricings
            .Sum(s => s.LineItems.Sum(l => l.BasePrice - l.SellingPrice))
            + result.CouponDiscount + result.BankCashback;

        return result;
    }
}

Discount Types Supported

13. Seller Platform & Marketplace

Flipkart hosts over 500,000 active sellers who list products, manage inventory, fulfill orders, and handle returns. The seller platform is essentially a B2B SaaS product for sellers of all sizes.

Seller Platform Architecture

Seller Onboarding Flow

1. Registration: Seller provides business details, GST number, PAN, bank account
2. GST Verification: Real-time verification via GST API (government portal)
3. KYC Check: PAN verification, bank account penny-drop verification
4. Category Approval: Some categories (electronics, fashion) require additional approvals
5. Product Listing: Seller uploads products via bulk CSV upload or API integration
6. Quality Check: Automated + manual review of product listings for compliance
7. Go Live: First 10 products listed, seller can start receiving orders

Settlement Engine

14. Payment Processing

Payment is the highest-stakes service in the platform. A payment failure or double-charge erodes customer trust immediately. Flipkart supports 15+ payment methods including UPI, credit/debit cards, net banking, EMI, wallets (PhonePe, Google Pay), and Cash on Delivery (COD).

Payment Flow

Payment States

Idempotency and Exactly-Once Payment

15. Shipping & Logistics

Flipkart operates one of India's largest logistics networks through Ekart Logistics, its in-house delivery arm. The shipping service must calculate delivery estimates, optimize routes, manage last-mile delivery, and handle COD collections.

Shipping Architecture

Delivery Estimation Algorithm

16. Recommendation Engine

Recommendations drive 35-40% of Flipkart's revenue. The system processes behavioral signals from 500M+ users and generates personalized product suggestions across multiple surfaces.

Recommendation Architecture

Recommendation Types

17. Review & Rating System

The review and rating system builds customer trust and drives conversion. Flipkart processes millions of reviews with image uploads, verified purchase badges, and multi-dimensional ratings.

Review Data Model

public class ProductReview
{
    public long ReviewId { get; set; }
    public long ProductId { get; set; }
    public long UserId { get; set; }
    public long OrderId { get; set; }
    public int OverallRating { get; set; }        // 1-5 stars
    public int ValueForMoneyRating { get; set; }  // 1-5
    public int QualityRating { get; set; }        // 1-5
    public int DeliveryRating { get; set; }       // 1-5
    public string Title { get; set; }
    public string Body { get; set; }
    public List<string> ImageUrls { get; set; }
    public bool IsVerifiedPurchase { get; set; }
    public bool IsHelpful { get; set; }
    public int HelpfulCount { get; set; }
    public ReviewStatus Status { get; set; }
    public SellerResponse? SellerReply { get; set; }
    public DateTime CreatedAt { get; set; }
}

Rating Aggregation

18. Notification System

Flipkart sends over 500 million notifications daily across push notifications, SMS, email, and in-app messages. The notification system must handle high throughput, support multi-channel delivery, and respect user preferences.

Notification Channels and SLAs

Notification Template System

19. Fraud Detection

E-commerce platforms lose 2-5% of revenue to fraud. Flipkart's fraud detection system must identify fraudulent orders in real-time (within 200ms) without adding friction to legitimate customers.

Fraud Signals

Fraud Decision Engine

20. Database Sharding

At Flipkart's scale, a single PostgreSQL instance cannot handle the data volume or throughput. We shard databases across multiple dimensions depending on the access pattern.

Sharding Architecture

Sharding Keys and Strategies

Cross-Shard Queries

21. Caching Strategy — Redis, CDN

Caching is critical for e-commerce performance. Flipkart's caching infrastructure saves an estimated 40% of database load and reduces P99 latency from 500ms to under 100ms for cached paths.

Multi-Level Cache Architecture

Cache Invalidation Strategies

Redis Cluster Configuration

22. Multi-Region Design

Flipkart operates primarily in India but serves customers across the country with varying network conditions. The multi-region design ensures low latency for customers in metros (Delhi, Mumbai, Bangalore) as well as tier-2 and tier-3 cities.

Multi-Region Architecture

Disaster Recovery RTO/RPO

23. Cost Estimation

Monthly Infrastructure Cost (AWS Mumbai Region)

24. Interview Q&A — 10+ Questions

25. Full C# Implementation — 300+ Lines

Below is a complete, production-grade C# implementation of the core Order Management Service, including the state machine, inventory reservation, pricing engine, and Kafka integration.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Text.Json;
using System.Security.Cryptography;

// ============================================================
// DOMAIN MODELS
// ============================================================

namespace Flipkart.OrderService.Domain
{
    public enum OrderState
    {
        Created, PaymentPending, PaymentConfirmed,
        Processing, Shipped, OutForDelivery, Delivered,
        Cancelled, Returned, Refunded
    }

    public enum PaymentMethod
    {
        Upi, CreditCard, DebitCard, NetBanking,
        Wallet, CashOnDelivery, EMI
    }

    public enum InventoryReservationStatus
    {
        Reserved, Failed, Released
    }

    public record ProductVariantInfo(
        long VariantId, long SellerId, string ProductName,
        string SkuCode, decimal MrpPrice, decimal SellingPrice,
        int AvailableQuantity);

    public record Address(
        string Line1, string Line2, string City,
        string State, string Pincode, string Country);

    public class OrderItem
    {
        public long OrderItemId { get; set; }
        public long VariantId { get; set; }
        public long SellerId { get; set; }
        public string ProductName { get; set; } = string.Empty;
        public string SkuCode { get; set; } = string.Empty;
        public int Quantity { get; set; }
        public decimal UnitPrice { get; set; }
        public decimal DiscountAmount { get; set; }
        public decimal TaxAmount { get; set; }
        public decimal TotalPrice { get; set; }
        public OrderState Status { get; set; }
        public string? TrackingNumber { get; set; }
    }

    public class Order
    {
        public long OrderId { get; set; }
        public string OrderNumber { get; set; } = string.Empty;
        public long UserId { get; set; }
        public OrderState Status { get; set; }
        public decimal TotalAmount { get; set; }
        public decimal DiscountAmount { get; set; }
        public decimal TaxAmount { get; set; }
        public decimal ShippingCharge { get; set; }
        public decimal PayableAmount { get; set; }
        public PaymentMethod PaymentMethod { get; set; }
        public Address ShippingAddress { get; set; } = null!;
        public List<OrderItem> Items { get; set; } = new();
        public List<InventoryReservation> Reservations { get; set; } = new();
        public DateTime CreatedAt { get; set; }
        public DateTime? ConfirmedAt { get; set; }
        public DateTime? ShippedAt { get; set; }
        public DateTime? DeliveredAt { get; set; }
        public DateTime? CancelledAt { get; set; }
        public string? CancellationReason { get; set; }
        public DateTime UpdatedAt { get; set; }
    }

    public class InventoryReservation
    {
        public string ReservationId { get; set; } = string.Empty;
        public long VariantId { get; set; }
        public int Quantity { get; set; }
        public InventoryReservationStatus Status { get; set; }
        public DateTime ReservedAt { get; set; }
        public DateTime ExpiresAt { get; set; }
    }

    public class PricingBreakdown
    {
        public decimal Subtotal { get; set; }
        public decimal PlatformDiscount { get; set; }
        public decimal CouponDiscount { get; set; }
        public decimal ShippingCharge { get; set; }
        public decimal TaxAmount { get; set; }
        public decimal TotalPayable { get; set; }
        public decimal TotalSavings { get; set; }
        public List<SellerPricing> SellerPricings { get; set; } = new();
    }

    public class SellerPricing
    {
        public long SellerId { get; set; }
        public decimal Subtotal { get; set; }
        public decimal Discount { get; set; }
        public decimal Tax { get; set; }
        public decimal Shipping { get; set; }
        public decimal Total => Subtotal - Discount + Tax + Shipping;
    }

    public record PlaceOrderRequest(
        long UserId, List<OrderItemRequest> Items,
        Address ShippingAddress, PaymentMethod PaymentMethod,
        string? CouponCode);

    public record OrderItemRequest(long VariantId, int Quantity);

    public record OrderResult(bool Success, Order? Order, string? ErrorMessage)
    {
        public static OrderResult Fail(string error) =>
            new(false, null, error);
        public static OrderResult Success(Order order) =>
            new(true, order, null);
    }

    // ============================================================
    // STATE MACHINE
    // ============================================================

    public static class OrderStateMachine
    {
        private static readonly Dictionary<OrderState, HashSet<OrderState>>
            Transitions = new()
        {
            [OrderState.Created] = new() { OrderState.PaymentPending },
            [OrderState.PaymentPending] = new()
                { OrderState.PaymentConfirmed, OrderState.Cancelled },
            [OrderState.PaymentConfirmed] = new()
                { OrderState.Processing, OrderState.Cancelled },
            [OrderState.Processing] = new()
                { OrderState.Shipped, OrderState.Cancelled },
            [OrderState.Shipped] = new()
                { OrderState.OutForDelivery, OrderState.Delivered },
            [OrderState.OutForDelivery] = new()
                { OrderState.Delivered, OrderState.Shipped },
            [OrderState.Delivered] = new()
                { OrderState.ReturnRequested },
            [OrderState.ReturnRequested] = new()
                { OrderState.Returned, OrderState.Delivered },
            [OrderState.Returned] = new() { OrderState.Refunded },
            [OrderState.Cancelled] = new() { OrderState.Refunded }
        };

        private static readonly HashSet<OrderState> TerminalStates = new()
            { OrderState.Refunded, OrderState.Delivered };

        public static bool CanTransition(OrderState from, OrderState to)
            => Transitions.ContainsKey(from) && Transitions[from].Contains(to);

        public static bool IsTerminal(OrderState state)
            => TerminalStates.Contains(state);

        public static OrderState ValidateTransition(
            OrderState current, OrderState target)
        {
            if (!CanTransition(current, target))
                throw new InvalidOperationException(
                    $"Invalid transition: {current} to {target}");
            return target;
        }
    }

    // ============================================================
    // SERVICE INTERFACES
    // ============================================================

    public interface IInventoryService
    {
        Task<List<ProductVariantInfo>> GetVariantsAsync(
            List<long> variantIds);
        Task<InventoryReservation> ReserveAsync(
            long variantId, int quantity, long orderId);
        Task<bool> ReleaseReservationAsync(string reservationId);
        Task<bool> ConfirmReservationAsync(string reservationId);
    }

    public interface IPricingEngine
    {
        Task<PricingBreakdown> CalculateAsync(
            List<OrderItemRequest> items,
            long userId, string? couponCode);
    }

    public interface IPaymentService
    {
        Task<string> InitiatePaymentAsync(
            long orderId, decimal amount, PaymentMethod method);
        Task<bool> RefundAsync(long orderId, decimal amount);
    }

    public interface IKafkaProducer
    {
        Task PublishAsync<T>(string topic, T message);
    }

    public interface IOrderRepository
    {
        Task<Order> SaveAsync(Order order);
        Task<Order?> GetByIdAsync(long orderId);
        Task<Order?> GetByNumberAsync(string orderNumber);
        Task<List<Order>> GetUserOrdersAsync(
            long userId, int page, int pageSize);
    }

    public interface IIdGenerator
    {
        long NextOrderId();
        string GenerateOrderNumber();
    }

    // ============================================================
    // ORDER SERVICE - MAIN IMPLEMENTATION
    // ============================================================

    public class OrderService
    {
        private readonly IInventoryService _inventory;
        private readonly IPricingEngine _pricing;
        private readonly IPaymentService _payment;
        private readonly IKafkaProducer _kafka;
        private readonly IOrderRepository _orderRepo;
        private readonly IIdGenerator _idGenerator;

        private const int ReservationTtlMinutes = 10;
        private const int MaxItemsPerOrder = 50;
        private const decimal MaxCodAmount = 50000m;

        public OrderService(
            IInventoryService inventory,
            IPricingEngine pricing,
            IPaymentService payment,
            IKafkaProducer kafka,
            IOrderRepository orderRepo,
            IIdGenerator idGenerator)
        {
            _inventory = inventory;
            _pricing = pricing;
            _payment = payment;
            _kafka = kafka;
            _orderRepo = orderRepo;
            _idGenerator = idGenerator;
        }

        public async Task<OrderResult> PlaceOrderAsync(
            PlaceOrderRequest request)
        {
            // Step 1: Validate request
            var validation = ValidateRequest(request);
            if (!validation.IsValid)
                return OrderResult.Fail(validation.Error!);

            // Step 2: Fetch variant details
            var variantIds = request.Items
                .Select(i => i.VariantId).ToList();
            var variants = await _inventory
                .GetVariantsAsync(variantIds);

            var validationResult = ValidateVariants(
                request.Items, variants);
            if (!validationResult.IsValid)
                return OrderResult.Fail(validationResult.Error!);

            // Step 3: Reserve inventory for all items
            var reservations = new List<InventoryReservation>();
            try
            {
                foreach (var item in request.Items)
                {
                    var reservation = await _inventory.ReserveAsync(
                        item.VariantId, item.Quantity, orderId: 0);

                    if (reservation.Status
                        != InventoryReservationStatus.Reserved)
                    {
                        await RollbackReservationsAsync(reservations);
                        var variant = variants.First(v =>
                            v.VariantId == item.VariantId);
                        return OrderResult.Fail(
                            $"Insufficient stock for {variant.ProductName}");
                    }
                    reservations.Add(reservation);
                }
            }
            catch (Exception ex)
            {
                await RollbackReservationsAsync(reservations);
                return OrderResult.Fail(
                    $"Inventory reservation failed: {ex.Message}");
            }

            // Step 4: Calculate pricing
            var pricing = await _pricing.CalculateAsync(
                request.Items, request.UserId, request.CouponCode);

            // Step 5: Validate COD amount limit
            if (request.PaymentMethod
                == PaymentMethod.CashOnDelivery
                && pricing.TotalPayable > MaxCodAmount)
            {
                await RollbackReservationsAsync(reservations);
                return OrderResult.Fail(
                    $"COD not available above {MaxCodAmount}");
            }

            // Step 6: Create order
            var orderId = _idGenerator.NextOrderId();
            var orderNumber = _idGenerator.GenerateOrderNumber();

            var order = new Order
            {
                OrderId = orderId,
                OrderNumber = orderNumber,
                UserId = request.UserId,
                Status = OrderState.Created,
                Items = request.Items.Select((item, idx) =>
                {
                    var variant = variants.First(v =>
                        v.VariantId == item.VariantId);
                    return new OrderItem
                    {
                        OrderItemId = (idx + 1),
                        VariantId = item.VariantId,
                        SellerId = variant.SellerId,
                        ProductName = variant.ProductName,
                        SkuCode = variant.SkuCode,
                        Quantity = item.Quantity,
                        UnitPrice = variant.SellingPrice,
                        DiscountAmount =
                            (variant.MrpPrice - variant.SellingPrice)
                            * item.Quantity,
                        TaxAmount = 0,
                        TotalPrice = variant.SellingPrice
                            * item.Quantity,
                        Status = OrderState.Created
                    };
                }).ToList(),
                Reservations = reservations,
                TotalAmount = pricing.Subtotal,
                DiscountAmount = pricing.PlatformDiscount
                    + pricing.CouponDiscount,
                TaxAmount = pricing.TaxAmount,
                ShippingCharge = pricing.ShippingCharge,
                PayableAmount = pricing.TotalPayable,
                PaymentMethod = request.PaymentMethod,
                ShippingAddress = request.ShippingAddress,
                CreatedAt = DateTime.UtcNow,
                UpdatedAt = DateTime.UtcNow
            };

            await _orderRepo.SaveAsync(order);

            // Step 7: Transition to PaymentPending
            await TransitionOrderStateAsync(
                order, OrderState.PaymentPending);

            // Step 8: Initiate payment (skip for COD)
            if (request.PaymentMethod
                != PaymentMethod.CashOnDelivery)
            {
                try
                {
                    await _payment.InitiatePaymentAsync(
                        order.OrderId, order.PayableAmount,
                        order.PaymentMethod);
                }
                catch (Exception ex)
                {
                    await TransitionOrderStateAsync(
                        order, OrderState.Cancelled);
                    await RollbackReservationsAsync(reservations);
                    return OrderResult.Fail(
                        $"Payment initiation failed: {ex.Message}");
                }
            }
            else
            {
                // COD: Auto-confirm payment
                await TransitionOrderStateAsync(
                    order, OrderState.PaymentConfirmed);
            }

            // Step 9: Publish events
            await _kafka.PublishAsync("order.created", new
            {
                order.OrderId, order.OrderNumber,
                order.UserId, order.PayableAmount,
                ItemCount = order.Items.Count,
                SellerIds = order.Items
                    .Select(i => i.SellerId).Distinct().ToList(),
                CreatedAt = order.CreatedAt
            });

            return OrderResult.Success(order);
        }

        public async Task<bool> HandlePaymentSuccessAsync(
            long orderId, string gatewayTransactionId)
        {
            var order = await _orderRepo.GetByIdAsync(orderId);
            if (order == null) return false;
            if (order.Status != OrderState.PaymentPending)
                return false;

            await TransitionOrderStateAsync(
                order, OrderState.PaymentConfirmed);

            foreach (var reservation in order.Reservations
                .Where(r => r.Status
                    == InventoryReservationStatus.Reserved))
            {
                await _inventory
                    .ConfirmReservationAsync(reservation.ReservationId);
            }

            await _kafka.PublishAsync("payment.confirmed", new
            {
                order.OrderId, order.UserId,
                order.PayableAmount,
                GatewayTransactionId = gatewayTransactionId,
                ConfirmedAt = order.ConfirmationTime
            });

            return true;
        }

        public async Task<bool> CancelOrderAsync(
            long orderId, long userId, string reason)
        {
            var order = await _orderRepo.GetByIdAsync(orderId);
            if (order == null || order.UserId != userId)
                return false;

            if (order.Status != OrderState.PaymentPending
                && order.Status != OrderState.PaymentConfirmed
                && order.Status != OrderState.Processing)
                return false;

            await TransitionOrderStateAsync(
                order, OrderState.Cancelled);
            order.CancellationReason = reason;

            await RollbackReservationsAsync(order.Reservations);

            if (order.Status == OrderState.PaymentConfirmed)
            {
                await _payment.RefundAsync(
                    order.OrderId, order.PayableAmount);
            }

            await _kafka.PublishAsync("order.cancelled", new
            {
                order.OrderId, order.UserId,
                reason, CancelledAt = order.CancelledAt
            });

            return true;
        }

        public async Task<bool> UpdateOrderStatusAsync(
            long orderId, OrderState newState,
            string? trackingNumber = null)
        {
            var order = await _orderRepo.GetByIdAsync(orderId);
            if (order == null) return false;

            await TransitionOrderStateAsync(order, newState);

            if (newState == OrderState.Shipped
                && trackingNumber != null)
            {
                foreach (var item in order.Items)
                {
                    item.TrackingNumber = trackingNumber;
                    item.Status = OrderState.Shipped;
                }
                order.ShippedAt = DateTime.UtcNow;
            }

            if (newState == OrderState.Delivered)
                order.DeliveredAt = DateTime.UtcNow;

            await _orderRepo.SaveAsync(order);

            await _kafka.PublishAsync(
                $"order.{newState.ToString().ToLower()}", new
            {
                order.OrderId, order.OrderNumber,
                order.UserId, Status = newState.ToString(),
                Timestamp = DateTime.UtcNow
            });

            return true;
        }

        private async Task TransitionOrderStateAsync(
            Order order, OrderState newState)
        {
            OrderStateMachine.ValidateTransition(
                order.Status, newState);
            order.Status = newState;
            order.UpdatedAt = DateTime.UtcNow;

            switch (newState)
            {
                case OrderState.PaymentConfirmed:
                    order.ConfirmationTime = DateTime.UtcNow;
                    break;
                case OrderState.Shipped:
                    order.ShippedAt = DateTime.UtcNow;
                    break;
                case OrderState.Delivered:
                    order.DeliveredAt = DateTime.UtcNow;
                    break;
                case OrderState.Cancelled:
                    order.CancelledAt = DateTime.UtcNow;
                    break;
            }
            await _orderRepo.SaveAsync(order);
        }

        private (bool IsValid, string? Error) ValidateRequest(
            PlaceOrderRequest request)
        {
            if (request.Items == null || !request.Items.Any())
                return (false, "Order must have at least one item");
            if (request.Items.Count > MaxItemsPerOrder)
                return (false, $"Max {MaxItemsPerOrder} items per order");
            if (request.Items.Any(i => i.Quantity < 1))
                return (false, "Quantity must be at least 1");
            if (request.Items.Any(i => i.Quantity > 10))
                return (false, "Max quantity per item is 10");
            if (request.ShippingAddress == null)
                return (false, "Shipping address required");
            return (true, null);
        }

        private (bool IsValid, string? Error) ValidateVariants(
            List<OrderItemRequest> items,
            List<ProductVariantInfo> variants)
        {
            foreach (var item in items)
            {
                var variant = variants
                    .FirstOrDefault(v => v.VariantId == item.VariantId);
                if (variant == null)
                    return (false, $"Variant {item.VariantId} not found");
                if (variant.AvailableQuantity < item.Quantity)
                    return (false,
                        $"Insufficient stock for {variant.ProductName}");
            }
            return (true, null);
        }

        private async Task RollbackReservationsAsync(
            List<InventoryReservation> reservations)
        {
            foreach (var reservation in reservations
                .Where(r => r.Status
                    == InventoryReservationStatus.Reserved))
            {
                try
                {
                    await _inventory.ReleaseReservationAsync(
                        reservation.ReservationId);
                    reservation.Status
                        = InventoryReservationStatus.Released;
                }
                catch { /* Log but do not throw */ }
            }
        }
    }
}

This implementation demonstrates:

• State machine pattern with exhaustive transition validation
• Saga pattern for distributed transaction management (inventory reservation with rollback)
• Idempotency through reservation IDs and event publishing
• Clean architecture with interface-based dependency injection
• Event-driven design with Kafka publishing at each state transition
• Domain-driven modeling with rich domain objects and value objects
• Defensive programming with comprehensive request validation

26. Conclusion

Designing an e-commerce platform at Flipkart's scale is one of the most comprehensive system design challenges in the industry. It requires deep expertise across distributed databases, event-driven architectures, real-time search, fraud detection, payment processing, logistics optimization, and multi-region deployment.

The key takeaways from this design are:

1. Inventory consistency is paramount — overselling directly costs revenue. Use DynamoDB conditional writes or similar atomic operations for inventory decrements.
2. Flash sales require isolation — pre-allocate inventory pools, use virtual waiting rooms, and cache deal pages on CDN to handle 24x traffic spikes with 5x infrastructure.
3. Event-driven architecture scales better — Kafka decouples services and provides natural backpressure. Every state transition should publish an event.
4. Caching is not optional — multi-level caching (CDN, Redis, in-memory) reduces database load by 40% and keeps P99 latency under 100ms.
5. Database sharding is necessary but complex — choose shard keys carefully (user ID for orders, category for products) and plan for rebalancing.
6. Payment idempotency is critical — at-least-once delivery is the norm; design every payment handler to be safely retriable.
7. The state machine pattern is essential for order management — it makes complex workflows auditable, testable, and extensible.
8. Multi-region deployment provides both low latency and disaster recovery — active-passive with automated failover is the right choice for e-commerce.

The full C# implementation provided in this article gives you a production-ready foundation that you can extend with your specific business logic, monitoring, and observability requirements. Whether you are preparing for a Staff Engineer interview or building the next great marketplace, these patterns and principles will serve you well.

For further reading, explore our guides on distributed system design patterns, Apache Kafka at scale, and database sharding strategies to deepen your understanding of the building blocks discussed in this article.