Harish Rawat’s Post

Backend systems look simple… until you think about how they behave with real users, retries, and concurrent requests ⚡ I built a ride-sharing backend using Spring Boot, MySQL, Redis, and Flyway to explore what actually goes into designing a system like this beyond basic APIs 🚖 The system supports: • Rider and driver management 👤 • Real-time driver location updates 📍 • Nearest-driver matching 🚗 • Idempotent ride requests using request IDs 🔁 • Concurrency-safe driver assignment to prevent double booking 🔒 • Redis caching for faster driver lookups ⚡ • Database indexing and query optimization for efficient matching 📊 I also used k6 to simulate concurrent traffic and see how the system behaves when multiple requests hit at the same time. Working on this gave me a much clearer understanding of how backend systems are designed to stay consistent and reliable under real-world conditions. Github: https://lnkd.in/gZh_f4TS Would love to hear your thoughts or feedback 👍 #BackendEngineering #SystemDesign #SpringBoot #JavaBackend

🚀 ShieldGate – Day 3 & Day 4 Update Building my own API Rate Limiter & Monitoring System (MERN + Redis) from scratch. After setting up the basics, I focused on the core backend logic and performance 👇 ⚙️ Day 3: Sliding Window Rate Limiting (Core Logic) Implemented a Sliding Window Log Algorithm using Redis Sorted Sets ✔ Tracks requests per IP in real-time ✔ Removes outdated requests automatically ✔ Ensures accurate rate limiting within a time window 📊 Result: Backend can decide in <50ms whether to allow or block a request 🛡️ Day 4: Middleware Integration + Performance Optimization Built a reusable Express Middleware (shieldGate) and optimized it for real-world performance. 🔹 Middleware (Plug & Play System) ✔ Automatically intercepts every request ✔ Calls central rate limiter service ✔ Blocks excessive requests (429 status) ✔ Fail-safe design (continues even if limiter fails) ⚡ Performance Optimization (Caching) Enhanced middleware using in-memory caching ✔ Reduced unnecessary API calls ✔ Implemented Cache HIT / MISS strategy with TTL ✔ Improved response time from ~600ms → ~7ms ⚡ 🧠 Key Learnings Middleware execution order is critical Avoid infinite loops in internal API calls Caching significantly improves performance System design is about how components communicate efficiently 🛠️ Tech Stack Node.js • Express • Redis • MongoDB • Docker • Axios 🔗 GitHub Repository 👉 https://lnkd.in/gcEpiMsp . . . . . #BackendDevelopment #SystemDesign #Redis #NodeJS #MERN #SoftwareEngineering #100DaysOfCode

🚀 LinkForge — Update Here’s a quick update on my URL shortener side project, LinkForge, as I continue improving and refining the system. ⚙️ Recent Improvements Improved password complexity validation for better security Fixed N+1 query issue to optimize database performance Shifted from Redis-based counters to MongoDB counters for more reliable URL ID generation Added rate limiting on the redirect route to prevent abuse Added queue metrics for better visibility into background jobs Moved CORS configuration to environment variables Added basic route and Redis monitoring for system health tracking GitHub Repository: https://lnkd.in/gYfVbD4j If you find this project useful or interesting, consider starring the repo ⭐ and sharing your feedback! #LinkForge #NodeJS #MongoDB #Redis #BackendDevelopment #FullStackDevelopment #SideProject

Today I focused on optimizing authentication performance in my Django backend. Instead of relying on the default JWT flow (which hits the database on every request), I implemented a custom authentication class with a Redis caching layer. Now the flow looks like this: • JWT is verified (no database call) • User data is fetched from Redis cache • Database lookup is skipped for most requests • Token blacklist is checked to handle logout/revocation This small change significantly reduces database load and makes the system more scalable as traffic grows. I also added a fallback to the default behavior in case the cache misses, so the system remains reliable. It’s one of those improvements that users don’t see directly, but it makes a huge difference in performance under real usage. Next step: extending this to handle permissions and roles more efficiently.

🚀 Day 1–2 of building ShieldGate — API Rate Limiter System Started working on a real-world backend project focused on preventing API abuse and improving system reliability. 🔧 What I’ve built so far: • Backend setup using Node.js & Express • Integrated MongoDB for API key & user management • Set up Redis using Docker for high-speed operations • Implemented Sliding Window Rate Limiting using Redis Sorted Sets 📊 Current Capability: The system can now track real-time request count per IP within a rolling 60-second window. 💡 Key Learning: Learned how Redis Sorted Sets (ZADD, ZREMRANGEBYSCORE, ZCARD) enable efficient and scalable rate limiting using a sliding window approach. 🔗 GitHub Repo: https://lnkd.in/gcEpiMsp . . . . . #NodeJS #BackendDevelopment #Redis #SystemDesign #WebDevelopment #MERN #100DaysOfCode

🚨 I thought Redis = just caching… I was wrong. While building my Spring Boot project, I used Redis assuming: 👉 “It’s just a second-level cache to avoid hitting the DB” But then I implemented a virality scoring system… and everything changed. ❌ My initial thinking: Redis = store DB data temporarily Use it to reduce queries to PostgreSQL ⚡ What I actually built: A system where: • Bot reply → +1 score • Human like → +20 score • Human comment → +50 score 👉 These values update in real-time using Redis. 🤯 Realization: This data is NOT coming from DB. It is created, updated, and managed entirely inside Redis. ✅ What Redis actually became in my project: • Real-time counter system (increment) • Cooldown manager (TTL expiry) • Fast in-memory engine for dynamic scoring 💡 Key Insight: Redis is not just caching. 👉 It’s a real-time data engine for: counters rate limiting ranking systems temporary logic 🛠️ Want to see the actual implementation? GitHub Repo: https://lnkd.in/gWDsRXqD 🧠 Lesson: If you only use Redis as a cache, you’re using maybe 30% of its power. Next: Upgrading this using Sorted Sets (ZSET) to build a real “trending posts” system 🚀 #Java #SpringBoot #Redis #BackendDevelopment #SystemDesign

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

Built a URL Shortener from scratch today 🔗 Nothing fancy, but as a student still finding my footing in backend development, this one felt good to complete. What went into it: → Node.js + Express for the server → MongoDB + Mongoose for storing URL mappings → nanoid for generating unique short IDs → REST API design (POST to shorten, GET to redirect) Small project, big lessons — async/await, middleware, dynamic routing, and why order of code actually matters Code here if you want to check it out 👉 https://lnkd.in/geZNtcVu Still learning every day. If you're a fellow student building small projects and figuring things out as you go — keep going, it adds up. #NodeJS #MongoDB #WebDevelopment #100DaysOfCode #StudentDeveloper #BackendDevelopment

I didn’t just build a URL shortener; I built a Distributed System capable of handling millions of requests. 🚀 Most people use a simple Database Auto-Increment for IDs. But what happens when you have 10 servers running at once? You get ID collisions. In my latest project, EspressoLinks, I tackled the challenges of System Design and High Availability: 🔹 Distributed ID Generation: Used Redis Atomic Counters (INCR) to ensure unique short-keys across a cluster of 3 Spring Boot instances. 🔹 Latency Optimization: Implemented a Cache-Aside pattern with Redis, dropping redirection latency from 85ms to 4ms (a 21x improvement!). 🔹 Load Balancing: Configured an Nginx Load Balancer to distribute traffic using a Round-Robin algorithm. 🔹 Resilience: Built a "Failover" mechanism—if Redis goes down, the system gracefully falls back to PostgreSQL without crashing. This project taught me how to move beyond "it works on my machine" to "it works at scale." 🛠 Tech Stack: Java 17, Spring Boot 3, Redis, PostgreSQL, Nginx, Docker, and Bucket4j. Check out the architecture and source code here: https://lnkd.in/gDTHaiGY #Java #SpringBoot #SystemDesign #Redis #Docker #BackendDevelopment #SoftwareEngineering #CloudComputing

Recently I wrapped up a small project exploring the intersection of containerisation and horizontal scalability using NGINX as load balancer. What was built: A fully containerised Flask + Redis web application, orchestrated with Docker Compose and scaled across three instances behind an NGINX load balancer. Key implementation details: - Deployed Flask + Redis using Docker Compose with dedicated volumes for both Redis persistence and NGINX configuration -Exposed the Flask application on port 5001 (Expose:5001 instead port 5001:5001) - Created three HTML pages : *Home.html- Static landing page served at http://localhost::5001 with no Redis dependency, loading instantly *About.html- Project overview and architecture description *Visits.html - A dynamic visit counter powered by Redis. Each request to /count triggers r.incr('visits'), instructing Redis to automically increment the visits key and return the updated value to Flask -Scaled to three Flask instances behind NGINX using: Ran the full stack with: docker compose up --scale web=3 --build What was learned: Containerisation, facilitated through Docker, provides a consistent and isolated runtime environment for each application instance, enabling seamless replication across multiple containers. Scalability, achieved through horizontal scaling and load balancing via Nginx, ensures that incoming traffic is distributed evenly across all running instances, preventing any single container from becoming a bottleneck. Together, these two principles form the foundation of a resilient and production-ready architecture, capable of dynamically responding to fluctuating workloads whilst maintaining uninterrupted service availability. Full repository available on GitHub: https://lnkd.in/eqKevYBC #Docker #Dockercompose #Flask #Redis #DevOps #Containers #NGINX CoderCo Project Demo: