Ujith B’s Post

🚨 Without connection pooling, your DB will struggle under load Spring Boot uses HikariCP by default. But default config isn’t always optimal. 💥 Issue I faced: Under load → DB connections exhausted Root cause: Pool size too small for concurrent traffic ✅ Fix: - Tuned max pool size - Monitored active connections 💡 Takeaway: Database is often the bottleneck. Connection pooling decides how well you scale. #Java #SpringBoot #BackendDevelopment #SoftwareEngineering  #Microservices #JPA #RESTAPI  #DeveloperLife #CareerGrowth

🧬 Spring Boot – Repository Layer & Database Concept Continuing my Spring Boot journey by understanding how applications interact with databases. 🧠 Key Learnings: ✔️ Role of "@Repository" in Spring Boot ✔️ How the repository layer handles data operations ✔️ Flow of application: Controller → Service → Repository → Database 💡 The repository layer acts as a bridge between business logic and the database, making data handling clean and organized. 💻 DSA Practice: • Finding duplicate characters • Sorting an array using basic logic ⌨️ Maintaining daily typing practice to improve speed and accuracy. 🧠 Quick Check: Which layer talks to the database? 👉 Repository ✅ Building a strong foundation in backend development step by step 🚀 #SpringBoot #Java #BackendDevelopment #Database #DSA #LearningInPublic #DeveloperJourney

One pattern that consistently improves performance in backend systems is introducing a caching layer between services and the database. In early stages of development, applications often query the database directly for most requests. It works fine when traffic is low. But as systems grow, repeated queries for the same data start putting unnecessary pressure on the database. In one system I worked on, introducing a caching layer for frequently accessed data significantly reduced database load and improved response times for several APIs. Caching isn’t always the first thing teams think about when designing services, but it often becomes one of the simplest ways to improve performance at scale. Like many things in distributed systems, small architectural adjustments can have a big impact once traffic increases. #BackendDevelopment #Java #Microservices #SoftwareEngineering

🚨 “Let’s add cache” is not always the right solution Caching improved one of my APIs from 800ms → 50ms. But later… it caused stale data issues in production. 💥 Problem: Users were seeing outdated data after updates Root cause: Cache was not invalidated properly ✅ Fix: - Added cache eviction on updates - Used TTL for safety 💡 Takeaway: Caching is easy to add. Hard to maintain correctly. Always plan invalidation before implementation. #Java #SpringBoot #BackendDevelopment #SoftwareEngineering  #Microservices #JPA #RESTAPI  #DeveloperLife #CareerGrowth

I’ve been spending a lot of time recently looking under the hood of Operating Systems—studying process states, concurrency, and thread scheduling. Instead of just reading about these concepts, I wanted to put the theory into practice by building a system that actually relies on them. I just finished engineering a fault-tolerant Distributed File System (DFS) from scratch using Java! 🚀 Instead of relying on heavy abstractions or frameworks like Spring Boot, I wanted to understand the raw mechanics of how enterprise storage systems (like HDFS or AWS S3) manage data, network traffic, and hardware failures. Here is what I built under the hood: ⚡ Custom TCP Protocol: Bypassed REST entirely for internal node communication, utilizing raw TCP Sockets for ultra-low latency binary streaming. 🧠 Concurrent Memory Safety: Designed the Master Node using a ConcurrentHashMap and thread pools to handle asynchronous web requests with constant-time lookups and zero memory corruption. 🔄 Auto-Recovery & Fault Tolerance: Engineered a replication algorithm (Factor of 3) with background Heartbeat daemons. If a Data Node OS process is terminated mid-operation, the Master instantly detects the failure and self-heals the download using backup replicas. 📊 Real-Time Visual Dashboard: Built a decoupled, asynchronous JavaScript/HTML/CSS frontend to map file chunks and monitor live node health. Building this forced me to navigate complex systems engineering challenges, from breaking network socket buffer deadlocks to managing disk I/O with Java NIO. It was an incredible way to bridge the gap between OS theory and real-world distributed architecture. If you want to see the code or run a "Chaos Monkey" test on the cluster yourself, check out the repository here: https://lnkd.in/gdsA2Hwm #SoftwareEngineering #Java #DistributedSystems #ComputerScience #Networking #WebDevelopment #BackendEngineering

Most developers think Spring handles 500 requests “all at once.” It doesn’t. Here’s what actually happens: Spring Boot (via embedded Tomcat in Spring Boot) uses a thread pool to handle incoming requests. Each request follows this path: → Request arrives at Tomcat → A free thread is assigned → DispatcherServlet routes it to your @RestController → Controller → Service → Database → Response is returned → Thread goes back to the pool That’s it. No magic. ━━━━━━━━━━━━━━━━━━━━ What happens when all threads are busy? → New requests are placed in a queue → If the queue is full, requests may be rejected (e.g., 503 errors depending on configuration) ━━━━━━━━━━━━━━━━━━━━ The real bottleneck isn’t traffic, it’s blocked threads. Consider this: A slow database call takes 3 seconds × 200 threads = Your system can stall under moderate load This is why backend engineers focus on: Thread pool tuning Reducing blocking operations Asynchronous processing (@Async) Efficient database access (connection pooling) Non-blocking architectures (Spring WebFlux) Key takeaway: Performance is not about handling more requests. It’s about how efficiently your threads are utilized. #Java #SpringBoot #Concurrency #BackendDevelopment #SoftwareEngineering #JavaDeveloper

💻 Diving deeper into Operating Systems & Distributed Systems Lately, I’ve been exploring core OS concepts like process management, multithreading, and synchronization—and I realized the best way to truly understand them is to build something that depends on them. So, I built my own Distributed File System (DFS) from scratch using Java 🚀 Rather than relying on high-level frameworks, I focused on understanding how real systems handle data distribution, failures, and communication at a low level. 🔧 What’s happening behind the scenes? ⚡ Socket-Based Communication Implemented direct TCP socket communication between nodes to enable fast and efficient data transfer without relying on REST APIs. 🧵 Concurrency & Thread Management Designed the system to handle multiple client requests simultaneously using thread pools and concurrent data structures, ensuring safe and efficient execution. 🛡️ Fault Tolerance & Replication Integrated a replication strategy to ensure data availability. Even if a node fails unexpectedly, the system can recover and continue serving requests seamlessly. 📡 Heartbeat Monitoring System Built a mechanism for continuous health checks of nodes, allowing the system to detect failures in real time and respond accordingly. 📊 Interactive Monitoring Interface Created a lightweight frontend dashboard to visualize file distribution and track node activity dynamically. 🧠 Key Takeaways Working on this project helped me connect theoretical OS concepts with real-world system design challenges—especially around network communication, synchronization, and fault handling. It also gave me a deeper appreciation for how large-scale systems maintain reliability under unpredictable conditions. 🔗 Project Repository: https://lnkd.in/gP-DAtj2 I’d love to hear your thoughts or feedback! #DistributedSystems #OperatingSystems #Java #BackendDevelopment #SystemDesign #ComputerScience #Networking

Unlock the full potential of your Spring applications this spring! Virtual threads are here to revolutionize concurrency, allowing millions of I/O-bound requests without blocking. Discover how to harness this power with Spring Boot 3.2, just a single property away. Read the full article to learn more: https://lnkd.in/gQKvdECS #concurrency #Java #Java21 #Performance #SpringBoot

💡 The file upload mistake that would've haunted me in production storing a full URL in your database is a trap. https://lnkd.in/getwKNqc — looks fine. works fine. until you switch storage providers and realize you now have 50,000 rows to update in production. Took me an embarrassing amount of time to figure out the right way: store only the key → users/abc123.jpg keep the base URL in your config combine them at runtime when building responses One env variable change. entire system migrated. database never stores a domain name again. That was just one of three things I got wrong building file uploads this week. The second one: skipping compression. a user uploads a 4MB phone photo, you store a 4MB phone photo. your storage bill is quiet now. it won't be later. compress before upload, not after. a 3MB image should leave your server under 150KB. The third: public storage buckets. if your file URL works forever with no auth, that's not a feature. generate signed URLs with expiry instead. 10 extra lines of code, one less thing to regret. File uploads feel like a solved problem until you actually build one properly. #Java #SpringBoot #BackendDev

I fixed a 4-second Spring Boot API without scaling anything. ⚠️the real problem? 47 database queries per request. 🧩we thought it was a performance issue. so we tried: • more RAM • indexes • monitoring CPU nothing changed. 🔍then I checked the SQL logs. and saw the real issue: → N+1 query problem → JPA lazy loading → 47 queries for a single API call 🛠️ the fix was simple: replace multiple queries with one optimized query: JOIN FETCH everything in a single DB call. 📉 result: • 4000ms → 190ms • 47 queries → 1 • DB CPU dropped massively 📌 lesson: don’t scale first. first understand what your code is doing to the database. #SpringBoot #Java #Backend #SystemDesign #APIs #SoftwareEngineering