Design an E-Commerce Platform (Amazon/Flipkart)

Java — Atomic inventory reservation via Redis Lua script with DB fallback

// Inventory Service — Redis-based atomic reservation with DB persistence
@Service
public class InventoryService {

    private final RedisTemplate<String, String> redis;
    private final InventoryRepository inventoryRepo;
    private final DefaultRedisScript<Long> reserveScript;

    @PostConstruct
    public void initScript() {
        // Atomic check-and-decrement Lua script
        String lua = """
            local stock = tonumber(redis.call('GET', KEYS[1]))
            if stock == nil then return -2 end  -- key not loaded
            if stock >= tonumber(ARGV[1]) then
                return redis.call('DECRBY', KEYS[1], ARGV[1])
            else
                return -1  -- insufficient stock
            end
            """;
        reserveScript = new DefaultRedisScript<>(lua, Long.class);
    }

    /**
     * Reserve qty units. Returns the new stock level, or throws if unavailable.
     */
    public long reserve(long productId, int qty) {
        String key = "stock:" + productId;

        Long result = redis.execute(reserveScript,
            List.of(key), String.valueOf(qty));

        if (result == null || result == -2) {
            // Redis key not loaded — fall back to DB with optimistic lock
            return reserveInDb(productId, qty);
        }
        if (result < 0) {
            throw new InsufficientStockException(productId, qty);
        }

        // Persist reservation asynchronously to DB
        inventoryRepo.decrementAsync(productId, qty);
        return result;
    }

    public void release(long productId, int qty) {
        String key = "stock:" + productId;
        redis.opsForValue().increment(key, qty);
        inventoryRepo.incrementAsync(productId, qty);
    }

    private long reserveInDb(long productId, int qty) {
        int updated = inventoryRepo.tryReserve(productId, qty);
        if (updated == 0) throw new InsufficientStockException(productId, qty);
        return inventoryRepo.getStock(productId);
    }
}

Java — Orchestration-based Order Saga with inventory compensation

// Order Service — orchestration-based Saga
@Service
public class OrderSagaOrchestrator {

    private final OrderRepository orderRepo;
    private final InventoryServiceClient inventoryClient;
    private final PaymentServiceClient paymentClient;
    private final KafkaTemplate<String, Object> kafka;

    @Transactional
    public Order placeOrder(PlaceOrderRequest req) {
        // Step 1: Persist order in PENDING state
        Order order = orderRepo.save(Order.builder()
            .userId(req.userId())
            .items(req.items())
            .totalAmount(req.totalAmount())
            .status(OrderStatus.PENDING)
            .build());

        try {
            // Step 2: Reserve inventory (idempotent by orderId)
            for (OrderItem item : order.items()) {
                inventoryClient.reserve(
                    new ReserveRequest(item.productId(), item.qty(), order.id()));
            }
            order.setStatus(OrderStatus.INVENTORY_RESERVED);
            orderRepo.save(order);

        } catch (InsufficientStockException e) {
            order.setStatus(OrderStatus.FAILED);
            order.setFailureReason("Insufficient stock: " + e.getMessage());
            orderRepo.save(order);
            throw e;
        }

        try {
            // Step 3: Initiate payment (async — confirmation via webhook)
            paymentClient.initiate(
                new PaymentRequest(order.id(), order.totalAmount(),
                    req.paymentMethodToken()));
            order.setStatus(OrderStatus.PAYMENT_PENDING);
            orderRepo.save(order);

        } catch (PaymentException e) {
            // Compensation: release inventory
            for (OrderItem item : order.items()) {
                inventoryClient.release(
                    new ReleaseRequest(item.productId(), item.qty(), order.id()));
            }
            order.setStatus(OrderStatus.FAILED);
            order.setFailureReason("Payment initiation failed");
            orderRepo.save(order);
            throw e;
        }

        return order;
    }

    // Called when Payment Service webhook confirms payment
    @KafkaListener(topics = "payment-events")
    public void onPaymentEvent(PaymentEvent event) {
        Order order = orderRepo.findById(event.orderId()).orElseThrow();

        if (event.status() == PaymentStatus.COMPLETED) {
            order.setStatus(OrderStatus.CONFIRMED);
            kafka.send("order-events", new OrderConfirmedEvent(order.id(), order.userId()));
        } else {
            // Payment failed — release inventory
            for (OrderItem item : order.items()) {
                inventoryClient.release(
                    new ReleaseRequest(item.productId(), item.qty(), order.id()));
            }
            order.setStatus(OrderStatus.FAILED);
            order.setFailureReason("Payment declined");
        }
        orderRepo.save(order);
    }
}

Java — Elasticsearch search with facets, filters, boost, and pagination

// Search Service — Elasticsearch query with facets and pagination
@Service
public class ProductSearchService {

    private final ElasticsearchClient esClient;
    private static final String INDEX = "products";

    public SearchResponse<ProductDoc> search(SearchQuery query) throws IOException {

        // Build the bool query
        BoolQuery.Builder boolQuery = new BoolQuery.Builder();

        // Full-text match on title and description
        if (query.text() != null && !query.text().isBlank()) {
            boolQuery.must(m -> m.multiMatch(mm -> mm
                .fields("title^3", "description", "brand^2")  // title boosted 3x
                .query(query.text())
                .fuzziness("AUTO")
            ));
        }

        // Filters (don't affect relevance score)
        if (query.category() != null) {
            boolQuery.filter(f -> f.term(t -> t
                .field("category_path").value(query.category())));
        }
        if (query.minPrice() != null || query.maxPrice() != null) {
            boolQuery.filter(f -> f.range(r -> {
                r.field("price");
                if (query.minPrice() != null) r.gte(JsonData.of(query.minPrice()));
                if (query.maxPrice() != null) r.lte(JsonData.of(query.maxPrice()));
                return r;
            }));
        }
        boolQuery.filter(f -> f.term(t -> t.field("in_stock").value(true)));

        // Sort
        SortOptions sort = switch (query.sortBy()) {
            case PRICE_ASC  -> SortOptions.of(s -> s.field(f -> f.field("price").order(SortOrder.Asc)));
            case RATING     -> SortOptions.of(s -> s.field(f -> f.field("avg_rating").order(SortOrder.Desc)));
            default         -> SortOptions.of(s -> s.score(sc -> sc.order(SortOrder.Desc)));
        };

        return esClient.search(s -> s
            .index(INDEX)
            .query(q -> q.bool(boolQuery.build()))
            .sort(sort)
            .from(query.page() * query.pageSize())
            .size(query.pageSize())
            // Aggregations for facet counts
            .aggregations("by_brand", a -> a.terms(t -> t.field("brand").size(20)))
            .aggregations("price_range", a -> a.range(r -> r.field("price")
                .ranges(List.of(
                    AggregationRange.of(ar -> ar.to(50.0)),
                    AggregationRange.of(ar -> ar.from(50.0).to(200.0)),
                    AggregationRange.of(ar -> ar.from(200.0))
                ))
            ),
            ProductDoc.class
        );
    }
}

Java — Flash sale gate: Redis Lua reservation + per-user limit + Kafka queueing

// Flash Sale Service — entry gate with Redis reservation and order queueing
@Service
public class FlashSaleService {

    private final RedisTemplate<String, String> redis;
    private final DefaultRedisScript<Long> flashReserveScript;
    private final KafkaTemplate<String, FlashOrderEvent> kafka;

    @PostConstruct
    public void initScript() {
        String lua = """
            -- KEYS[1] = stock key, KEYS[2] = user-purchased key
            -- ARGV[1] = qty, ARGV[2] = userId
            if redis.call('EXISTS', KEYS[2]) == 1 then
                return -3  -- user already purchased
            end
            local stock = tonumber(redis.call('GET', KEYS[1]))
            if stock == nil or stock < tonumber(ARGV[1]) then
                return -1  -- out of stock
            end
            redis.call('SETEX', KEYS[2], 86400, '1')  -- mark user as purchased
            return redis.call('DECRBY', KEYS[1], ARGV[1])
            """;
        flashReserveScript = new DefaultRedisScript<>(lua, Long.class);
    }

    public FlashOrderResponse attemptPurchase(long saleId, long productId,
                                               long userId, int qty) {
        String stockKey   = "flash:" + saleId + ":stock:" + productId;
        String purchasedKey = "flash:" + saleId + ":user:" + userId;

        Long result = redis.execute(flashReserveScript,
            List.of(stockKey, purchasedKey), String.valueOf(qty), String.valueOf(userId));

        if (result == null || result == -1) {
            return FlashOrderResponse.outOfStock();
        }
        if (result == -3) {
            return FlashOrderResponse.alreadyPurchased();
        }

        // Reservation succeeded — enqueue order for async processing
        String reservationId = UUID.randomUUID().toString();
        kafka.send("flash-orders", String.valueOf(saleId),
            new FlashOrderEvent(reservationId, saleId, productId, userId, qty));

        return FlashOrderResponse.reserved(reservationId);
    }
}