A production-grade Flash Sale system built on a Microservices architecture to solve real-world Race Condition problems at scale — featuring a live Cyber HUD Admin Dashboard.

🔴 Live Demo · 📖 Documentation · 🐛 Report Bug

---

🧠 The Problem This Solves

In a standard Flash Sale, thousands of users click "Buy" simultaneously. A naive implementation leads to:

• ❌ Overselling — Stock goes negative because multiple threads read the same stock value at the same time.
• ❌ Data Inconsistency — Orders are created for items that no longer exist.
• ❌ System Collapse — A single monolithic server crumbles under the load.

This project solves all three using a distributed microservices architecture.

---

✅ The Solution

Problem	Solution Used
Race Condition on stock	Redis DECRBY Atomic Operation (thread-safe, no lock needed)
Request overload	RabbitMQ Message Queue (order requests are queued, not processed simultaneously)
Single point of failure	Microservices (each service runs independently)
Slow inventory queries	Redis Cache (sub-millisecond reads)

---

🏗️ System Architecture

┌─────────────────────────────────────────────────────────────┐
│                        CLIENT (Browser)                      │
│              React Dashboard │ Flash Sale Page               │
└─────────────────────┬───────────────────────────────────────┘
                      │ HTTP / REST
                      ▼
┌─────────────────────────────────┐
│          API GATEWAY (Go)        │
│     Rate Limiting · Routing      │
└─────┬───────────┬───────────────┘
      │           │
      ▼           ▼
┌──────────┐  ┌──────────────┐    ┌─────────────────────────┐
│ Product  │  │  Inventory   │───▶│  Redis (Atomic Counter) │
│ Service  │  │  Service     │    │  DECRBY for Stock        │
│  (Go)    │  │  (Go)        │    └─────────────────────────┘
└──────────┘  └──────┬───────┘
                     │ Publish
                     ▼
            ┌─────────────────┐   ┌───────────────────────┐
            │   RabbitMQ      │──▶│   Order Service (Go)  │
            │  Message Queue  │   │   Consumes & Persists │
            └─────────────────┘   └───────────┬───────────┘
                                              │
                                              ▼
                                    ┌──────────────────┐
                                    │   PostgreSQL DB   │
                                    │  (Persistent)     │
                                    └──────────────────┘

---

🎛️ Admin Dashboard Preview

Cyber HUD Theme with full Dark / Light Mode toggle — real-time system monitoring at a glance.

Feature	Description
📊 Live Stats	Stock, Orders, Queue length update every 4 seconds
🟢 Service Health	Status indicator for Gateway, Order Processor, Inventory Sync
🖥️ Security Logs	Live feed of system events with timestamps
🎨 Dark / Light Mode	Smooth theme transition via CSS Variables
⚡ Control Center	Trigger sessions, pause sales, flush cache

---

🚀 Tech Stack

Backend

Layer	Technology	Purpose
Language	Go (Golang)	High-performance, concurrent microservices
Web Framework	Fiber	Express-like HTTP framework for Go
Message Broker	RabbitMQ	Async order queuing
Cache & Atomic Ops	Redis	Sub-ms stock reads, Race Condition prevention
Database	PostgreSQL	Persistent order & product storage
Containerization	Docker + Compose	One-command environment setup

Frontend

Layer	Technology	Purpose
Framework	React 18 + Vite 5	Fast SPA with HMR
Styling	Vanilla CSS	Custom Cyber HUD design system
Icons	Lucide React	Consistent icon library
Fonts	Orbitron + Rajdhani	Futuristic HUD typography

---

📦 Getting Started

Prerequisites

• Go 1.22+
• Node.js 18+
• Docker Desktop

1. Clone the repository

git clone https://github.com/yourusername/nexcore-flashsale-engine.git
cd nexcore-flashsale-engine

2. Start infrastructure (Redis, RabbitMQ, PostgreSQL)

docker-compose up -d

3. Start the Admin Dashboard (Frontend)

cd frontend
npm install
npm run dev

Dashboard will be available at http://localhost:5173

4. Start the Microservices (Backend)

# In separate terminals:
cd backend/gateway && go run main.go
cd backend/product && go run main.go
cd backend/inventory && go run main.go
cd backend/order && go run main.go

---

📁 Project Structure

nexcore-flashsale-engine/
├── backend/
│   ├── gateway/        # API Gateway - routing & rate limiting
│   ├── product/        # Product & Flash Sale schedule management
│   ├── inventory/      # Stock management with Redis atomic ops
│   ├── order/          # Order processing via RabbitMQ consumer
│   └── shared/         # Shared models, config, utilities
├── frontend/
│   ├── src/
│   │   ├── App.jsx     # Main Dashboard component
│   │   └── index.css   # Cyber HUD Design System
│   └── package.json
├── docker-compose.yml
└── README.md

---

🔬 Key Concepts Demonstrated

1. Solving Race Condition with Redis Atomic Operations

// ❌ Unsafe (classic race condition)
stock := getStockFromDB()
if stock > 0 {
    updateStock(stock - 1)  // Another goroutine may do the same!
}

// ✅ Safe (atomic Redis operation)
remaining, err := rdb.Decr(ctx, "product:stock:1").Result()
if remaining < 0 {
    rdb.Incr(ctx, "product:stock:1") // Rollback
    return errors.New("out of stock")
}

2. Async Order Processing via RabbitMQ

// Producer (Inventory Service) — publishes order to queue
ch.Publish("", "order_queue", false, false, amqp.Publishing{
    ContentType: "application/json",
    Body:        orderJSON,
})

// Consumer (Order Service) — processes orders from queue
msgs, _ := ch.Consume("order_queue", "", true, false, false, false, nil)
for msg := range msgs {
    processAndSaveOrder(msg.Body) // Saved to PostgreSQL
}

---

👨‍💻 Author

[Your Name]

Informatics Student | Backend & Distributed Systems Enthusiast

---

📄 License

This project is licensed under the MIT License — see the LICENSE file for details.

---

Built with ☕ and a lot of debugging sessions

⭐ Star this repo if you find it useful!