Managing Flash Sales And Discounts

Round 3 at Walmart broke me. The interviewer said: Design a Flash Sale system. 10 million users. One product. All hitting Buy at exactly 12:00:00. - What happens when 10 million writes hit your database simultaneously? - Two users bought the last item at the same millisecond. Who gets it? I failed that round. 33 LPA oppurtuinity gone. But I didn't move on. I went deep. Here's what I should have said. The naive approach (what everyone says): - User clicks Buy - API checks inventory - If available → deduct stock → confirm order - This works in demo. Kills in production. The real problems at scale: 1. Overselling 10 million users hit Buy simultaneously. API reads stock = 1 for all of them. All pass the inventory check. 10 million confirmation emails sent. Stock was 1. Fix: Never check inventory in your application layer. Use Redis DECR atomic single operation. Stock decrements by 1. Returns new value. If value < 0 → reject instantly. No two users ever see the same stock count. 2. Database dies at 12:00:00 10 million writes per second hit your DB directly. DB connection pool exhausts in milliseconds. System crashes. Sale over before it started. Fix: Put Kafka between API and DB. User clicks Buy → Kafka accepts instantly → returns "You are in queue." DB processes orders at its own pace. API never waits. DB never chokes. 3. Same user buys twice Network timeout. User clicks Buy again. Two orders created. Two payments charged. Fix: Idempotency key unique token per Buy attempt. Before processing — check Redis if this token exists. Already processed? Return old result. Never process again. 4. Sale not starting at exactly 12:00:00 Server A starts at 12:00:00. Server B starts at 12:00:03. Users on different servers see different sale states. Fix: Centralised sale flag in Redis. All servers check the same key. Flag flips to true simultaneously. Consistent experience for every user. The architecture I should have led with: User → API Gateway → Redis (inventory + idempotency) → Kafka → Order Service → DB - Redis handles inventory atomically no overselling ever - Kafka absorbs the 12:00:00 traffic spike no direct DB hammering - Idempotency key prevents duplicate orders - API Gateway rate limits per user no single user hammers the system Walmart doesn't test whether you can build a flash sale. They test whether you know what happens when 10 million people break it simultaneously. 𝗞𝗲𝗲𝗽𝗶𝗻𝗴 𝘁𝗵𝗶𝘀 𝗶𝗻 𝗺𝗶𝗻𝗱, 𝗜 𝘄𝗲𝗻𝘁 𝗱𝗲𝗲𝗽 𝗮𝗻𝗱 𝗱𝗼𝗰𝘂𝗺𝗲𝗻𝘁𝗲𝗱 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 𝗶𝗻𝘁𝗼 𝗮 𝗝𝗮𝘃𝗮 𝗕𝗮𝗰𝗸𝗲𝗻𝗱 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗚𝘂𝗶𝗱𝗲. 𝗚𝗲𝘁 𝘁𝗵𝗲 𝗚𝘂𝗶𝗱𝗲 𝗵𝗲𝗿𝗲: https://lnkd.in/dTvYVutD Use SDE20 to get 20% off. Stay Hungry, Stay FoolisH!

Flash sales expose bad inventory design fast. Preventing oversells without killing latency is the hard part. At first glance, every option looks reasonable: A. Lock in the primary DB Safe and correct. But hot rows create lock contention and ugly tail latency. B. Optimistic concurrency with retries Clean and simple. But under heavy contention, retries turn into a traffic amplifier. C. Atomic in-memory counter ✅ Fast, scalable, and race-free on the hot path. This is the best fit for flash sales. D. Queue it and fix later Great for smoothing spikes. But you are accepting oversells and paying for it later with refunds and support pain. Why C wins? 1. Atomic check and decrement removes race conditions 2. In-memory operations keep latency low 3. Sharding by product helps scale hot SKUs 4. The database stops being the bottleneck 5. It matches the reality of flash-sale traffic Trade-offs - You still need durable persistence - You need reconciliation for drift - You need idempotency for retries - You need reservation expiry for abandoned carts Contrast: DB locking protects stock by slowing the system down. Atomic counters protect stock while keeping the system fast.

🔥 𝗧𝗵𝗶𝘀 𝗜𝘀 𝗛𝗼𝘄 Amazon 𝗔𝘃𝗼𝗶𝗱𝘀 𝗙𝗹𝗮𝘀𝗵 𝗦𝗮𝗹𝗲 𝗖𝗿𝗮𝘀𝗵𝗲𝘀 𝗶𝗻 𝗕𝗮𝗰𝗸𝗲𝗻𝗱𝘀 Flash sale crashes don’t happen because of traffic. They happen because the 𝗯𝗮𝗰𝗸𝗲𝗻𝗱 𝘁𝗿𝗲𝗮𝘁𝘀 𝘀𝗽𝗶𝗸𝗲𝘀 𝗹𝗶𝗸𝗲 𝗻𝗼𝗿𝗺𝗮𝗹 𝗹𝗼𝗮𝗱. Here’s the 𝗯𝗮𝗰𝗸𝗲𝗻𝗱 𝘁𝗵𝗶𝗻𝗸𝗶𝗻𝗴 used to survive flash-sale at scale 👇 𝗦𝘁𝗲𝗽 1: 𝗔𝘀𝘀𝘂𝗺𝗲 𝗧𝗿𝗮𝗳𝗳𝗶𝗰 𝗪𝗶𝗹𝗹 𝗕𝗲 𝗨𝗻𝗳𝗮𝗶𝗿 Millions of users hit the same few products at once. So instead of letting everyone hit the database: • Requests are throttled • Rate limits are applied early • Excess traffic is shed gracefully 𝗚𝗼𝗮𝗹: protect the system, not please every request 𝗦𝘁𝗲𝗽 2: 𝗡𝗲𝘃𝗲𝗿 𝗧𝗿𝘂𝘀𝘁 𝘁𝗵𝗲 𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲 Inventory and product data are: • Cached aggressively • Pre-computed before the sale • Served from in-memory stores 𝗦𝘁𝗲𝗽 3: 𝗪𝗿𝗶𝘁𝗲𝘀 𝗔𝗿𝗲 𝗦𝗲𝗿𝗶𝗮𝗹𝗶𝘇𝗲𝗱 Orders are not processed directly. 𝗜𝗻𝘀𝘁𝗲𝗮𝗱: • Requests go into queues • Inventory is decremented safely • Only confirmed orders hit the DB 𝗧𝗵𝗶𝘀 𝗽𝗿𝗲𝘃𝗲𝗻𝘁𝘀: • Overselling • Lock contention • Cascade failures 𝗦𝘁𝗲𝗽 4: 𝗙𝗮𝗶𝗹𝘂𝗿𝗲 𝗜𝘀 𝗘𝘅𝗽𝗲𝗰𝘁𝗲𝗱 Some services will slow down. Some requests will fail. 𝗦𝗼 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝘂𝘀𝗲: • Timeouts • Circuit breakers • Fallback responses 𝗔 𝗳𝗹𝗮𝘀𝗵 𝘀𝗮𝗹𝗲 𝗯𝗮𝗰𝗸𝗲𝗻𝗱 𝗶𝘀 𝗱𝗲𝘀𝗶𝗴𝗻𝗲𝗱 𝘁𝗼 𝗱𝗲𝗴𝗿𝗮𝗱𝗲, 𝗻𝗼𝘁 𝗰𝗼𝗹𝗹𝗮𝗽𝘀𝗲. Final Thought 👇 𝗙𝗹𝗮𝘀𝗵 𝘀𝗮𝗹𝗲𝘀 𝗮𝗿𝗲 𝗻𝗼𝘁 𝗮𝗯𝗼𝘂𝘁 𝘀𝗽𝗲𝗲𝗱. 𝗧𝗵𝗲𝘆’𝗿𝗲 𝗮𝗯𝗼𝘂𝘁 𝗰𝗼𝗻𝘁𝗿𝗼𝗹 𝘂𝗻𝗱𝗲𝗿 𝗲𝘅𝘁𝗿𝗲𝗺𝗲 𝗹𝗼𝗮𝗱. This is the difference between: • “It worked in testing” • “It survived production” Exactly the kind of backend thinking product-based companies look for. --------------------------------- 𝗙𝗼𝗿 𝗽𝗲𝗿𝘀𝗼𝗻𝗮𝗹𝗶𝘇𝗲𝗱 𝗴𝘂𝗶𝗱𝗮𝗻𝗰𝗲, 𝗿𝗼𝗮𝗱𝗺𝗮𝗽𝘀, 𝗼𝗿 1:1, 𝘆𝗼𝘂 𝗰𝗮𝗻 𝗰𝗼𝗻𝗻𝗲𝗰𝘁 𝘄𝗶𝘁𝗵 𝗺𝗲 𝗵𝗲𝗿𝗲 :- https://lnkd.in/gb-2Wbut #SystemDesign #BackendEngineering #Scalability #DistributedSystems #Java #SpringBoot #SoftwareEngineer #HighTrafficSystems

✨ 𝐑𝐞𝐜𝐞𝐧𝐭 𝐒𝐲𝐬𝐭𝐞𝐦 𝐃𝐞𝐬𝐢𝐠𝐧 𝐈𝐧𝐭𝐞𝐫𝐯𝐢𝐞𝐰 𝐏𝐫𝐨𝐛𝐥𝐞𝐦: 𝐇𝐨𝐰 𝐈 𝐃𝐞𝐬𝐢𝐠𝐧𝐞𝐝 𝐚 𝐋𝐢𝐠𝐡𝐭𝐧𝐢𝐧𝐠-𝐅𝐚𝐬𝐭 𝐞𝐂𝐨𝐦𝐦𝐞𝐫𝐜𝐞 & 𝐂𝐚𝐦𝐩𝐚𝐢𝐠𝐧 𝐒𝐲𝐬𝐭𝐞𝐦 ⚡️Ever joined a Swiggy/Amazon flash sale where 100k people smash “Claim” at the same second? It feels less like shopping and more like a hunger games arena. 🏹🔥 𝐋𝐚𝐬𝐭 𝐰𝐞𝐞𝐤 𝐢𝐧 𝐚 𝐬𝐲𝐬𝐭𝐞𝐦 𝐝𝐞𝐬𝐢𝐠𝐧 𝐢𝐧𝐭𝐞𝐫𝐯𝐢𝐞𝐰, I was thrown right into that chaos: 👉 “Design a checkout system that survives when everyone wants the same burger at ₹1.” 🎯 The Problem "Ensure fair claims, avoid double-claims, prevent oversell, and keep the system resilient under chaos."   🧠 Challenges I Navigated Inventory Management → Prevent overselling even under 10k+ requests/sec. User Claim Idempotency → Each user should claim only once. High Traffic Bursts → Handle flash sale traffic spikes without downtime.   🤯 Trade-offs Considered ✅ DB-first approach? ❌ Collapses under massive write bursts. ✅ Cache-only? ❌ Risk of losing truth during failures. ✅ Queue buffering? ✅ Helps absorb spikes but adds latency.   🧠 𝐖𝐡𝐲 𝐂𝐚𝐜𝐡𝐞-𝐅𝐢𝐫𝐬𝐭, 𝐍𝐨𝐭 𝐃𝐁-𝐅𝐢𝐫𝐬𝐭? In high-concurrency campaigns like Swiggy’s “100 Burgers at ₹1”, the DB-first approach fails under massive bursts: Problem: Imagine 10,000+ users hitting the DB simultaneously. Even with high TPS, row locks for stock decrement → contention → everyone slows down. Result: Users see delays, oversells happen, and double-claims sneak in. ✅ Solution → Cache-first (Redis): Redis is in-memory, ultra-fast, and handles 100k+ ops/sec. Real-time checks happen in cache, not DB. DB is updated asynchronously (Kafka → DB) for durability + analytics.   ⚡ 𝐅𝐥𝐨𝐰 𝐨𝐟 𝐭𝐡𝐞 𝐒𝐲𝐬𝐭𝐞𝐦 User → API Gateway → Claim Service → Cache (Redis) → DB 1️⃣ User clicks the claim link. 2️⃣ API Gateway routes to Claim Service. 3️⃣ Claim Service checks Redis cache: User already claimed? → return ❌ Stock > 0? → proceed ✅ 4️⃣ Redis Atomic Ops: SETNX user:{id}:claimed → ensures only first claim succeeds. DECR burger:count → decrements stock safely. 5️⃣ If claim succeeds → respond with Happy Face. 6️⃣️If stock exhauste→ respond with Sad Face Events are pushed → Kafka → DB (durability + analytics). ⚡ This ensures: Each user gets exactly 1 burger. No overselling. Sub-100ms latency for most requests.   ⚡ Atomic Operations in Redis 𝐒𝐄𝐓𝐍𝐗 𝐮𝐬𝐞𝐫:𝟏𝟐𝟑𝟒𝟓: 𝐜𝐥𝐚𝐢𝐦𝐞𝐝→ Only the first request succeeds. Subsequent ones fail instantly → prevents double-claims. 𝐃𝐄𝐂𝐑 𝐛𝐮𝐫𝐠𝐞𝐫:𝐜𝐨𝐮𝐧𝐭 → Decrements stock atomically. Guarantees no overselling, even under massive concurrency.   💡 how would you improve this further? I’d love to hear your thoughts 👇 #SystemDesign #SystemDesignInterview #DistributedSystems #HighScalability #SoftwareArchitecture #BackendEngineering #CloudArchitecture #Redis #Kafka #Databases #TechCareers #EngineeringLeadership #InterviewPrep #SDE

𝗢𝗻𝗲 𝗵𝗼𝘁 𝗿𝗼𝘄. 𝗠𝗶𝗹𝗹𝗶𝗼𝗻 𝘂𝘀𝗲𝗿𝘀. 𝗖𝗵𝗮𝗼𝘀. In a flash sale, imagine a product with 100 units and millions of users clicking Buy at the same time. If inventory lives in one row: product_id = 42, stock = 100 Every purchase hits the same row. What happens? • In lock-based systems → waiting, timeouts, deadlocks • In optimistic systems → aborts and retries Either way, that single row becomes the bottleneck. The fix: sharded counters Instead of one row, split stock into multiple rows: • shard 0 → 10 units • shard 1 → 10 units • … • shard 9 → 10 units Total stock is still 100 but contention drops massively. Each purchase: • randomly picks a shard • decrements stock if available • retries another shard if empty No hot row. Much higher throughput. System stays responsive under extreme load. Key takeaway: 𝗜𝗳 𝗼𝗻𝗲 𝗿𝗼𝘄 𝗶𝘀 𝗯𝗲𝗶𝗻𝗴 𝘂𝗽𝗱𝗮𝘁𝗲𝗱 𝗯𝘆 𝗲𝘃𝗲𝗿𝘆𝗼𝗻𝗲, 𝘁𝗵𝗮𝘁 𝗿𝗼𝘄 𝗶𝘀 𝗮𝗹𝗿𝗲𝗮𝗱𝘆 𝗮 𝘀𝗰𝗮𝗹𝗮𝗯𝗶𝗹𝗶𝘁𝘆 𝗯𝘂𝗴.

A year ago, our store fulfillment was breaking down. ❌ 30%+ rejection rates ❌ Orders bouncing from store to store ❌ Delays and cancellations piling up 200 stores. One broken loop. We went back to first principles and asked: why are stores rejecting orders? Two reasons. #1. Ghost inventory By the time an order was picked in the store, the item was already sold. Fix: ➡️ Introduced stock thresholds based on rejection patterns. ➡️ Tightened picking SLAs to reduce stock-outs. #2. Broken Incentives Store teams rejected online orders for high-demand items because they feared losing store sales incentives. Fix: ➡️ Unified incentives across channels. ➡️ Reinforced one message: a customer is a customer. The result: 📉 Rejections dropped from >30% to single digits. ⚡ Enabled 60-minute store-to-customer delivery. 📈 Scaled from 200 stores to 1000 stores. What started as our biggest operational liability became our strongest competitive advantage. Most operational problems are actually incentive problems in disguise. Fix the incentive. Fix the behavior. Fix the system. #Operations #SupplyChain #Retail #Ecommerce #Leadership

Flipkart’s GOAT Sale shows how much India’s mega-sale model has changed. A few years ago, a large e-commerce sale was mainly a fulfilment centre problem. Platforms had to forecast demand, stock large warehouses, manage order spikes, and push deliveries over the next few days. Now, quick commerce has changed the operating pressure. Flipkart Minutes has crossed 1,000 micro-fulfilment centres across 130+ cities and 8,000+ pincodes. Orders have grown 5X year-on-year, while Tier 2 and Tier 3 markets have scaled 42X. This means a sale is no longer planned only at a national or city level. It has to be planned at a neighbourhood level. If a customer expects a phone accessory, beauty product, grocery item or electronic essential within minutes, the product cannot sit in a central warehouse. It has to be available in the right micro-fulfilment centre before demand arrives. That is the difficult part. During a sale, demand spikes fast. Replenishment cannot always catch up in real time. The winning platform is the one that can predict which SKUs will move in which catchment, place stock early, and keep last-mile execution visible. Reuters reports that India’s quick-commerce market is already around $11 billion, with deliveries happening in 10 to 30 minutes. Flipkart Minutes also has the highest average order value among peers at around ₹700. That makes the logistics problem even sharper. Higher-value products need better stock accuracy, stronger rider accountability, cleaner proof of delivery and faster exception handling. The future of mega sales will not be decided only by discounts. It will be decided by how well platforms pre-position inventory, track replenishment and control the last mile. Because instant delivery leaves very little room for operational guesswork.

A Meesho interviewer asked, "Our flash sale goes live. We have 80,000 orders per second. There is exactly 1 unit left for a OnePlus TV, and 15,000 users click 'Buy' at the exact same millisecond. What happens?" Most candidates answered instantly: "Use a database lock." The interviewer smiled. "Your database just received 15,000 concurrent write requests in under a second. Walk me through exactly what happens next." Silence. The Over-Selling Nightmare, 15,000 requests hit your API servers simultaneously. All of them read the inventory and see 1 unit available. All of them try to write, place the order, and decrement stock. Without proper handling, all 15,000 succeed. You’ve just sold one TV to 15,000 angry customers. 𝗪𝗵𝘆 𝘁𝗵𝗲 𝗡𝗮𝗶𝘃𝗲 𝗙𝗶𝘅 𝗙𝗮𝗶𝗹𝘀 Locking the database row forces the system to process one request at a time. While this prevents over-selling, it creates a massive bottleneck at 80,000 orders per second:  • The database queue backs up instantly.  • Latency spikes across the entire platform.  • Timeout errors cascade, and the entire checkout system crashes.  • You fixed the over-sell, but you broke the entire flash sale. 𝗪𝗵𝗮𝘁 𝗔𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗪𝗼𝗿𝗸𝘀 𝗮𝘁 𝗦𝗰𝗮𝗹𝗲 Production-grade systems handle this problem by moving the heavy lifting away from traditional database locks: Redis Atomic Operations: Use Redis DECR. It checks and decrements the stock in a single, atomic operation in-memory. No race conditions, sub-millisecond latency. Optimistic Locking: Read the inventory along with a version number. Update the row only if the version hasn't changed. If it has, fail fast or retry. No hard database locks. The Reservation Layer: Don’t permanently decrement stock on the first click. Hold it in a temporary "reserved" state for 10 minutes. Confirm only when payment succeeds; otherwise, release it back. Message Queues: Funnel buy requests into a Kafka or RabbitMQ topic. Process them sequentially per product ID to eliminate concurrent database writes entirely. 𝗧𝗵𝗲 𝗙𝗼𝗹𝗹𝗼𝘄-𝗨𝗽 𝗧𝗵𝗮𝘁 𝗘𝗻𝗱𝗲𝗱 𝘁𝗵𝗲 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 "The user's payment fails after the 10-minute reservation. How do you safely return that 1 unit to the inventory without corrupting the state?" 𝗔𝗻𝘀𝘄𝗲𝗿𝗶𝗻𝗴 𝘁𝗵𝗶𝘀 𝗿𝗲𝗾𝘂𝗶𝗿𝗲𝘀 𝗺𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗱𝗲𝗲𝗽 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗮𝗹 𝗰𝗼𝗻𝗰𝗲𝗽𝘁𝘀:  • Idempotency keys to prevent double-processing.  • Compensating transactions to reverse failed states.  • The Saga Pattern to manage distributed data consistency. This single question stretched into a 40-minute deep dive. The interview wasn't actually about inventory. It was a test of how you think when millions of users and real business revenue are on the line at the exact same second. Found this useful? Repost for someone preparing for SDE-2 interviews right now.

Anyone who has ever tried booking a Tatkal ticket knows the pure anxiety of watching an infinite loading spinner while the clock ticks away. When traffic spikes to 30,000 transactions per second at 11:00 AM, all fighting for the exact same limited inventory, letting every request hit your database at once guarantees total system failure and deadlocks. In system design, handling this gracefully comes down to one core topic: High-Concurrency Inventory Allocation. Here is how you actually build a system to survive a massive flash-sale spike without crashing: 1) Buffer with a Queue: Never let peak traffic hit your core database directly. Place a high-throughput message queue in front of your processing servers. This ingests the massive tidal wave of requests instantly, handles them in a controlled order, and gives the user a "processing" status. 2) Keep Inventory In-Memory: Checking if a seat is available using standard SQL queries during a spike will destroy database performance. Instead, offload the inventory counts to an in-memory store like Redis. Decrementing a counter in Redis takes less than a millisecond and easily absorbs tens of thousands of requests. 3) Smart Locking: To avoid database deadlocks when multiple workers try to update the exact same train chart rows, use distributed locking or optimistic concurrency control. This ensures only one worker mutates a specific seat record at any given microsecond. 4) Asynchronous Payments: Never hold a database transaction open while waiting for an external banking API to process a payment. Reserve the seat with a short TTL (Time-To-Live), release the database connection, and only finalize the booking when the bank hits your webhook with a successful callback. Good architecture is all about protecting the database from the impatience of thousands of users. We’ve built a structured session that walks you through high-concurrency architecture and flash sale system design step by step, so you can be done with this topic once and for all and never get confused ever. Try it here: layrs.me/tutor-topics

Flash Fails, Readiness Wins Flash without readiness is a fast way to lose customers in eCommerce. Brands pour money into ads or chase a viral moment... only to get crushed by backend breakdowns. Inventory isn’t tracked, fulfillment lags, post-purchase flows are missing. Customers don’t come back. CAC climbs, LTV drops, and suddenly the growth story isn’t growth at all. I learned this firsthand when I led an RFP process for an eCommerce brand. Vendors pitched all flash - slick websites, shiny tech that couldn't deliver what we needed, big promises. But when I pushed for our specific outcomes, many backed off from the work entirely. They didn’t “get it.” Flash without readiness couldn’t fly. We needed partners who started with outcomes and then built the right road to deliver on them. The fix isn’t sexy. It’s not the next tool or another flashy campaign. It’s operational readiness. Making sure: 🔹 Outcomes are defined clearly and drive every decision. 🔹 Inventory and fulfillment are tight. 🔹 Post-purchase flows actually exist and nurture repeat sales. 🔹 Teams know the playbook before the orders roll in. 📌 Always Be Ready. That’s the real edge. Start with outcomes first, then build the road and tools that actually deliver on them. It’s how I work, and it’s why growth lasts. Strong foundations work every time. ___ 👋 Hi, I’m Anne. I align marketing infrastructure, people, processes, and technology to create, fix, and scale revenue operations, everything from branding and partnerships to systems and strategy, so brands and teams grow smarter, move faster, and achieve sustainable growth. #eCommerce #DTC #FixTheFlow