Simplifying Problem-Solving with Clarity and Discipline

🚨 I stopped loading all data at once today… and my API got smarter. Day 24 of my Backend Journey — and this is where things started feeling real-world 👇 🧠 LeetCode Learning Solved LeetCode 2515. Shortest Distance to Target String in a Circular Array 💡 What clicked: → Circular traversal thinking → Checking both directions (forward & backward) → No extra space needed ⚡ Smart iteration > complicated logic 🔗 My Submission:https://lnkd.in/gja7CGPS ☕ Spring Boot Realization Today I learned Pagination using Spring Data JPA 👉 Page = chunk of data 👉 Pageable = pagination config 👉 PageRequest = implementation Instead of loading everything: ✔ Fetch only what’s needed ✔ Add sorting + pagination ✔ Build scalable APIs 🧠 The Shift 👉 Backend is not just about working code 👉 It’s about efficient data handling Small changes like pagination = big impact in real apps 📘 Spring Boot Notes: https://lnkd.in/gRgxP7Th 📈 Day 24 Progress: ✅ Better API design understanding ✅ Improved problem-solving approach ✅ Thinking like a backend engineer 💬 Do you prefer writing optimized code first, or refining later? 👇 Let’s discuss #100DaysOfCode #BackendDevelopment #SpringBoot #Java #LeetCode #CodingJourney

🚨 This problem didn’t ask for optimization… but understanding possibilities. Day 33 of my Backend Developer Journey — and today was about 👉 maximizing outcome with flexible inputs 🧠 LeetCode Breakthrough Solved today’s Daily Challenge using greedy thinking 💡 What clicked: → Treat _ as flexible moves → Calculate current position → Use _ to maximize distance ⚡ The real trick: 👉 Don’t fix unknowns… 👉 use them to your advantage 🔍 Key Insight 👉 Known moves → fixed contribution 👉 Unknown moves → maximize result ⚡ Final answer = |current position| + number of flexible moves 🔗 My Submission:https://lnkd.in/ghdgkZVV ☕ Spring Boot Learning 🔄 Orphan Removal vs Cascade Delete Today I explored a subtle but powerful concept 👇 👉 Cascade Delete → Deletes child when parent is deleted 👉 Orphan Removal → Deletes child when it is removed from relationship ⚡ Key Difference 💡 Cascade = Parent-based deletion 💡 Orphan = Relationship-based deletion 🚨 N+1 Query Problem One of the most important backend performance issues 👇 👉 Fetch 1 parent → triggers N extra queries for children ⚡ Problem: 👉 Multiple unnecessary DB calls 🔥 Solution 👉 Use fetch join 👉 Use @EntityGraph 👉 Prefer JOIN FETCH in queries 🧠 The Shift 👉 Problems are not always about solving… but maximizing 👉 Backend performance matters as much as correctness 👉 Small concepts → huge real-world impact 📘 Spring Boot Notes: https://lnkd.in/gRgxP7Th 🔗 GitHub Repo (Project):https://lnkd.in/gWb8ZPdv 📈 Day 33 Progress: ✅ Learned greedy thinking approach ✅ Understood orphan removal vs cascade ✅ Discovered N+1 query problem 💬 Have you ever faced N+1 issues in your project? 👇 #100DaysOfCode #BackendDevelopment #SpringBoot #Java #LeetCode #SystemDesign #CodingJourney

🚨 Today wasn’t about solving problems… it was about fixing what was broken. Day 37 of my Backend Developer Journey — and honestly, 👉 this felt more like a real developer day 🧠 LeetCode Breakthrough Solved today’s Daily Challenge using Median + Math Optimization 💡 What clicked: → Flatten the grid into a single array → Check if all elements follow same modulo → Use median to minimize operations ⚡ The Real Trick 👉 If modulo condition fails → impossible ❌ 👉 If valid → median gives minimum operations ✅ 🔍 Key Insight 👉 Median minimizes absolute differences 👉 Math-based optimization beats brute force 🔗 My Submission: https://lnkd.in/gf43YBkq ☕ Spring Boot Learning 🐛 Debugging Day (Real Dev Life) Today was not smooth… and that’s okay 👇 👉 Faced issues with Lombok + Java 24 👉 Switched back to Java 21 👉 Bugs reduced, but still debugging ⚡ What I learned 👉 New versions ≠ always stable 👉 Compatibility matters more than hype 👉 Debugging is a core developer skill 🔌 Database Progress 👉 Successfully connected PostgreSQL to my server 👉 Backend is now interacting with real data 🧠 The Shift 👉 Not every day is productive — but every day teaches 👉 Debugging builds deeper understanding than coding 👉 Real growth happens when things don’t work 🔗 GitHub Repo (Lovable Clone): https://lnkd.in/gwHmAZaK 📈 Day 37 Progress: ✅ Learned median optimization technique ✅ Handled real-world debugging issues ✅ Connected DB to backend successfully 💬 What’s one bug that taught you more than any tutorial? 👇 #100DaysOfCode #BackendDevelopment #SpringBoot #Java #LeetCode #Debugging #CodingJourney

🚨 I didn’t optimize this problem… and that was the right decision. Day 31 of my Backend Developer Journey — and today taught me: 👉 Not every problem needs a complex solution. 🧠 LeetCode Breakthrough Solved today’s challenge using controlled brute force 💡 What clicked: → Compare each query with dictionary words → Count character differences → Accept if differences ≤ 2 ⚡ The real trick: 👉 Break early when condition fails 👉 Keep logic simple and readable 🔍 Key Insight 👉 Sometimes constraints allow brute force 👉 Optimization is useful… but only when needed ⚡ Clean logic > unnecessary complexity 🔗 My Submission: https://lnkd.in/gVDCQx5y ☕ Spring Boot Learning 🏥 Hospital Management System — Project Progress Today I leveled up my project significantly 👇 👉 Created core entities: → Patient → Insurance → Doctor → Appointment 🔗 Real Database Relationships 💡 Implemented real-world mappings: 👉 Patient ↔ Insurance (relationship mapping) 👉 Patient ↔ Appointment 👉 Doctor ↔ Appointment ⚡ This is where backend becomes real: 👉 Not just tables… but connected data systems 🔥 Big Realization 👉 Designing relationships is harder than writing APIs 👉 Good schema design = scalable backend 🧠 The Shift 👉 Simplicity in DSA + Complexity in System Design 👉 Moving from coding → engineering thinking 👉 Building something real changes everything 📘 Spring Boot Notes: https://lnkd.in/gpWQvkyK 🔗 GitHub Repo (Project): https://lnkd.in/gWb8ZPdv 📈 Day 31 Progress: ✅ Practiced clean brute-force logic ✅ Designed real-world DB relationships ✅ Strengthened project-building mindset 💬 What’s harder according to you — DSA problems or designing real systems? 👇 #100DaysOfCode #BackendDevelopment #SpringBoot #Java #LeetCode #SystemDesign #CodingJourney

🚨 I thought this was just grouping… but prefix sums changed everything. Day 32 of my Backend Developer Journey — and today was about 👉 turning brute force into math 🧠 LeetCode Breakthrough Solved today’s Daily Challenge using HashMap + Prefix Sum logic 💡 What clicked: → Group indices of same values → Use prefix sums to calculate distances efficiently → Avoid recalculating distances again and again ⚡ The real trick: 👉 Don’t compute distances individually 👉 Precompute and reuse calculations 🔍 Key Insight Instead of O(n²): 👉 Split into left + right contribution 👉 Use running sums ⚡ Optimized to O(n) 🔗 My Submission: https://lnkd.in/g9Dar9cq ☕ Spring Boot Learning 🔄 Cascading in JPA (Game Changer for Projects) Working on my Hospital Management System, I explored cascading 👇 👉 CascadeType.PERSIST 👉 CascadeType.MERGE 👉 CascadeType.REMOVE 👉 CascadeType.ALL ⚡ Why this matters 💡 Instead of manually saving related entities: 👉 Save parent → child automatically saved 👉 Delete parent → child automatically handled 🔥 Real Example 👉 Saving Patient → Insurance also gets saved 👉 Deleting Patient → related records handled automatically 🧠 The Shift 👉 Optimization = math + observation 👉 Backend = relationships + lifecycle management 👉 Projects teach more than theory ever will 📘 Spring Boot Notes: https://lnkd.in/gpWQvkyK 🔗 GitHub Repo https://lnkd.in/gWb8ZPdv 📈 Day 32 Progress: ✅ Learned prefix sum optimization ✅ Understood cascading deeply ✅ Improved real-world backend thinking 💬 Do you prefer solving problems using logic or math-based optimization? 👇 #100DaysOfCode #BackendDevelopment #SpringBoot #Java #LeetCode #CodingJourney #SystemDesign

🚨 I didn’t check every pair… and still got the maximum distance. Day 29 of my Backend Developer Journey — and today was about 👉 thinking smart instead of thinking more 🧠 LeetCode Breakthrough Solved “Two Farthest Houses with Different Colors” 💡 What clicked: → No need to compare all pairs → Just compare with first and last house → Expand from both ends ⚡ The real trick: 👉 The farthest distance will always involve either the first or the last element 🔍 Key Insight Instead of brute force (O(n²)): 👉 Use two pointers 👉 Compare edges only ⚡ Optimized to O(n) with simple logic 🔗 My Submission:https://lnkd.in/gE4cBmuV ☕ Spring Boot Learning 🔁 JPA Repository Revision Today I revisited the core of Spring Data JPA 👇 👉 JpaRepository simplifies database operations 👉 No need to write boilerplate SQL 👉 Built-in methods like: → save() → findById() → findAll() → delete() ⚡ Why this matters 💡 Strong fundamentals > New concepts 👉 Writing less code 👉 Getting more done 👉 Cleaner backend design 🧠 The Shift 👉 Optimization is about observing patterns 👉 Revising basics makes concepts stronger 👉 Backend mastery = consistency + clarity 📘 Spring Boot Notes:https://lnkd.in/gpWQvkyK 📈 Day 29 Progress: ✅ Improved problem-solving efficiency ✅ Strengthened JPA fundamentals ✅ Practicing consistency daily 💬 Have you ever solved a problem faster by doing less work? 😄 #100DaysOfCode #BackendDevelopment #SpringBoot #Java #LeetCode #CodingJourney

Day 91 of My 9-Month Coding Challenge 🎯 Logging & Monitoring in Backend Systems 📊 Today, I focused on improving backend observability using structured logging and basic monitoring practices—because writing code is only half the job; understanding what happens in production is equally critical. 🛠️ What I Worked On: ✔ Implemented structured logging using tools like Winston / Morgan ✔ Logged incoming requests, responses, and error stacks ✔ Differentiated log levels (info, warn, error, debug) ✔ Stored logs in files for persistence and debugging ✔ Added environment-based logging (dev vs production) 📚 Key Learnings: ✅ Logs are the first line of defense when debugging production issues ✅ Structured logs make it easier to trace and analyze system behavior ✅ Excessive logging can impact performance—balance is important ✅ Never log sensitive data (passwords, tokens, etc.) ✅ Monitoring + logging together give full system visibility 🧠 Core Concept: Reliable Backend = Observability (Logging + Monitoring) + Error Tracking 💡 Insight: You can’t fix what you can’t see. Good logging turns unknown bugs into solvable problems. Still learning. Still improving. Still consistent. 💯 #Day91 #9MonthChallenge #NodeJS #ExpressJS #BackendDevelopment #Logging #Monitoring #WebDevelopment #MERN #BuildInPublic #Consistency

Claude Code's source code leaked yesterday. 512,000 lines of TypeScript, now public. I went through it and extracted the architectural patterns that show up consistently across the codebase — the engineering decisions behind how it works. A few examples: Every tool throws a typed error on failure — never returns { success: false }. The framework catches it and formats it for the LLM. The tool has one job: do the work or throw. One schema definition drives both TypeScript types and JSON validation. They share one source and can never drift. Concurrency safety is evaluated per invocation, not declared statically. Same tool, different answer depending on the input. Packaged all 16 as portable skill files that load automatically into Claude Code, Cursor, Gemini CLI, Codex, and OpenCode. Zero config. MIT license. → https://lnkd.in/d6nQvdGf #AIEngineering #ClaudeCode #DeveloperTools #OpenSource

🛠️ 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧: 𝐏𝐚𝐠𝐢𝐧𝐚𝐭𝐢𝐨𝐧 & 𝐒𝐨𝐫𝐭𝐢𝐧𝐠 𝐢𝐧 𝐚 𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 A𝐏𝐈 When working with large datasets, returning everything at once is never a good idea. It increases response time, impacts performance, and doesn’t scale well. 🔍 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 My API was returning a huge dataset in a single response → leading to slow performance and inefficient data handling. 💡 𝐖𝐡𝐚𝐭 𝐭𝐡𝐢𝐬 𝐢𝐦𝐩𝐫𝐨𝐯𝐞𝐬 ✔️ Breaks large data into manageable pages ✔️ Reduces response payload ✔️ Improves API performance ✔️ Allows dynamic sorting ✔️ Supports field-based sorting ascending order 🧠 𝐊𝐞𝐲 𝐭𝐚𝐤𝐞𝐚𝐰𝐚𝐲 Backend development is not just about returning data it’s about returning it efficiently and responsibly. 📈 𝐑𝐞𝐚𝐥-𝐰𝐨𝐫𝐥𝐝 𝐢𝐦𝐩𝐚𝐜𝐭 Pagination combined with sorting is essential for building scalable APIs, especially when handling large datasets in production systems 🔽 Adding the implementation below for reference #SpringBoot #Java #BackendDevelopment #APIDesign #SoftwareEngineering

I built something a bit unusual, and I’m not entirely sure how to introduce it without sounding like every other “AI will change everything” post… so I’ll just explain what I actually did. Over the past years working on business applications (especially in insurance), I noticed that a large part of the codebase is not really “logic” in the traditional sense. It’s forms. And behind those forms: endless rules, conditions, validations, and document generation. At some point, it starts to feel like we are just translating domain documents into code, line by line, with a lot of if/else along the way. So I built a small demo to explore a different approach. Instead of hardcoding the form, the application takes a description of a context, uses AI to generate relevant questions step by step, validates the input dynamically, and finally produces a document (report/contract) as a PDF. It’s not a product. It’s not production-ready. It’s just a proof of concept to test an idea: what if forms were generated from intent instead of code? For this project, I also stepped out of my usual stack (C#/.NET) and built it using Java and Spring, partly as a technical exercise, partly because I’m currently exploring opportunities in the Java ecosystem. The application is not fully public (API costs are real), but I’m happy to give access if you’re curious. If you’re interested in the idea, or just want to take a look: 👉 https://csohaib.dev/ And if nothing else, at least now I have one less excuse to complain about forms.