Priya Pandey’s Post

Day 21. My API crashed with a StackOverflowError. Not because of bad code. Because of a relationship I didn’t think twice about. I had this: @Entity public class User { @OneToMany(mappedBy = "user") private List<Order> orders; } @Entity public class Order { @ManyToOne private User user; } Looks normal. Until you return it as JSON. Here’s what actually happens: → User → Orders → User → Orders → User… → Infinite recursion → StackOverflowError → Your API crashes That’s not a bug. That’s how your model is designed. Hibernate understands it. Jackson doesn’t. So I fixed it. (see implementation below 👇) Now: → DTOs control the response → No circular references → No accidental data explosion The hard truth: → Bidirectional relationships are easy to write → They’re dangerous to expose → You won’t notice until production Returning entities is convenient. Controlling your API response is what makes you a backend developer. Have you ever hit this error? 👇 Drop it below #SpringBoot #Java #Hibernate #BackendDevelopment #JavaDeveloper

🚨 My code was fine… my configuration was the problem. Day 40 of my Backend Developer Journey — and today felt like a real developer day 🧠 LeetCode Breakthrough Solved a problem using mathematical optimization (Rotation Function) 💡 What clicked: → Reuse previous computation → Avoid recalculating entire function → Derive relation between rotations ⚡ The Real Trick 👉 Instead of O(n²), use: F(k) = F(k-1) + sum - n × last_element 🔍 Key Insight 👉 Precompute total sum 👉 Build answer iteratively 👉 Turn brute force into O(n) 🔗 My Submission: https://lnkd.in/gRWYfwKj ☕ Spring Boot Learning 🐛 Hibernate Tables Not Creating — Debugging Story Everything looked correct… but: ❌ Tables were NOT getting created 🔍 Root Causes 👉 ddl-auto not set properly 👉 Old compiled files interfering 👉 Maven build not clean ✅ Fix ✔ Set in application.yml: spring: jpa: hibernate: ddl-auto: create ✔ Cleaned previous compiled files ✔ Reinstalled dependencies ✔ Rebuilt project 🔥 Result 👉 Tables created successfully 👉 JPA repositories detected 👉 Backend working as expected 🧠 The Shift 👉 Backend issues are often hidden in config 👉 Debugging > Coding (some days 😅) 👉 Real learning happens when things break 🔗 GitHub Repo: https://lnkd.in/gwHmAZaK 📈 Day 40 Progress: ✅ Learned rotation function optimization ✅ Fixed real Hibernate issue ✅ Improved debugging mindset 💬 What’s the most frustrating config bug you’ve faced? 👇 #100DaysOfCode #BackendDevelopment #SpringBoot #Java #LeetCode #Debugging #CodingJourney

Day 29. I enabled query logging for the first time. What I saw surprised me. I had this: List<User> users = userRepository.findAll(); Simple. Clean. One line. I assumed Hibernate was handling it efficiently. Then I added this: spring.jpa.show-sql=true And watched the logs. Not one query. Multiple hidden ones. → Fetch users → Then fetch relationships → Then more queries behind the scenes Hibernate wasn’t optimizing anything. It was executing exactly what I told it to — lazily, one relationship at a time. That’s when it clicked. ORM doesn’t optimize your queries. It executes what you tell it to. (see fix below 👇) Or better: 👉 Fetch only what you need (DTO projection) What I learned: → Hibernate is not magic → Default behavior is not always efficient → You are responsible for query performance The hard truth: → “It works” doesn’t mean “it’s optimized” → ORM hides complexity — it doesn’t remove it Writing code that runs is easy. Understanding what your database is actually doing is what makes you a backend developer. Have you ever checked your query logs and been surprised? 👇 Drop your experience #SpringBoot #Java #Hibernate #BackendDevelopment #Performance #JavaDeveloper

#SpringUnpackedSeries - 03 Continuing from: https://lnkd.in/gJ4Wg6XN === HOW SPRING BOOT + JPA SIMPLIFY YOUR DATA LAYER? === Ever wonder how Spring Boot manages to connect to a database with almost zero manual setup? It’s all about the "Autopilot" mode! When you combine Spring Boot with JPA (Java Persistence API), the framework takes over the repetitive, "boring" parts of coding, allowing you to focus on building features rather than plumbing. --- The 3-Step Magic Trick --- • Step 1: The Input You provide the basics: a few dependencies in your build.gradle, simple properties, and your @Entity classes. That’s it! • Step 2: The Autopilot Spring Boot kicks in to scan your project. It finds your database drivers, initializes Hibernate, and automatically sets up the EntityManagerFactory. • Step 3: The Result The framework builds the "heavy" machinery. It generates SQL, manages transactions, and handles connection pooling without you writing a single line of JDBC code. --- Why This Matters? --- • Speed: Go from an empty project to a working database layer in minutes. • Clean Code: No more messy boilerplate or manual SQL management. • Efficiency: Let the framework handle complex tasks like Transaction Management and Data Access automatically. #SpringUnpacked #SpringBoot #Java #JPA #Hibernate #SoftwareDevelopment #CodingLife #BackendDevelopment #ProgrammingTips #TechCommunity #WebDevelopment

🚨 I almost overcomplicated this problem… but pattern recognition saved me. Day 25 of my Backend Developer Journey — and today was all about thinking in cycles 🔁 🧠 LeetCode Breakthrough Solved LeetCode 3488. Closest Equal Element Queries 💡 What clicked: → Group indices using HashMap → Treat indices as circular (important!) → Compare nearest left & right occurrences ⚡ The real trick: Not linear thinking… but circular distance calculation 🔍 Key Insight Instead of checking all elements: 👉 Preprocess positions 👉 Use modulo to simulate circular array 👉 Reduce time complexity significantly 🔗 My Submission: https://lnkd.in/gKBBY7ds ☕ Spring Boot Learning 🔄 Hibernate Entity Lifecycle Today I learned how Hibernate manages objects internally: 👉 Transient – Object created, not in DB 👉 Persistent – Connected to DB (tracked by Hibernate) 👉 Detached – Exists but not tracked 👉 Removed – Marked for deletion 💡 Why this matters: Understanding lifecycle = avoiding unexpected DB behavior 🧠 The Shift 👉 Problems are not always linear 👉 Sometimes the data structure defines the solution 👉 Backend isn’t just coding — it’s understanding system behavior 📘 Spring Boot Notes: https://lnkd.in/gRgxP7Th 📈 Day 25 Progress: ✅ Stronger problem-solving ✅ Better understanding of Hibernate internals ✅ Thinking beyond brute force 💬 Have you ever solved a problem only after changing the way you looked at it? #100DaysOfCode #BackendDevelopment #SpringBoot #Java #LeetCode #CodingJourney

🚨 I solved this problem… but the real learning was in how I stored data. Day 26 of my Backend Developer Journey — and today was all about thinking ahead while iterating 👇 🧠 LeetCode Breakthrough Solved LeetCode 3761. Minimum Absolute Distance Between Mirror Pairs 💡 What clicked: → Reverse the number to find its mirror → Store reversed values in HashMap → Check distance while iterating ⚡ The key trick: Instead of searching later… 👉 Prepare data in advance while traversing 🔍 Key Insight 👉 Store future-use data (reversed numbers) 👉 Avoid nested loops 👉 Reduce time complexity to O(n) 🔗 My Submission: https://lnkd.in/gUZ5QUKc ☕ Spring Boot Learning 🔄 Hibernate Entity Lifecycle Deep Dive Today I didn’t just learn states… I understood how Hibernate actually behaves internally 👉 Transient – Only in heap memory 👉 Persistent – Connected & tracked by Hibernate 👉 Detached – Exists but not tracked 👉 Removed – Marked for deletion ⚡ Real Game Changer 💡 Persistence Context (First-Level Cache) 👉 Same entity = same reference 👉 Avoids repeated DB calls 👉 Managed automatically using @Transactional 🔥 Powerful Concept 👉 Updating entity WITHOUT calling save() still works Why? Because Hibernate tracks changes in Persistent State ⚡ This is called: Dirty Checking (not Dirty Read — common mistake 👀) 🧠 The Shift 👉 Efficient coding = smart data preparation 👉 Hibernate is not magic — it’s predictable when understood 👉 Backend = Data + Lifecycle + Optimization 📘 Spring Boot Notes: https://lnkd.in/gRgxP7Th 📈 Day 26 Progress: ✅ Improved hashmap intuition ✅ Understood Hibernate internals deeply ✅ Learned real-world DB optimization concept 💬 Did you know Hibernate updates data even without calling save()? 😄 #100DaysOfCode #BackendDevelopment #SpringBoot #Java #LeetCode #CodingJourney

🚨 I replaced 3 hours of Spring Boot boilerplate with a 12-second Claude Code prompt. Here's the exact prompt pattern I used : "You are a Senior Java architect. Generate a production-grade Spring Boot microservice for [domain]. Include: layered architecture, global exception handling, Hibernate N+1 prevention, and Swagger annotations. Follow SOLID. Output only code." -- What I got back in seconds: ✅ Entity + Repository (with JPQL, no lazy load traps) ✅ Service layer with transaction boundaries ✅ DTO projection to avoid over-fetching ✅ ControllerAdvice with RFC 7807 error format -- What used to take a junior dev 2 days → done in 12 seconds. The game isn't "AI writes your code." The game is "how precisely can you architect your prompt?" Vague input = vague output. Architectural thinking + AI = 10x output. Are you still writing boilerplate manually in 2026? -- Drop a 🔥 if you've tried Claude Code. #SolutionArchitect #ClaudeCode #SpringBoot #AIEngineering #Java #SoftwareArchitecture #DeveloperProductivity

Was working on a Spring Boot REST API the other day. Everything looked fine entity class, repository, controller all set up. But two fields, createdAt and updatedAt, were coming back null in every response. Spent time checking the constructor, the DTO mapping, the database config. Turns out I just needed two annotations: @CreationTimestamp → auto-sets the time when record is created @UpdateTimestamp → auto-updates the time on every save Two lines. That's it. Hibernate handles everything behind the scenes you don't set these manually. One more thing I'd missed without @JsonFormat, Java's Timestamp serializes weirdly in JSON. Add this and it formats cleanly: @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") Small things. But they'll silently break your API if you miss them. #Java #SpringBoot #Backend #LearningInPublic #HibernateJPA

Stop putting Lombok’s @Data on your JPA Entities. I know it saves time. You create a new Entity, slap @Data at the top of the class, and instantly get all your getters, setters, and string methods without writing boilerplate. But after 9 years of debugging Spring Boot applications, I can tell you this is one of the most common ways to silently crash your server in production. Here is why Senior Engineers ban @Data on the database layer: 1. The StackOverflowError Trap If you have a bidirectional relationship (like a User entity that has a list of Order entities, and an Order points back to a User), @Data generates a toString() method that calls the toString() of its children. User calls Order, Order calls User, and your app crashes in an infinite loop the second you try to log it. 2. The Performance Killer @Data automatically generates equals() and hashCode(). In Hibernate, evaluating these on lazy-loaded collections can accidentally trigger a massive database query just by adding the entity to a HashSet. You suddenly fetched 10,000 records without writing a single SELECT statement. The Senior Fix: Keep your database entities explicit and predictable. Instead of @Data, just use @Getter and @Setter. If you absolutely need a toString(), write it yourself or use @ToString.Exclude on your relational fields to break the loop. Lombok is an amazing tool, but using it blindly on your entities is a ticking time bomb. Have you ever taken down a dev environment because of an infinite toString() loop? Let's share some war stories below. 👇 #Java #SpringBoot #Hibernate #CleanCode #SoftwareEngineering #BackendDevelopment #LLD #SystemDesign

🚀 Top 20 Most Useful Spring Boot Annotations Every Developer Should Know Spring Boot is not about memorizing annotations. It is about knowing which one to reach for and why. Here are the 20 that actually matter in real projects: → @SpringBootApplication – This annotation is used to bootstrap a Spring Boot application and launch it through the Java main method. → @RestController – Build REST APIs easily → @RequestMapping – Define base URL paths → @GetMapping / @PostMapping – Handle HTTP requests → @RequestBody – Convert JSON request into a Java object. → @Valid – Data Validation Made Easy → @PathVariable– It helps you extract values directly from the URL. → @RequestParam– is used to get values from URL query parameters. → @Service – Business logic layer → @Repository – Database interaction layer → @Entity – Map Java class to database table → @Id – Define primary key → @Table – is used to map a Java entity class to a specific database table name. → @Autowired – Dependency injection (use constructor injection in modern practice) → @Transactional – is used to manage database transactions automatically. → @Component  –   is the fallback for everything else → @Configuration  –   is used to define custom Spring configuration classes. → @Bean – registers objects you cannot annotate directly → @ControllerAdvice –  centralizes exception handling → @EnableScheduling –  is used to enable scheduled tasks in your Spring Boot application. Knowing these 20 is the difference between writing Spring Boot code and actually understanding the framework. #SpringBoot #Java #BackendDevelopment #DevOps #SoftwareEngineering #Microservices #LearningJourney