Dynamic Programming & Backend Development Lessons

🚨 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 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 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

I hit a strange realization today. Not a new concept. Not a new framework. Just something I’ve already used in production. But still… *I couldn’t explain it cleanly. We often say “I know this.” But do we really? Today’s trigger was a simple API design scenario in Spring Framework: 👉 Upload a file + send structured JSON data in the same request Sounds basic, right? But when I tried to break it down clearly— the *why*, the *how*, the *right annotation*— there was hesitation. --- Then the clarity came back: * `@RequestParam` → key-value inputs * `@PathVariable` → resource identity * `@RequestBody` → pure JSON payload * `@RequestPart` → **multipart boundary where file + structured data meet That moment reminded me of something deeper: > “Exposure creates familiarity. > But only articulation proves understanding.” In real systems, this gap shows up everywhere: * You’ve seen the pattern, but can’t justify it * You’ve fixed the bug, but can’t explain root cause * You’ve used the annotation, but don’t know *why it exists* At scale, this matters. Because senior engineering is not about: ❌ Writing more code It’s about: ✔ Explaining decisions clearly ✔ Designing with intent ✔ Debugging with first-principles thinkin --- **Today wasn’t about learning something new. It was about realizing what I hadn’t fully understood.** And that’s a different kind of progress. #SoftwareEngineering #Java #SpringBoot #SystemDesign #Backend #EngineeringMindset

Most token optimization tools look at your config: unused skills, bloated system prompts, model routing. Tokenomics looks at something different: how you actually work. Roni Koren Kurtberg ran both approaches side by side on 240 Claude Code sessions and found completely different problems. Config audits catch the overhead you pay before typing a word. Behavioral analysis catches the patterns you repeat session after session without realizing it. 43% context snowball rate. 645 redundant file reads. 44% of sessions with unbounded bash output. No settings file will fix those. You need to see them first. Great post with real numbers, not theory.

Excited to share something I've been heads-down building over the past 3 months — CoderX, a competitive programming platform that automates the two hardest parts of running one: creating problems and judging submissions. No manual test cases. No human judges. The platform runs itself. Here's how it works under the hood: The system is split into 6 microservices communicating over REST, Redis queues, and WebSockets. — An AI service (FastAPI + LangChain + LLaMA-3) generates full problem sets autonomously: title, description, test cases, and language stubs. Before saving, it runs semantic deduplication via AstraDB vector search to keep the problem set diverse. — A submission service picks up your code, records the attempt, and enqueues it via BullMQ for processing. — An evaluator service pulls the job, spins up an isolated Docker container (Python, Java, or C++), and runs your code against all test cases with hard resource limits — 100MB RAM, 2 second timeout. Results are written back to the database as Accepted, Wrong Answer, or TLE. — A WebSocket service streams the verdict to your browser the moment execution completes. No polling, no page refresh. — The frontend uses a protected triple-editor where boilerplate is locked and only your logic section is editable — keeping submissions clean and consistent across all languages. Building this taught me a lot about distributed system design, async job orchestration, and secure code execution. Still shipping features, but the core loop is solid end to end. Github Link : https://lnkd.in/gSvuwrjV Open to feedback from anyone who's built something similar. #SystemDesign #Microservices #BuildInPublic #CompetitiveProgramming #SoftwareEngineering

🚨 This DP problem almost looked impossible… until I broke it down step by step. Day 23 of my Backend Developer Journey — and today was all about thinking in transitions, not brute force 👇 🧠 LeetCode Deep Dive Solved Minimum Total Distance Traveled 💡 What clicked: → Sorting robots & factories simplifies decisions → DP helps track minimum cost efficiently → Key idea: assign k robots to one factory within capacity ⚡ Transition-based thinking = Game changer ⚙️ Approach Breakdown ✔️ Sort robots & factories ✔️ Use DP → dp[i][j] = min distance for first i robots using first j factories ✔️ Try assigning multiple robots to a factory (within limit) 🔗 My Submission: https://lnkd.in/gtj9xka3 ☕ Spring Boot Learning Today I strengthened my understanding of Spring Data JPA 🚀 🔹 What I Learned: 👉 Dynamic Sorting with Sort.by() 👉 Pagination using Pageable 👉 Writing cleaner and scalable repository queries 🧠 The Real Learning 👉 DP is not about memorizing patterns 👉 It’s about breaking problems into smaller decisions 👉 Backend is not just CRUD 👉 It’s about efficient data handling at scale 📘 Spring Boot Notes: https://lnkd.in/gpWQvkyK 📈 Day 23 Progress: ✅ Improved DP intuition ✅ Better understanding of scalable APIs ✅ Stronger problem-solving mindset 💬 Have you ever struggled with DP until one idea suddenly made everything click? 👇 #100DaysOfCode #BackendDevelopment #SpringBoot #Java #LeetCode #DataStructures #CodingJourney

🚀 Backend Learning | Pagination Strategies (Offset vs Cursor-Based) While working on backend systems, I recently explored how to efficiently handle large datasets using pagination. 🔹 The Problem: • Fetching large datasets increases response time • High memory and database load • Poor user experience 🔹 What I Learned: • Offset-Based Pagination: → Uses LIMIT & OFFSET → Simple but slow for large data • Cursor-Based Pagination: → Uses a unique cursor (like ID or timestamp) → Faster and more efficient for large datasets 🔹 Key Insights: • Offset → Easy but not scalable • Cursor → Scalable and performant • Cursor avoids skipping large rows 🔹 Outcome: • Improved API performance • Efficient data fetching • Better user experience Handling large data is not about fetching more — it’s about fetching smartly. 🚀 #Java #SpringBoot #BackendDevelopment #SystemDesign #APIDesign #Pagination #LearningInPublic

Just built a working version of Andrej Karpathy's "LLM Knowledge Bases" idea with Spring AI. Karpathy recently shared how he uses LLMs to turn research materials into a self-maintaining personal wiki. Plain Markdown files, Obsidian on the front end, and the LLM handling summaries, backlinks, and cleanup. I loved the pattern, so I built it in Spring. karpathy-wiki is a local Spring Boot CLI app with three Spring AI agents: ✅ WikiCompilerAgent takes raw notes and URLs and turns them into a clean, linked wiki with articles, concepts, summaries, and an index. ✅ ResearchAgent answers questions against your wiki, generates new content like notes and Marp slides, and files it back in. ✅ WikiLinterAgent finds orphans, broken links, stubs, and contradictions to keep things tidy. Everything lives as plain .md files on disk. No vector DB, no black boxes. Just files you can version with Git. Built with: • Spring AI 2.0 and spring-ai-agent-utils • Spring Shell for the CLI • Java 26 The whole wiki schema and agent behavior is defined in one SCHEMA.md file, so it's easy to extend. Repo: https://lnkd.in/gkAZ7cdi If you're a Java or Spring developer looking at AI agents, personal knowledge management, or alternatives to RAG, I'd love your feedback. Give it a star, try it out, or let me know what you think. How do you build knowledge bases with LLMs? #SpringAI #Java #SpringBoot #AIAgents

Ever opened a file called UserManager.py only to discover it’s 3,000 lines long and handles literally everything from database connections to sending emails? 😅 We’ve all been there. In my daily work as a Back-end Developer, I've seen firsthand how these "God Classes" can turn a simple feature update into a terrifying game of Jenga. That’s why I’m kicking off a new series on Medium deep-diving into the SOLID principles, starting with the foundation: the Single Responsibility Principle (SRP). In this first article, we break down: - The danger of the "Swiss Army Knife" approach to coding - Real-world Python examples showing the exact "Before & After" of a refactor - The top 3 red flags to spot SRP violations in your own projects If you are looking to ditch the clutter and write cleaner, highly modular code, check out the full article here: https://lnkd.in/dxBcDgds What is the most outrageous "God Class" you have ever encountered in the wild? Let me know in the comments! #CleanCode #SoftwareEngineering #Python #SOLID #Backend #DeveloperLife #TechWriting