ShopScale Fabric
Category
Full Stack
/
/
ShopScale Fabric is a microservices-based e-commerce platform designed to stay operational under heavy load, using Kafka-driven events to decouple services so failures don't cascade.
About the Project
ShopScale Fabric is a microservices-based e-commerce platform designed to survive high-traffic events without breaking down. The core principle was decoupling — if the Review Service fails, the Checkout Service stays operational. Order placement flows asynchronously through an event pipeline: order placed → event sent to Kafka → inventory updated → notification sent, with no service blocking another.
Resilience by Design
E-commerce systems live or die by uptime during peak traffic. This system was built to fail gracefully — services go down, the rest keeps running. Inventory runs out? The order still processes. A notification email fails? The transaction completes anyway.
Service Discovery & Configuration
Every microservice registers independently through Eureka for service discovery, eliminating hard-coded URLs. A centralized Config Server manages shared settings across all services. This means new services can spin up, find each other, and start serving requests without manual configuration — essential for scale.
Event-Driven Order Processing
Kafka serves as the backbone for asynchronous communication. Order Service publishes an OrderPlacedEvent that Inventory Service consumes to update stock. Notification Service emails the user separately. If Inventory Service dies mid-order, the Kafka message persists and processes correctly when the service restarts. This decoupling prevents failures from cascading across the system.
Circuit Breakers & Intelligent Failure
Resilience4j circuit breakers sit between services. If the Price Service goes down, the Cart Service doesn't hang waiting for a response — it fails fast and serves a cached price instead. This means dependent services degrade gracefully rather than locking up threads.
Gateway & Security
Spring Cloud Gateway centralizes concerns: request routing, rate limiting (100 requests/minute per IP), and JWT validation. All authentication happens at the gateway, so downstream microservices trust validated tokens. React frontend connects only to the gateway, never directly to microservices.
Fault Tolerance Tested, Not Assumed
The Inventory Service was killed mid-order placement. The order was restarted. The pending Kafka message processed correctly. Distributed tracing followed a single request across the Gateway, Order Service, and Inventory Service, measuring latency at each hop. Failure modes weren't theoretical — they were tested.
Built to Survive Black Friday
Designed to scale instantaneously under crushing load. Microservices architecture means each service scales independently — if Orders need 10 instances during peak traffic, but Products only needs 2, you pay for exactly that. This is how modern e-commerce systems stay profitable at scale.
Repository: https://github.com/Adnxnn16/Shopscale-Fabric
Stack: Java Spring Boot, Apache Kafka, PostgreSQL, MongoDB, Redis
