Optimizing Spring Boot API Performance with EntityGraph and Caching

🚀 Day 15/100: Spring Boot From Zero to Production Topic: Default Logging in Spring Boot Logging is your application’s Black Box recorder. It captures every action, error, and heartbeat so you aren't flying blind when things break. The best part? In Spring Boot, it works like magic from the moment you hit "Run." The "Zero-Config" Starter You don't have to download a single library to get started. Every Spring Boot Starter (Web, Data, etc.) automatically pulls in spring-boot-starter-logging. By default, it uses Logback as the engine and SLF4J as the universal interface. > Set to INFO by default (it hides the "noisy" DEBUG/TRACE logs). > It automatically shows the Date, Time, Log Level, PID, Thread Name, and the actual Message. You can steer the "defaults" directly from your application.properties file: Change the Volume: logging.level.root=DEBUG to see everything. Save to Disk: logging.file.name=app.log to stop losing logs when the console closes. Target Packages: logging.level.org.hibernate=SQL to only watch specific internal actions. While the default is great for your local machine, it’s not enough for production. For big projects, we need file rotation, JSON formatting, and environment-specific rules. In the next post, we’ll look at how to take this to a Professional Grade using XML configuration. Stay tuned! #Java #SpringBoot #SoftwareDevelopment #100DaysOfCode #Backend #Logging #Logback #SoftwareEngineering

kyndl update: the backend is live. This week I completed Steps 1 and 2 of the Phase 4 build — Node.js server, BullMQ job queue, Postgres schema, and 180 days of quit-smoking messages seeded into a real database. But the thing I keep thinking about isn't the code. It's the review process. Claude Code builds fast. But three times this week I caught something before it hit production: · A duplicate row that would have silently sent two messages to every user on the same day — forever, until someone noticed · A blanket content edit that didn't match the spec we designed in Phase 2 · A missing trigger tag that would have sent the wrong message variant to the wrong user segment None catastrophic. All of them meaningful for an app where message timing and tone directly affect whether someone stays quit. The pattern I'm taking away: audit before you edit. Report before you change. Commit before you touch the database. Claude Code is a powerful co-author. But it still needs someone who understands the product deeply enough to know when something's off. That part doesn't get automated. Phase 4 continues. Steps 3–9 ahead.

Building for Scale: Leveling up the "Vela Route" Backend 🛠️📦 It’s been a week of deep dives into the "Spring Way" of doing things. I’ve just wrapped up two major features for my logistics project, Vela Route, that take it from a simple prototype to a more robust, enterprise-ready API. 🚀 Dynamic Search with JPA Specifications: > Instead of writing static queries, I implemented a modular search system. Using the Criteria API, I built "LEGO-like" specifications that allow the API to filter by status and destination dynamically. This ensures the database handles the heavy lifting while keeping the code clean. 🛡️ Global Exception Handling: > I moved away from messy try-catch blocks and implemented a Global Exception Advisor. By using @ControllerAdvice, the app now has a centralized "security guard" that catches errors and returns standardized, professional JSON responses. Next up: Optimizing tracking number lookups with advanced data structures. #Java #SpringBoot #Backend #SoftwareEngineering #VelaRoute #LearningInPublic #PostgreSQL #Docker

Had one of those “everything looks fine… but it’s not” production moments recently. An API that usually responds in ~120ms suddenly started taking 2–3 seconds. No errors. No crashes. Just… slow. At first glance, nothing obvious: CPU was okay, memory wasn’t maxed out, service was up. But digging deeper turned into a good reminder of how real-world slowness actually happens 👇 --- Started with threads. Tomcat thread pool was almost full. Not completely exhausted, but close enough that new requests were waiting. So the service wasn’t doing more work — it was just taking longer to start doing the work. --- Then the DB. One query that used to take ~20ms was now taking ~150ms. Why? Data had grown. Index wasn’t helping anymore the way we expected. And of course… there was a hidden N+1 query in one flow. Didn’t matter in testing. Hurt in production. --- Then downstream calls. This API was calling 2 other services. Individually fast (~50–80ms), but together they added up. And when one of them slowed slightly, everything stacked. No timeout issues. Just latency compounding quietly. --- The interesting part? None of these were “major bugs”. It was: – slightly slower DB – slightly busy threads – slightly delayed downstream service All happening together. --- And that’s when it hits you: We don’t usually design systems to fail — we design them assuming things will stay fast. But in reality, systems degrade, not break. --- What helped: Stopped guessing. Looked at: – thread metrics – DB query timings – per-service latency Fixed the biggest contributor first (DB query + fetch strategy), and suddenly everything else started looking normal again. --- Big takeaway for me: Performance issues in microservices are rarely dramatic. They’re gradual, layered, and easy to miss until users feel them. And debugging them is less about “what’s broken?” and more about “where is time actually going?” #Java #SpringBoot #Microservices #ProductionIssues #BackendEngineering #SystemDesign

Professional Structure & Secure Auth: Day 11 of Backend Mastery Day 11 was about one thing: Refactoring for Scale. As my applications grow, "spaghetti code" becomes a liability. Today, I dismantled my monolithic setup and rebuilt it using industry-standard folder structures. Day 11 Key Progress: Modular Architecture: Separated the entry point (server.js) from the application logic (src/app.js). This makes testing and scaling much cleaner. Database & Config Decoupling: Moved MongoDB connection logic to a dedicated database.js file and environment settings to a config/ folder. This is how real-world enterprise apps are built. Advanced CRUD & Validation: It’s not enough to just "save" data. I implemented robust Error Handling and Validation Logic to ensure the database stays clean and the server never crashes on bad input. Authentication Schema: Designed my first Schema specifically for Authentication. This involved thinking deeply about data integrity, required fields, and the foundation for secure user login. Building a backend is 20% writing code and 80% designing the system that holds it. 11 days in, and the vision is becoming clear. Current Goal: Finalizing the Authentication flow to turn this into a multi-user platform. @Mentor ~ Ankur Prajapat #MERNStack #NodeJS #ExpressJS #SoftwareArchitecture #CleanCode #BackendEngineer #100DaysOfCode #WebDevelopment

We wrote 60,000 lines of Rust to power a TypeScript framework, and are now sharing what that journey actually looked like. The runtime handles everything underneath your application code - HTTP, databases, pub/sub, tracing, caching, API gateway - all running multi-threaded in the same process as Node.js. Give it a read: https://lnkd.in/dd-bwM-J

One of the biggest technical bets we've made at Encore, and it's paying off every day. The post goes into the full story.

This article from Encore is a really interesting use case of portability, I really liked the fun part "Pingora didn't support Windows when we started using it, and since Encore needs to run on Windows for local development, we added Windows support to Pingora and contributed it upstream. So today Pingora runs on Windows thanks to Encore. 🙌"

Solving Data Consistency: Real-Time Search Syncing in Spring Boot 🔄 Yesterday I built the engine (a custom Trie search), but today I built the fuel line. In my logistics app, Vela Route, I faced a classic challenge: How do I ensure my high-speed search index stays updated when new data hits the database? 🛠️ The Implementation: I integrated a "Dual-Write" strategy within the Service layer. Now, every time a new shipment is persisted to PostgreSQL, it is immediately injected into the Trie in-memory. ✅ The Result: Zero lag between data entry and searchability. No app restarts required. 🧠 The Takeaway: It’s one thing to use a data structure; it's another to architect a system where your cache and your database live in perfect harmony. Feeling more confident in Java's strictness every day—even if the syntax still keeps me on my toes! #SoftwareEngineering #Backend #Java #SpringBoot #VelaRoute #SystemDesign #BuildingInPublic #FullStack

Stop celebrating “working code” that secretly makes 18 DB calls per request. Yes, it works. No, it won’t survive production scale. I keep seeing this pattern in backend systems—especially in Spring Boot + ORM-heavy apps: 👉 Loop over data 👉 Trigger queries inside each iteration 👉 Ship it because “it passes tests” Congrats. You just built a silent performance killer (N+1 problem). ⸻ 💥 What’s really happening? • Every component fires its own query • Network round trips explode • DB gets hammered under load • Latency spikes… and nobody knows why ⸻ 🚀 How real engineers fix it 1. Kill the N+1 problem at the root • Stop DB calls inside loops • Identify where queries multiply 2. Use JOINs like your system depends on it (because it does) • Let the database handle relationships • One optimized query > 18 scattered ones 3. Batch your queries • Replace repeated calls with IN clauses • Fetch data in chunks, not one-by-one 4. Push computation to the database • Use GROUP BY, COUNT, SUM • Avoid unnecessary processing in your app layer 5. Control ORM behavior • Lazy loading inside loops = disaster • Use eager fetching strategically, not blindly 6. Cache hot data • Frequently accessed data should NOT hit DB every time • Use Redis / in-memory caching smartly ⸻ 🔥 Production mindset shift This isn’t “optimization.” This is system design discipline. Because at scale: Your biggest bottleneck isn’t CPU… it’s how many times you talk to your database. ⸻ “Reduce multiple DB queries by eliminating N+1 using joins, batch fetching, aggregation, and caching—designing a single optimized query for production systems.” ⸻ If your API is making double-digit DB calls per request… you don’t have a backend problem. You have a design problem. ⸻ #Java #SpringBoot #SystemDesign #BackendEngineering #Scalability #PerformanceEngineering #MicroservicesArchitecture #SoftwareArchitecture #LowLatency #HighAvailability #DistributedSystems #APIPerformance #DatabaseOptimization #ORM #Hibernate #Caching #Redis #SRE #TechLeadership