FlowCart: Production-Grade Microservices E-commerce Backend on AWS EKS

🚀 Upgraded My Microservices Architecture with Redis & Rate Limiting I’ve been working on improving my event-driven e-commerce microservices system, and I just implemented Redis-based Rate Limiting at the API Gateway level to make it more production-ready. 💡 What I Built Event-driven architecture using Kafka Saga Pattern for distributed transactions Strategy Pattern for flexible payment processing (UPI, Card, NetBanking) API Gateway with JWT-based authentication Dockerized microservices ecosystem Outbox Pattern, Retry & DLQ handling ⚡ New Upgrade: Redis + Rate Limiting Integrated Redis to track request counts Implemented Rate Limiting at API Gateway Different strategies: 🔐 Authenticated Users (JWT) → Rate limit per user 🌐 Public APIs → Rate limit per IP Prevents: API abuse DDoS attacks System overload 🧠 Why This Matters Improves system stability under high traffic Ensures fair usage across users Adds real-world production-grade scalability Enhances security at the entry point 🏗️ Architecture Highlights API Gateway handles: JWT Validation Routing Rate Limiting (via Redis) Kafka enables async communication between: Order → Payment → Notification → Email Redis acts as a fast in-memory store for request throttling 📦 Tech Stack Java | Spring Boot | Spring Cloud Gateway | Kafka | Redis | PostgreSQL | Docker | Zipkin 🎯 What I Learned How to design scalable API Gateway patterns Real-world use of Redis beyond caching Handling traffic spikes safely Combining security + performance #Microservices #SpringBoot #Kafka #Redis #SystemDesign #Backend #Java #APIGateway #RateLimiting #Docker #CleanArchitecture

We built an online chocolate shop that doesn't crash on busy days. 🍫 Over the past few weeks, our team of 4 designed, deployed, and demoed ChocoJava — a cloud-native e-commerce platform running on AWS EKS. Here's what's under the hood 👇 ▸ 6 Spring Boot microservices, each with its own PostgreSQL database ▸ Spring Cloud Gateway + Eureka service registry ▸ Redis as the shared cache layer for hot reads ▸ Hybrid communication — OpenFeign + Resilience4j (sync) and Apache Kafka (async) ▸ Keycloak for SSO + JWT auth, validated at the gateway and inside every service ▸ AWS Secrets Manager + IRSA — zero static credentials in our container images ▸ Multi-AZ deployment with Kubernetes HPA scaling pods 2 → 5 at 70% CPU ▸ Jenkins CI/CD with immutable git-sha image tags and Kustomize overlays for dev/qa/uat ▸ React 19 + TypeScript + Tailwind frontend We recorded a 20-minute walkthrough that takes you through the live AWS console, the Keycloak login flow with a decoded JWT, a Kafka-driven email notification firing in real time, and the HPA scaling pods under load. 🎥 Full demo video → link in the first comment ⬇️ Biggest lesson? Async coupling forgives outages. Sync coupling amplifies them. Whenever the caller doesn't need the answer right now — reach for events. Huge respect to my teammates Ashfaq Riyaldeen, Ahamed Munsif and Shamil Kaleel for shipping this with me. If you've built or are building something cloud-native — what's one thing you'd do differently the second time? 👇 #CloudComputing #AWS #Kubernetes #Microservices #SpringBoot #Kafka #Redis #DevOps #SoftwareEngineering #Java #SystemDesign

🚀 Just shipped my biggest backend project yet! Built a production-grade E-Commerce Platform with 3 Spring Boot microservices communicating asynchronously via Apache Kafka. Here's what I built: 🏗️ Architecture: → product-service (port 8081) — product catalog + Redis caching → order-service (port 8082) — orders + Kafka producer → payment-service (port 8083) — payments + Kafka consumer ⚡ How it works: 1. Client places order → saved as PENDING in MySQL 2. Kafka event published to "order.placed" topic 3. payment-service consumes the event 4. Redis checks idempotency key → prevents double payment 5. Payment processed → "payment.processed" event published 6. Order status updates to CONFIRMED — automatically! 🔑 Key patterns I implemented: ✅ Idempotency pattern — duplicate orders return 409 Conflict ✅ Dead letter topic — failed messages after 3 retries ✅ Redis caching — 5 min TTL on product reads ✅ Prometheus + Grafana — real-time metrics dashboard 🛠️ Full tech stack: Java 21 | Spring Boot 3.5 | Apache Kafka | Redis 7 | MySQL 8 | Docker Compose | Swagger UI | Prometheus | Grafana | Bootstrap 5 GitHub Link:https://lnkd.in/gDirSVGe Everything starts with one command: docker compose up --build 🐳 #Java #SpringBoot #Kafka #Microservices #Backend #Redis #Docker #OpenToWork #JavaDeveloper #SoftwareEngineering

Architecting a Distributed, Real-Time Auction Ecosystem: Introducing AuctionU I am excited to officially share AuctionU, my most ambitious project to date. This is a full-scale, event-driven microservices ecosystem designed to handle the high-concurrency and sub-second latency required for live digital auctions. Check out the live frontend here: https://lnkd.in/gygy_B4Y The Architecture & Tech Stack I moved away from the monolith to build a system where every component is decoupled, containerized, and built for scale. Backend: Java Spring Boot (Microservices), Apache Kafka (KRaft), Redis, Spring Gateway. Frontend: Next.js 15 deployed via Vercel. Security: Two-stage OTP verification with Redis and stateless JWT session management. Real-Time: WebSockets (STOMP) and Redis Pub/Sub for live bidding. Infrastructure: Docker Compose & ngrok. Engineering Highlights: 🔹Centralized Edge Routing: Implemented Kong API Gateway as the unified entry point for all client requests, managing service discovery and request routing across the microservices cluster. 🔹Custom Authentication Plugins: Configured Kong to handle centralized request validation, ensuring that only authenticated traffic with valid JWTs reaches the downstream Auth and Product services. 🔹Hybrid-Cloud Deployment: Deployed the Next.js frontend on Vercel, exposing the local Docker-containerized Kong Gateway through a secure ngrok tunnel to bridge the gap between local development and the public web. 🔹Concurrency & Data Integrity: Utilized ShedLock for distributed locking and the Transactional Outbox Pattern to ensure the "Winning Bid" logic is executed exactly once, preventing race conditions during high-concurrency auction closures. 🔹Real-Time Bid Streaming: Bridged Kafka event streams with WebSockets and Redis Pub/Sub to enable live, sub-second bid updates across all connected clients. 🔹Secure Onboarding: Built a robust registration flow that stages user data in Redis during OTP verification, ensuring the MySQL database only persists verified users. Building AuctionU taught me that the hardest part of software isn't writing code—it's managing state and consistency across moving parts. It’s about building a system that is "collision-proof" even under heavy load. Check out the code and architecture here: https://lnkd.in/grfChGWu #Microservices #SpringBoot #ApacheKafka #DistributedSystems #SystemDesign #SoftwareEngineering #AuctionU #NextJS #Docker #Vercel #BackendDevelopment

🚀 The Reading Retreat - Built a Scalable Microservices Blog Platform – Full Stack Project Excited to share my project where I built a production-ready blog application using Microservices Architecture ⚡ 📌 Project Overview: This is a real-world scalable blog platform designed with a microservices approach to ensure flexibility, performance, and maintainability. Instead of a monolithic structure, the app is split into multiple services. 🔗 Live Demo: https://lnkd.in/daGQKNfe 💻 GitHub Repo: https://lnkd.in/dMp6y65z ⚙️ Tech Stack: Node.js | Express | MongoDB | PostgreSQL | Redis | RabbitMQ | Docker | Next.js | Vercel 🧠 Key Highlights ✅ Microservices Communication using RabbitMQ (event-driven architecture) ✅ Redis Caching with smart cache invalidation for performance optimization ✅ Hybrid Database Design PostgreSQL → structured data MongoDB → flexible content storage ✅ Authentication with Google OAuth 2.0 ✅ Dockerized Services for consistent deployment ✅ Next.js Frontend deployed on Vercel #FullStackDevelopment #Microservices #NodeJS #NextJS #SystemDesign #WebDevelopment #Docker #Redis #RabbitMQ

I am excited to share my latest project: Real-Time Bidding Microservices Ecosystem This project was a strong technical challenge where I applied a microservices architecture to handle real-time bidding with high efficiency, low latency, and scalability 📦 To follow the DRY principle and speed up development, I used a shared package that I previously built and published on NPM: @bts-soft/core. It handles common logic across NestJS services such as validation, caching, and notifications. I also created a separate package for authentication and authorization to better organize access control across services 💡 This experience was important to me for two main reasons: 1️⃣ First, this is my first complete project using Go (Golang) in production-like scenarios. I used it in core services such as Auction and Bidding, where its concurrency model made a clear difference in performance-critical paths. 2️⃣ Second, I focused heavily on testing. For the first time, I implemented a full testing setup with both unit and E2E tests using Jest, covering services written in both Go and NestJS. This significantly improved my confidence in the system’s stability 🏗️ Architecture Overview The system consists of 5 microservices and an API Gateway: 1) User Service: NestJS, PostgreSQL, Redis 2) Auction Service: Go, MongoDB 3) Bidding Service: Go, Redis, MongoDB 4) Notification Service: NestJS, MongoDB, WebSockets 5) AI Service: NestJS, MongoDB (price prediction) The API Gateway uses GraphQL Federation to provide a unified and flexible interface for clients ⚙️ Communication & Infrastructure For inter-service communication: • gRPC with Protobuf for synchronous calls • NATS for asynchronous messaging (Pub/Sub) For infrastructure: • Docker for containerization • Kubernetes for orchestration • NGINX for ingress • Skaffold to streamline local development on Kubernetes I’ve included the project and package links below. I’d appreciate any feedback or discussion around the architecture and design decisions 🔗 GitHub Repo: https://lnkd.in/dka_dyfA 📦 NPM Package: https://lnkd.in/di7jmhuM 🌐 Portfolio: https://lnkd.in/dAh96_da #Microservices #Backend #Go #NestJS #Kubernetes #Docker #gRPC #GraphQL #NATS #Redis #PostgreSQL #SoftwareEngineering

Most backend applications work. Very few are production-ready and scalable. I’m shifting from standalone APIs to building end-to-end backend systems focused on performance, scalability, and reliability. Currently integrating: → Redis (caching, performance optimization) → Docker (containerization, consistent environments) → CI/CD (automated testing & continuous deployment) → WebSockets (real-time, event-driven communication) Key learning: API development is easy. System architecture and data flow are the real challenges. From request → cache → database → real-time updates, everything must work seamlessly. Focusing on scalable backend architecture and system design. Flowchart : Mermaid.live #backenddevelopment #nodejs #systemdesign #redis #docker #devops

🧠 How Kafka + Spring Boot Microservices actually work in an eCommerce system Most posts say “used Kafka with microservices”… but here’s what really happens under the hood 👇 Let’s say a user places an order: 1️⃣ Order Service * Receives the request (REST API) * Saves order in DB * Publishes an event to Kafka topic: order-created 2️⃣ Kafka (Message Broker) * Acts as a middle layer between services * Stores the event and delivers it to all subscribed services * Ensures services don’t directly depend on each other 3️⃣ Payment Service (Consumer) * Listens to order-created topic * Processes payment * Publishes payment-success / payment-failed 4️⃣ Inventory Service (Consumer) * Listens to payment-success * Reduces stock * Publishes inventory-updated 5️⃣ Notification Service * Listens to all events * Sends email/SMS to user 🔁 Flow becomes: Order → Kafka → Payment → Kafka → Inventory → Kafka → Notification 💡 Why Kafka here? * Asynchronous communication (no waiting between services) * Loose coupling (services don’t call each other directly) * Easy scalability (add more consumers without changing producer) 💡 Key Learning: Instead of tightly coupled API calls, events drive the entire system. This is how real-world scalable systems (like eCommerce platforms) are designed. #Kafka #SpringBoot #Microservices #EventDrivenArchitecture #SystemDesign #Java

Day 5 of Java Backend Spring boot Challenge Today I started building Microservice Project in Spring boot. Microservices with Spring Boot — Starting my project OrderFlow OrderFlow is a scalable microservices-based e-commerce backend system built using Spring Boot, Spring Cloud, Kafka, and JWT authentication. Today, I developed the first service: Order Service Workflow of Order Service: Client (Postman / Frontend) ⬇️ Controller (Receives HTTP request & maps API endpoints) ⬇️ Service Layer (Handles business logic like creating/fetching orders) ⬇️ Repository Layer (Interacts with database using JPA) ⬇️ Database (MySQL — stores order data) Key Features Implemented: REST APIs for Create, Get, Delete Orders Clean architecture (Controller → Service → Repository) MySQL integration using Spring Data JPA Lombok for reducing boilerplate code This is just the beginning — next step is integrating Inventory Service and enabling service-to-service communication. I had also Developed the HLD of my Project. If anyone wants to give suggestion to improve my project. Feel free to DM me or Write comments. #Microservices #SpringBoot #Java #BackendDevelopment #SystemDesign #OrderFlow #LearningInPublic #SoftwareDevelopment Github Link : https://lnkd.in/gvFruDht

🚀 Built a Scalable Product Variant System (PVS) with Auth & Concurrency Handling Excited to share my latest backend-focused project: Ecommerce PVS (Product Variant System) — designed to handle complex product structures and real-world concurrency challenges. 💡 This project focuses on solving core e-commerce problems like: • Managing multi-dimensional product variants (size, color, etc.) • Generating all possible variant combinations (SKU logic) • Preventing race conditions during concurrent operations ⚙️ Tech Stack: • Node.js, Express • MongoDB (Replica Set with Transactions) • Redis (for caching & distributed locking) • JWT Authentication • Zod (schema validation) • Swagger (API documentation) 🔥 Key Features: • 🔐 Secure JWT-based authentication (access + refresh tokens) • 🧠 Advanced variant combination engine • ⚡ Redis distributed locking (SET NX PX + Lua script) • 📦 Consistent stock handling under concurrent requests • 📄 Swagger API docs for easy testing • 🧩 Clean modular architecture (scalable & maintainable) 🛠️ Engineering Highlight: Implemented a distributed locking mechanism using Redis to ensure that only one process can modify product variants at a time — preventing data inconsistency in high-concurrency scenarios. 📚 What I learned: • Handling concurrency in backend systems • Designing scalable APIs • Working with MongoDB transactions (Replica Set) • Writing safer and predictable code using schema validation 🔗 GitHub Repo: https://lnkd.in/dUngbV9M Would love to hear your feedback 🙌 #BackendDevelopment #NodeJS #Redis #MongoDB #FullStackDeveloper #SoftwareEngineering #API #WebDevelopment