Week 1 Progress Report: DSA, React, Spring Boot, SQL

Weekend learning mode: ON. 🎧💻 I’ve spent the last two days heavily focused on advancing my backend architecture skills with Java. Moving into enterprise development means understanding the tools, but also mastering the web fundamentals that hold it all together. Here’s what I’ve been tackling: 🌐 Web Basics: Solidifying the foundations—HTTP/HTTPS lifecycle, REST API design principles, and configuring CORS securely. ⚙️ Spring Core: Getting hands-on with Dependency Injection (IoC) and understanding how the container handles Bean scopes and lifecycles. 🛡️ Spring AOP: Learning how to cleanly modularize cross-cutting concerns (like logging and security) without cluttering up the core business logic. Transitioning to Java has been challenging, but realizing how powerful these frameworks are for building scalable systems makes it completely worth it. What is one topic you think every backend developer needs to master early on? Let me know! #Java #Backend #API #SpringFramework #DeveloperJourney #LearnInPublic

While working on backend systems, I revisited some features from Java 17… and honestly, they make code much cleaner. One feature I find really useful is Records. 👉 Earlier: We used to write a lot of boilerplate just to create a simple data class. Getters Constructors toString(), equals(), hashCode() ✅ With Java 17 — Records: You can define a data class in one line: public record User(String name, int age) {} That’s it. Java automatically provides: ✔️ Constructor ✔️ Getters ✔️ equals() & hashCode() ✔️ toString() 💡 Practical usage: User user = new User("Dipesh", 25); System.out.println(user.name()); // Dipesh System.out.println(user.age()); // 25 🧠 Where this helps: DTOs in APIs Response objects Immutable data models What I like most is how it reduces boilerplate and keeps the code focused. Would love to know — are you using records in your projects? #Java #Java17 #Backend #SoftwareEngineering #Programming #Microservices #LearningInPublic

Testcontainers + MockMvc Most developers test their database code against an in-memory database. It's fast, it's easy to set up, and it lies to you. Your production app runs on PostgreSQL. Your tests run on H2, which has a different engine, different behavior, and different edge cases. You can have 100% passing tests and still ship a bug that only exists in production. So I made a different choice. My integration tests spin up a real PostgreSQL container via Testcontainers, run every assertion, then tear it down. My end-to-end tests go one step further using MockMvc to fire real HTTP requests through the full Spring stack, hitting the actual controller, service, repository, and database. No shortcuts at any layer. No mocks. No surprises in production. Testcontainers (testcontainers.com) makes this easy; it supports Java, Go, Python, .NET, and has native integration with Spring Boot 3+. Not the easiest path. The correct one. --- 💬 Do you test against a real database or an in-memory one? Drop it in the comments. 🔗 Full project: https://lnkd.in/dse3hHTV 🔗 Testcontainers: https://testcontainers.com #Java #SpringBoot #Testing #BackendDevelopment #SoftwareEngineering

🚀 Spring Boot Learning – @RestController vs @RequestMapping While building REST APIs in Spring Boot, I explored how requests are handled behind the scenes. 🔹 @RestController Used to create REST APIs. It combines @Controller + @ResponseBody and returns data directly (JSON/String). 🔹 @RequestMapping Used to map URLs to classes or methods and can handle different HTTP methods. 💡 Modern Approach (Shortcut Annotations) Instead of using @RequestMapping for everything, Spring provides: -> @GetMapping -> @PostMapping -> @PutMapping -> @DeleteMapping These make code cleaner and more readable. 📌 Key Insight: 👉 @RestController creates APIs 👉 Mapping annotations connect URLs to methods Sharing a simple graphical representation to make this concept easier to understand. 📊 #SpringBoot #Java #BackendDevelopment #RESTAPI #DependencyInjection #JavaDeveloper #LearningInPublic

Why write 100 lines of code when the same can be done in 10? 🚀 Day 1 of my Spring Learning Series Today, I started my journey into the Spring Framework, aiming to understand how modern enterprise applications are built efficiently. The first concept I explored was the difference between: • **Languages (Java)** → the foundation we build on   • **Technologies (Servlets)** → tools that help solve specific problems   • **Frameworks (Spring)** → structured solutions that handle most of the heavy lifting  A simple way to see it: Building with a language is like starting from raw materials, while using a framework is like working with a ready-made structure — you focus more on customization than construction. This shift in perspective made me realize how powerful frameworks are in writing cleaner, scalable, and maintainable code. Looking forward to diving deeper into Spring in the coming days. What was the first framework that changed the way you code? #SpringFramework #Java #BackendDevelopment #SoftwareEngineering #LearningInPublic #TechJourney

🚀 Day 11: Scope & Memory – Mastering Variable Types in Java 🧠📍 Today’s focus was on understanding where data lives in a program—a crucial step toward writing efficient and predictable code. In Java, the way a variable is declared directly impacts its scope, lifetime, and memory allocation. Here’s how I broke it down: 🔹 1. Local Variables – Temporary Workers ⏱️ • Declared inside methods • Accessible only within that method • Created when the method starts, destroyed when it ends • ⚠️ Must be initialized before use (no default values) 🔹 2. Instance Variables – Object Properties 🏠 • Declared inside a class, outside methods • Require an object to access • Each object gets its own copy • Changes in one object do NOT affect another 🔹 3. Static Variables – Shared Data 🌐 • Declared with the static keyword • Belong to the class, not objects • Accessed using the class name (no object needed) • Only one copy exists, shared across all instances 💡 Key Takeaway: Variable scope is more than just visibility—it’s about memory management and data control. Knowing where and how variables exist helps in building optimized and scalable applications. Step by step, I’m strengthening my foundation in Java and moving closer to writing production-level code. 💻 #JavaFullStack #CoreJava #CodingJourney #VariableScope #MemoryManagement #Day11 #LearningInPublic

🧬 Spring Boot – Understanding @RequestBody Today I learned how Spring Boot handles data coming from the client using @RequestBody. 🧠 Key Concept: 👉 "@RequestBody" is used to receive JSON data from the frontend and convert it into a Java object automatically. 🔁 Flow: Client (JSON) → @RequestBody → Java Object 💡 This makes API development clean and efficient without manual parsing. ✔️ Helps in handling POST & PUT requests ✔️ Automatically maps request data to objects ✔️ Simplifies backend code 📌 Real Use Case: • Creating users • Updating data • Handling form submissions 💻 DSA Practice: • Prime number check • Factorial calculation 🧠 Quick Check: "@RequestBody" is used to receive data from client ✅ ✨ Understanding how data flows from frontend to backend is a key step in mastering REST APIs. #SpringBoot #Java #BackendDevelopment #RESTAPI #WebDevelopment #DSA #LearningInPublic

Most used Spring Boot annotations (that you’ll see almost everywhere) If you’ve worked with Spring, you already know… half the magic is in annotations 😅 Here are some of the ones I keep using almost daily: * @SpringBootApplication → starting point of the app * @RestController → tells Spring this class handles APIs * @RequestMapping / @GetMapping / @PostMapping → for routing requests * @Autowired → dependency injection (used a lot, sometimes too much 👀) * @Service → business logic layer * @Repository → database layer * @Component → generic bean * @Entity → maps class to DB table * @Id → primary key * @Configuration → for config classes * @Bean → manually define beans when needed When I started, I used to just memorize these. Over time, I realised understanding when NOT to use them is equally important. Like: * overusing @Autowired everywhere * mixing @Component, @Service randomly * not understanding bean lifecycle Spring feels simple at start, but there’s a lot going under the hood. If you’re learning Spring right now → focus less on remembering, more on understanding what each annotation actually does. Which Spring annotation do you use the most? 👇 #ThoughtForTheDay #SpringBoot #Java #Backend #SoftwareEngineering

Day 95 of my consistency journey Today was all about going deeper into building my URL Shortener project and strengthening my backend fundamentals. I focused on understanding how real-world systems handle redirection, database interaction, and scalability. Instead of just coding, I tried to think like a backend engineer — why things are designed a certain way, not just how. 💡 Key takeaways from today: - How URL redirection actually works behind the scenes - Importance of clean architecture in backend systems - Thinking in terms of scalability from the start - Strengthening Java + Spring Boot fundamentals Consistency is slowly turning confusion into clarity. Still a long way to go, but showing up every day is the real win. #Day95 #Consistency #BackendDevelopment #Java #SpringBoot #SystemDesign #100DaysOfCode

🧬 Spring Boot – Understanding API Responses Today I explored how Spring Boot sends data from backend to frontend. 🧠 Key Learnings: ✔️ Returning a Java object automatically converts it to JSON ✔️ Spring Boot uses Jackson internally for this conversion ✔️ "@ResponseBody" ensures data is sent directly as response 💡 Best Practice: 👉 Using "@RestController" simplifies everything (Combination of @Controller + @ResponseBody) ✔️ Explored different return types: • Object • List • String • ResponseEntity (for better control over status & response) 🔁 API Flow: Request → Controller → Service → Return Object → JSON Response → Client 💻DSA Practice: • Even/Odd check using modulus • Sum of first N numbers (optimized using formula) ✨ Understanding how backend responses work is key to building real-world REST APIs. #SpringBoot #Java #BackendDevelopment #RESTAPI #WebDevelopment #DSA #LearningInPublic #SoftwareEngineering