Debosmit Choudhury’s Post

Backend Ladder #004: Timeouts are a feature No timeout = "I'm okay waiting forever." You're not. Your users aren't. Your thread pool definitely isn't. My rule for every external call: - a timeout (always) - a retry policy (sometimes none — that's fine) - a clear fallback (even if it's just a fast error) 💬: One missing timeout could take down an entire checkout flow. The dependency was fine. We weren't. #Reliability #Java #SpringBoot — 📌 I’m running a Backend Ladder series to share the notes, patterns, and hard lessons I’ve collected over the years building backend systems—one small topic at a time.

🧠 Spring @Transactional – Why Your Rollback Didn’t Happen This is one of the most dangerous “it works… until it doesn’t” scenarios in Spring. You mark a method with @Transactional. You throw an exception. You expect a rollback. But nothing rolls back. And you don’t notice… until production. ❌ The Problem: Self-Invocation In Spring, @Transactional works through proxies. When a method inside the same class calls another @Transactional method using this.method(), 👉 it bypasses the proxy. 👉 no interception happens. 👉 no transactional behavior is applied. In the image above: updateUser() calls this.sendEmail() That internal call never goes through Spring’s proxy. If sendEmail() fails? The save operation may NOT roll back. Silent failure. No warning. ✅ The Fix: Go Through the Proxy Instead of calling the method directly: Use self-injection Or move the transactional logic to a separate service When you call through the injected proxy (self.sendEmail()), Spring can properly intercept the call and apply transactional behavior. Now your rollback works as expected. 🎯 The Real Lesson Transactions are not just annotations. They are proxy-driven runtime behavior. If you don’t understand how Spring AOP works under the hood, you’ll eventually debug this at 2 AM. Have you ever been bitten by self-invocation in Spring? Let’s hear your story 👇 #Java #SpringBoot #SpringFramework #Transactional #SoftwareArchitecture #CleanCode #JavaDevelopment #BackendDevelopment

Day 19 – Exception Handling in Spring Boot Today I focused on handling exceptions properly in Spring Boot applications. Exception handling is important for building reliable and production-ready APIs. Instead of exposing raw errors, we should return meaningful and structured responses. =>@ControllerAdvice Used to handle exceptions globally across the entire application. It allows centralized error handling instead of writing try-catch blocks in every controller. =>@ExceptionHandler Used to handle specific exceptions. It defines what response should be returned when a particular exception occurs. => Custom Exceptions Creating custom exception classes improves clarity. For example, throwing a ResourceNotFoundException when data is not found makes the API more meaningful. => Proper exception handling improves: Code cleanliness User-friendly error responses Maintainability API reliability Structured exception handling is essential for building production-ready and maintainable backend systems. #Day19 #SpringBoot #ExceptionHandling #Java #BackendDevelopment #LearningJourney

Backend debugging reminder: When an API fails, check the contract before the code. I traced a Spring Boot endpoint where the controller, service, and SQL were all correct. The real failure point: DTO fields didn’t match the incoming JSON payload. No obvious exception. Business logic never executed. The request failed during deserialization. One naming mismatch broke the entire flow. Engineering takeaway: Backend systems fail more often at boundaries (API contracts, schemas, serialization) than in core logic. This is now my first checkpoint when debugging APIs. #BackendDevelopment #Java #SpringBoot #Debugging #SoftwareEngineering

🚀 Why @RestController is a Game Changer in Spring Boot 🔥 One annotation that instantly elevates your API development: @RestController Behind the scenes, it combines: @Controller + @ResponseBody 💪 Why it’s powerful: 👉 Automatically converts Java objects into JSON 👉 Eliminates unnecessary boilerplate 👉 Makes REST APIs clean, readable, and production-ready 👉 Encourages modern API design practices Sometimes, one annotation makes all the difference. 💡 #Java #SpringBoot #BackendDevelopment #SoftwareEngineering #TechGrowth

Many developers (including me earlier) rely heavily on Spring Boot to build applications quickly. But it’s easy to overlook what actually happens inside the Spring IoC container, especially how the Bean Lifecycle works. So I spent some time revisiting how Spring manages beans internally from bean instantiation, dependency injection, and initialization, to destruction callbacks using annotations like @PostConstruct and @PreDestroy. Understanding the Bean Lifecycle gives a much clearer picture of how Spring controls object creation, manages dependencies, and maintains the application context. Sometimes stepping back from the abstractions of Spring Boot and revisiting the core Spring Framework concepts helps build a stronger foundation. Back to strengthening the fundamentals. 💡 #Java #SpringFramework #SpringBoot #BackendDevelopment #DependencyInjection #SoftwareEngineering

Day 17 – Spring Boot Annotations Explained Today I focused on understanding some important Spring Boot annotations that power backend applications. -> @RestController Combines @Controller and @ResponseBody. It is used to create REST APIs and return JSON responses directly. -> @RequestMapping Maps HTTP requests to specific handler methods. It defines the URL path and supports different HTTP methods like GET, POST, PUT, and DELETE. -> @Autowired Used for Dependency Injection. Spring automatically injects required beans into a class. -> @Configuration Indicates that a class contains bean definitions. Spring processes it to generate and manage beans in the application context. Understanding these annotations helps in writing clean, structured, and maintainable backend code. Spring Boot reduces complexity, but knowing what happens behind the scenes makes a real difference. #Day17 #SpringBoot #Java #BackendDevelopment #Annotations #LearningJourney

Day 03 Refining my Backend Skills via Projects Today I worked on Global Exception Handling in my Spring Boot Blog API project . What I implemented: • Created a custom ResourceNotFoundException • Added GlobalExceptionHandler using @RestControllerAdvice • Implemented @ExceptionHandler to return clean API error responses • Improved API responses using a custom ApiResponse class • Updated the Custom DTO to Model Mapper This helps make APIs more robust and production-ready by handling errors in a structured way . #Java #SpringBoot #BackendDevelopment #CodingJourney #100DaysOfCode

How I Detect Bean Initialization Issues in Spring Boot When facing bean initialization issues in large applications, I follow these steps: ✔️ Check startup logs carefully ✔️ Look for exceptions like BeanCreationException or dependency errors From here we will clearly show which bean is failed and why. ✔️ Identify the exact bean from the stack trace ✔️ Check for circular dependencies If two beans depends on each other in that scenario spring throws an error. ✔️ Verify active profiles I will check is there any missing or wrong profiles configured. ✔️ Ensure proper component scanning and base package structure I will make sure all classes are inside base package of main class annotated with @SpringBootApplication. Most of the time, reading logs properly helps find the root cause quickly. #SpringBoot #Java #BackendDevelopment #Debugging

🚀 Day 28 / 100 | Swap Nodes in Pairs -Intuition: Instead of swapping values, swap the actual nodes by adjusting the links. Move the second node of each pair before the first node and repeat this for the entire list. -Approach : O(n) -Initialize a dummy node and point it to head -Set prev pointer to dummy (helps in connecting swapped pairs) -Traverse the list while head and head.next are not null -Set first = head (first node of pair) -Set second = head.next (second node of pair) -Connect prev to second -> prev.next = second -Move first to next pair -> first.next = second.next -Complete swap -> second.next = first -Move prev forward -> prev = first -Move head to next pair -> head = first.next -Repeat until list ends -Return dummy.next as new head. #100DaysOfCode #LeetCode #Java #DataStructures #LinkedList