Your team has built a generic repository used by several Spring Boot services for caching reference data before it’s persisted.

A teammate recently tried to reuse it for a new feature and hit a compilation error.

You’re reviewing their pull request.

The new feature does this:

Repository<User> repository = new Repository<>();

List<AdminUser> admins = List.of(
        new AdminUser("Alice"),
        new AdminUser("Bob")
);

repository.saveAll(admins);   // Compilation error

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 8300+ subscribers for hand-crafted, no-fluff content.

Upgrade to paid now (60% discount) and get the annual membership at $50/year forever that is ~ $4/mo.

So far we have covered 79+ real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

Why this code doesn't compile?

A common misconception is:

"AdminUser extends User, so List<AdminUser> should extend List<User>."

That's not how Java generics work. Generics are invariant.

Read more

You are building the “Trending Searches” feature for a large e-commerce platform.

Every day, the search system processes:

• 500 million search queries

• Millions of unique search terms

• Queries coming from multiple regions

• Multiple search clusters

The product team wants:

Trending Searches

1. iphone 17
2. air fryer
3. java spring boot
4. running shoes
5. wireless headphones

Problem

Design a system that returns the Top K most frequently searched queries in near real-time.

The API should expose:

GET /trending-searches?k=10

Response:

[
  {
    "query": "iphone 17",
    "count": 1254300
  },
  {
    "query": "air fryer",
    "count": 985000
  }
]

Initial Implementation

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 8300+ subscribers for hand-crafted, no-fluff content.

Upgrade to paid now (60% discount) and get the annual membership at $50/year forever that is ~ $4/mo.

So far we have covered 70+ real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

Why does this implementation not work at production scale?

The algorithm requires loading all queries into memory. For example:

500 million queries/day
+
millions of unique terms
=
Huge memory requirement

The map grows with every unique query: Map<String,Integer>

Example:

{
 "iphone": 100000,
 "java": 50000,
 "docker": 30000
}

Problems:

• High memory usage

• Cannot handle continuous streams

• Requires full dataset before calculation

• Expensive sorting, sorting has O(N log N) time complexity

How would you redesign this for real-time trending searches?

The system should separate ingestion, aggregation, and serving. This prevents expensive computations from happening every time a user requests trending searches.

Read more

This week's issue leans heavily into performance and platform internals. On the article side, we dig into DuckDB replacing hand-written Java loops in Spring Batch, why Java Stream's anyMatch/findFirst/count are quietly allocation-hungry, OpenJDK's guidance on safely evolving sealed-type switches, and Project Valhalla's first real preview reshaping how == works for value objects.

On video, catch a Spring Boot/Quarkus code-quality tool with a built-in MCP server, idiomatic Kotlin with Spring Boot 4, the latest on Valhalla and post-quantum crypto from Inside Java, and a deep dive into JDK Flight Recorder for production profiling. Let's dive in!

📢 If you have product, services or job that you like to present in front of ~8200 Java and Spring Developers , considering sponsoring this newsletter.

Sponsorship Details

Articles Of The Week (7)

DuckDB in Spring Batch: Replace In-Memory Java Loops with One SQL Statement

This article compares two Spring Batch apps that compute per-group order aggregates from a CSV—one using hand-written Java loops with an in-memory HashMap, the other replacing the transform step with a single DuckDB SQL statement inside one small Tasklet. The recommendation: use DuckDB for aggregation-heavy transform steps over files/databases it can read, while keeping the classic reader/processor/writer pattern for row-level enrichment, external calls, or strict downstream writes.

Preparing for Change: Safe Switching over Sealed APIs

This OpenJDK guide (Bimpoudis, Buckley, Goetz) explains that exhaustive switches over sealed types don't stay exhaustive forever; adding a new permitted subtype can break recompilation or cause a MatchException at runtime, and argues this is a feature, not a bug, since it forces developers to consciously re-verify their assumptions as the domain evolves. It strongly advises against using default as a catch-all (since it hides broken assumptions, doesn't handle null, and can mask erroneous results), recommending instead either handling every permitted subtype explicitly or using the narrowest possible match-all case (e.g., case Fruit other rather than case Object other).

Project Valhalla’s First Preview: JEP 401 Redefines == for Java Objects

This article covers JEP 401 (Value Objects Preview), now integrated into JDK 28, which introduces identity-free classes via a new value modifier; instances with only final fields where == compares by field values rather than reference identity (though equals is still needed since state isn't always equivalent). It requires --enable-preview at compile and runtime, comes with construction rules enforced by JEP 539's bytecode verification, restrictions on synchronized, and migration of value-based JDK classes like primitive wrappers and LocalDate; the payoff is potential JVM optimizations like scalarization or flattening into compact representations, though this isn't guaranteed and falls back to ordinary allocation when constraints (like atomicity limits) aren't met.

Allocation Hungry Any/All/None, FindFirst, and Count Methods on Java Stream

Donald Raab (Eclipse Collections creator) explains that Java Stream methods like anyMatch, allMatch, noneMatch, filter().findFirst(), and filter().count() are surprisingly allocation-heavy; each call creates a Stream object (80-88 bytes) plus several internal closures/inner-class objects, even when used serially and eagerly, generating unnecessary garbage. He recommends avoiding these patterns in hot code paths or libraries, instead using Eclipse Collections' Iterate utility (anySatisfy, detect, count, etc.) which accomplishes the same tasks with near-zero allocation.

Optimistic Concurrency with SQL Version Columns

This article explains optimistic concurrency using SQL version columns to prevent lost updates, where a stale write silently overwrites newer data because updates that key only on a row's ID have no way to detect intervening changes. The fix is carrying a version value from the original read into the UPDATE's WHERE clause (e.g., WHERE id = 101 AND version = 7) alongside incrementing it, so a stale write matches zero rows instead of overwriting newer data, with the application detecting conflicts via the affected-row count.

Evolving a Java MCP Server During MCP Specification Upgrades

This article demonstrates how a Helidon-based Java MCP server can adopt the new MCP 2026-07-28 spec; which moves the protocol to stateless HTTP, replaces initialize with server/discover, and adds explicit protocol headers, cache metadata, and typed tool output, without breaking existing 2025-06-18 clients. Using the urgency-mcp example, it adds a routing-level adapter (McpRequestLoggingFeature/StatelessMcpProtocolHandler) that intercepts only requests carrying the new protocol header, enforces the 2026 stateless contract (rejecting session IDs, validating headers, handling discovery/tools/list/tools/call), and otherwise lets legacy clients pass through to the original generated Helidon MCP route unchanged.

Java Concurrency Programming Learning Roadmap: Understanding Threads Through Problems

It proposes learning Java concurrency problem-first, starting from why concurrency matters (response time, multi-core use), then working through atomicity, visibility, and ordering problems, mapping solutions (volatile, synchronized, ReentrantLock, AQS, CAS), thread cooperation (CountDownLatch, CyclicBarrier, Semaphore, CompletableFuture), safe shutdown, thread pools, concurrent collections, and deadlock avoidance; framed as a conceptual build-up rather than API memorization. Let me know if you’d like anything different from this pass (e.g., shorter, different focus).

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 8200+ subscribers for hand-crafted, no-fluff content.

Upgrade to paid now (60% discount) and get the annual membership at $50/year forever that is ~ $4/mo.

So far we have covered 70+ real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

Videos Of The Week (4)

BootUI - Inspect, Analyze and Improve your Spring Boot and Quarkus Applications

Boot UI is a single-dependency dev-console tool for Spring Boot and Quarkus apps that scans code against best practices (architecture, REST APIs, security, Hibernate) with scoring and fix suggestions, built by a core JHipster contributor, while also offering live monitoring of health, metrics, SQL queries, scheduled jobs, caching, and messaging. Its standout feature is a built-in MCP server that plugs into AI coding assistants like IntelliJ's, letting you ask an agent to run scans and even fix violations directly.

Idiomatic Kotlin applications with Spring Boot 4

Sebastian Deleuze (Spring Framework core committer) covers best practices for idiomatic Kotlin with Spring Boot 4, arguing clean code still matters in the AI-agent era since agents copy patterns from your codebase, and recommends Java 25, Gradle Kotlin DSL, and upgrading to Spring Boot 4 for continued support. Key Spring Boot 4 features include modularized auto-configuration, full JSpecify-based null safety across the entire Spring portfolio (checked via NullAway, now natively translating to Kotlin null safety), and Kotlin 2.4's fix for the classic Jackson/Hibernate annotation-target gotcha.

JSON API, Valhalla Progress, LTS ❤️ PQC

This Inside Java Newscast (Nicolai Parlog) covers several OpenJDK updates: Project Valhalla's value types and strict field initialization have merged into JDK 28 early access, with Dan Smith identifying ~60 JDK API classes as migration candidates (though not urgent); primitive patterns will get another unchanged preview in JDK 28 due to overlap with constant patterns; and JEP 540 proposes an incubating, deliberately minimal JSON API (not meant to replace Jackson/GSON) targeting JDK 28.

Efficient Profiling and Troubleshooting for Java Applications

This talk by Michael introduces JDK Flight Recorder (JFR), an event-based, always-on recording framework designed for production use with under 1% overhead, capturing everything from GC and JIT activity to TLS handshakes, thread dumps, and custom application events with stack traces. It explains JFR's efficiency; thread-local buffering, reuse of data the JVM already collects, and a compact self-describing binary file format—plus its flexible filtering/throttling and configuration via .jfc files.

In-house Blogs (5)

• Spring Boot Interview Question : Rolling Out New Feature

• Java Interview Question - The ConcurrentHashMap Trap

• Spring Boot Interview Question - @Async Broke Our Audit Logs

• Spring Boot Interview Quiz: What Happens to the Transaction?

• Spring Boot Interview: The Event That Lied About Being Saved

» Check full list of interview question

Thats all for this week friends! Thanks for reading this far. If you liked it please like and share with your network.

Share

Before you leave, don’t forget to unlock all the real world use case based interview questions , just at $4/mo (with annual subscription).

Subscribe now

📢 If you have a product or services that you like to present in front of ~8000 Java and Spring Developers , considering sponsoring this newsletter.

Sponsorship Details

Happy Coding 🚀
Suraj

Subscribe | Sponsor us | LinkedIn | Twitter | Youtube

Your company uses feature flags to gradually roll out a new checkout flow. Every request checks the feature flag before deciding which implementation to execute.

The feature flags are stored in a remote service (LaunchDarkly, Unleash, or an internal service). One afternoon, the feature flag service becomes unavailable.

Suddenly:

• Checkout latency jumps from 40ms to 900ms

• Thread pools begin filling up

• Circuit breakers start opening

• Checkout success rate drops

No application code was deployed.

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 8100+ subscribers for hand-crafted, no-fluff content.

Founding Member Offer: Lock in founding member price at $50/year (~$4/month) for life. Limited spot left

So far we have covered 70+ real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

What actually went wrong?

The checkout service made a synchronous network call to evaluate the feature flag before executing any business logic.

If isEnabled() performs a REST call:

@Service
public class FeatureFlagService {

    private final RestTemplate restTemplate;

    public boolean isEnabled(String feature, User user) {

        return restTemplate.getForObject(
                "/flags/{feature}?userId={id}",
                Boolean.class,
                feature,
                user.getId()
        );
    }
}

every checkout request now depends on the feature flag service. If the feature flag service becomes slow:

Checkout -> Feature Flag Service (900ms)

every checkout request waits for the response, increasing latency and tying up request threads.

Eventually:

• Thread pools become exhausted.

• Requests begin timing out.

• Circuit breakers open.

• Checkout appears unavailable, even though its own business logic is healthy.

The feature flag service has unintentionally become part of the critical request path.

How would you redesign the system so a feature flag outage never impacts checkout?

Read more

A payment platform keeps track of how many API requests each merchant has made. To make it thread-safe, the team replaced a HashMap with a ConcurrentHashMap.

A few weeks later, operations noticed something strange: The total request count is consistently lower than the number of requests recorded by the load balancer. There are no exceptions, no failed requests and CPU and memory look healthy.

The only symptom is that some increments disappear under heavy load.

🚀 Level up your Java & Spring Boot skills.

Join 8100+ developers and get weekly, no-fluff content featuring practical coding tips, real-world backend insights, and interview questions based on production scenarios.

Founding Member Offer: Lock in founding member price at $50/year (~$4/month) for life. Limited spot left.

So far we have covered 70+ real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

The application uses a ConcurrentHashMap. Shouldn't this code be thread-safe?

ConcurrentHashMap guarantees thread safety for individual operations—not for a sequence of operations.

The following sequence is not atomic:

get(...)
modify(...)
put(...)

Multiple threads can observe the same value simultaneously.

Race condition example:

merchant A = 10. Two requests arrive at exactly the same time.

Thread A : get() → 10, Thread B: get() → 10

Both threads calculate: 10 + 1 = 11

Thread A writes → put(11). Thread B writes → put(11)

Final value → 11 vs Expected → 12

One increment silently disappears. And we don’t get any exception and warning. Just incorrect business data. This is a classic lost-update race condition.

What solution do you propose to fix this?

Read more

This week brings a strong mix of AI-meets-Java content alongside some solid core platform updates. On the AI side, we've got governed agent orchestration with Quarkus Flow and MCP, Spring AI's take on the Agent2Agent protocol for multi-agent systems, and a candid look at where we actually stand on the "AI adoption ladder."

On the platform front, there's encouraging news on post-quantum cryptography making its way to older LTS releases, an early look at Project Valhalla's plans for new numeric types, and a couple of clever libraries worth adding to your toolbox ; from idempotent REST endpoints to embedding DuckDB for zero-setup data crunching. Plus JIT compiler internals, WebAssembly on the JVM, and JobRunr landing on Spring Initializr. Let's dive in!

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 8200+ subscribers for hand-crafted, no-fluff content.

Upgrade to paid now (60% discount) and get the annual membership at $50/year forever that is ~ $4/mo.

So far we have covered 70+ real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

Articles Of The Week (8)

» Orchestration Meets MCP: Building Governed Agentic Workflows With Quarkus Flow and AGENTS.md

This article explores how Java developers can build more reliable and governed AI agent workflows using Quarkus Flow, LangChain4j, MCP, and AGENTS.md. Instead of relying on fragile custom loops, Quarkus Flow handles orchestration with retries, conditional loops, iteration limits, and human approval gates, while MCP provides standardized access to external tools and systems. AGENTS.md adds a governance layer for defining agent roles, security boundaries, and output requirements without hardcoding those rules into Java code

» Order Matters with Resilience4j in Spring Boot

This article explains why the order of Resilience4j components matters when combining Retry, CircuitBreaker, TimeLimiter, and Bulkhead. Spring AOP wraps these components as nested layers, so changing their order changes what each one actually measures and controls. It also covers how to explicitly control aspect ordering, fallback behavior, and the impact of wrapper placement on timeouts, concurrency limits, metrics, and failures

» Idempotent REST Endpoints Without the Boilerplate

This article introduces a Spring Boot starter that makes REST endpoints idempotent with a simple @Idempotent annotation. It handles duplicate requests using an idempotency key, replaying the original response instead of executing the operation again; a useful pattern for APIs where retries could cause problems like double charges. The library supports Redis and JDBC/Postgres storage, handles concurrent requests using atomic claims, and can either wait for the original request or fail fast with 409.

» Singleton in Spring Boot: How the IoC Container Manages Singleton Beans

This article explains how Spring Boot's IoC Container manages beans as singletons by default, so one instance is created per container and shared everywhere it's injected; a pattern useful because it avoids manual singleton boilerplate and redundant object creation across ourt app. The container builds bean definitions at startup, eagerly instantiates them via reflection, and hands out the same object on every injection, though @Lazy can defer creation and @Scope("prototype") can opt a bean out of singleton behavior.

» Exploring Agent2Agent Protocol (A2A) With Spring AI

This article demonstrates the Agent2Agent (A2A) Protocol using Spring AI, which lets independently-built AI agents discover each other via a published "Agent Card" and exchange tasks; useful when we split complex work across specialized agents rather than one monolithic one. It walks through building a job-screening system: an orchestrator agent acting as an A2A client discovers three remote specialist agents (each an A2A server) at startup, delegates candidate evaluation tasks to them via tool calls, and merges their responses into one summary.

» Push V3: One Message From Your Server to Every Surface

This article covers Push V3, a rewrite of Codename One’s push system that replaces certificates and numeric push types with a typed PushMessage model, managed provider credentials, server-side segmentation, and direct updates to Surfaces like widgets and Live Activities. The release also previews four related changes: a Maven repository move off Central, on-device AI/MCP tooling, a HealthKit/Health Connect API, and a new road-routing API using OSRM.

» Embedding DuckDB in a Maven App (and Using It for Things That Aren’t Databases)

This article shows how to embed DuckDB in a Maven project as a single JDBC dependency (no server, no install), and how it can query CSV, JSON, or Parquet files; local or over HTTP; directly as SQL tables without ever creating a database. It walks through a full example that aggregates a remote CSV of penguin data straight from a GitHub URL using plain java.sql code, no schema definition required. It frames DuckDB less as a database and more as a drop-in replacement for hand-rolled CSV parsing, in-memory aggregation logic, test-data generation, and reading Parquet without pulling in the Hadoop ecosystem.

» Post-Quantum Cryptography in Long-Term Support JDK Releases

This post outlines Oracle's plan to bring post-quantum cryptography to older, supported Java LTS releases (25, 21, 17, 11, 8), not just new JDKs, so apps can gain quantum-resistant TLS through updates and config alone. Groundwork includes JDK 24's ML-KEM/ML-DSA algorithms and JDK 27's hybrid PQC TLS 1.3 key exchange (GA September 2026), with older LTS versions reaching parity between October 2026 and late 2027.

📢 If you have a product or services that you like to present in front of ~8200 Java and Spring Developers , considering sponsoring this newsletter.

Sponsorship Details

Videos Of The Week (5)

» The 5 Steps of AI Adoption: Which One Are You On?

This video breaks down Boris Cherny's five-step "AI adoption ladder" for coding agents; from Step 0 (copy-pasting between a chatbot and your IDE, you're the bottleneck) through Step 1 (assisted pair-programming with manual review), Step 2 (orchestrating 5-10 parallel agents), Step 3 (supervised autonomy), to Step 4 (fully autonomous, AI-native loops). The core lesson: moving up a step isn't about using more tokens, it's about removing bottlenecks and adding guardrails like automated verification.

» Automatically Retrofitting JIT Compilers

This QCon London talk introduces yk, an open-source meta-tracing JIT compiler that bolts onto existing C-based interpreters (Lua, MicroPython) with minimal code changes (~400 lines added, under 5% of the codebase) while still delivering real speedups (~4x on a benchmark, ~2x geomean). The key idea: treat the existing C interpreter as the source of truth rather than writing a new one from scratch (unlike PyPy/RPython or Truffle), avoiding the compatibility drift that's killed most prior dynamic-language JIT projects.

» WebAssembly on the JVM: Feature Evolution, Performance, and the Transition to Endive

This InfoQ interview features Andrea Peruffo discussing Chicory, his project for running WebAssembly on the JVM, framing it as a way to reuse existing Wasm-compiled libraries (databases, parsers, JS engines like QuickJS) safely and portably in Java without JNI's crash risks and OS-specific builds. He covers WASI's progress (core spec finalized, WASI GC letting languages like Scala.js and Kotlin target Wasm, and the upcoming component model in WASI P3), real production use cases (Trino's Python UDFs, JRuby's Prism parser compiled to Wasm and sped up 10x via Java bytecode compilation, and Shopify's QuickJS engine embedded in Microcks for API mocking), and Chicory's execution layers.

» Paths to New Numeric Types On the Java Platform

This JavaOne talk by Joe Darcy (Oracle) explores speculative, in-development paths for adding new numeric types to Java, tied to Project Valhalla's value classes and type classes work. He motivates the need with use cases like scientific computing and especially ML/AI, which favors smaller formats (float16, bfloat16, 8-bit floats), and explains Java's divide between reference types (flexible, identity-based) and primitive types (fast, dense, no identity) that Valhalla aims to bridge. Drawing an analogy to abstract algebra's number hierarchy versus the Java Collections Framework, he argues Java doesn't need full mathematical richness.

» Spring Boot and JobRunr: easy job distribution and scheduling

This Spring demo (likely Josh Long) celebrates JobRunr; a distributed Java job scheduling engine; landing on Spring Initializr as a modern, easier alternative to Quartz. He builds a quick Spring Boot app with JobRunr, Postgres, and OpenTelemetry, showing how to define a JobRequest/JobRequestHandler, enqueue jobs (immediate, delayed, or cron-based recurring), and monitor everything via JobRunr’s built-in dashboard.

In-house Blogs (5)

• Spring Boot Interview Question - Async Broke Our Audit Logs

• Spring Boot Interview Quiz: What Happens to the Transaction?

• Spring Boot Interview: The Event That Lied About Being Saved

• Spring Boot Interview Quiz: The Hidden Order of Your Beans

• Spring Data JPA Interview Quiz : Why did Hibernate execute an UPDATE without calling save()?

» Check full list of interview question

Thats all for this week friends! Thanks for reading this far. If you liked it please like and share with your network.

Share

Before you leave, don’t forget to unlock all the real world use case based interview questions , just at $4/mo (with annual subscription).

Subscribe now

📢 If you have a product or services that you like to present in front of ~8000 Java and Spring Developers , considering sponsoring this newsletter.

Sponsorship Details

Happy Coding 🚀
Suraj

Subscribe | Sponsor us | LinkedIn | Twitter | Youtube

A payment service stores request metadata in MDC so every log line contains the request information.

The controller logs look correct:

requestId=8fa92
merchantId=paypal-123
userId=suraj

But every log produced inside sendReceipt() shows:

requestId=null
merchantId=null
userId=null

🚀 Level up your Java & Spring Boot skills.

Join 8100+ developers and get weekly, no-fluff content featuring practical coding tips, real-world backend insights, and interview questions based on production scenarios.

Founding Member Offer: Lock in founding member price at $50/year (~$4/month) for life. Limited spot left.

So far we have covered 70+ real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

Why did the audit context disappear?

MDC uses ThreadLocal

Most logging frameworks store MDC using ThreadLocal. The values belong only to the current thread.

@Async executes on another thread

The executor picks another thread from its pool. That thread has a completely different ThreadLocal map.

Request Thread  -> Async Executor Thread

Hence MDC.get("requestId") returns null

ThreadLocal values are NOT inherited

Unlike method arguments, ThreadLocal state is never copied automatically. Even if the thread comes from the same executor every time, the context is not transferred.

How would you fix it without changing every @Async method in the application?

Read more

Consider the following service:

The application throws:

java.io.IOException: Inventory service unavailable

The API returns an error.

What happens to the database transaction?

A. The order insert is rolled back because an exception occurred.

B. The order insert is committed because IOException is a checked exception.

C. Spring automatically retries the transaction.

D. The transaction remains open until the application restarts.

🚀 Level up your Java & Spring Boot skills.

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 8100+ subscribers for hand-crafted, no-fluff content.

Founding Member Offer: Lock in founding member price at $50/year (~$4/month) for life. Limited spot left

So far we have covered 70+ real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

Correct Answer

B. The order insert is committed because IOException is a checked exception.

Explanation

A common misconception is:

“Any exception causes a transaction rollback.”

That’s not how Spring works.

By default, Spring rolls back transactions only for:

• RuntimeException

• Error

Checked exceptions (such as IOException, SQLException, or any class extending Exception) do not trigger an automatic rollback.

What happens internally?

Even though the API fails, the database transaction is committed.

How to Fix It

Read more

This week we have packed agenda with covering variety of curated articles, videos. Engineers are talking about topics that are directly or indirectly related to AI + Java/Spring, along with some clean architecture and internals of JDK.

But before we dive in, quick news to share and an announcement. This week we crossed 8000 subscribers mark and feel like big achievement to reach here and able to build a community of 8000+ like minded engineers. Thank you so much for being so kind and supporting my articles.

If you are new here, i keep writing about Java & Spring Boot via articles or Interview Questions. If this interests you, consider becoming free or paid subscribers. Currently Founding member plan is active and you can become paid subscriber at $4/mo (with annual subscription).

Subscribe now

So far we have covered 70+ real world based interview questions and will add up to 100 by end of this year.

Testimonials

Articles Of The Week (8)

» Virtual Threads After JDK 24: What Changed for Production Java

This article explores how virtual threads have evolved since JDK 21 and explains why JDK 24's fix for thread pinning doesn't eliminate all production risks. Instead, the bottleneck shifts from thread pools to downstream resources like database connections, file descriptors, and rate limits. It also highlights why common ThreadLocal patterns become ineffective with virtual threads and recommends adopting Scoped Values for request context. The key takeaway is that virtual threads simplify concurrency, but production systems still need explicit resource limits, proper context propagation, and careful migration planning.

» Clean Architecture for Serverless: Business Logic You Can Take Anywhere

This talk demonstrates how to build serverless applications that can run across multiple cloud providers without changing business logic. Using Spring Cloud Function, Clean Architecture, and Gradle modules, the speaker isolates domain logic from cloud-specific services so the same application can be deployed to both AWS and Azure. The key takeaway is that portability comes from architectural boundaries and dependency injection—not avoiding cloud services altogether.

» A Guide to Ahead-of-Time Cache in the Java

This tutorial explores Java's Ahead-of-Time (AOT) Cache, introduced in JDK 24 as part of Project Leyden to reduce JVM startup time by precomputing and storing class metadata. It explains how JDK 25 simplifies cache generation, while JDK 26 improves compatibility by removing earlier garbage collector limitations. The key takeaway is that AOT Cache can significantly improve startup and warmup times, but only when integrated thoughtfully into the build and deployment process.

» How to Create a Spring Boot Fraud Scoring Service

This tutorial demonstrates how to build a fraud detection service entirely in Java using Deep Netts and Spring Boot, eliminating the need for a separate Python inference service. It covers training and serving the model in the same application, highlights why metrics like precision and recall matter more than accuracy for imbalanced datasets, and explains common production pitfalls such as deploying a model without its corresponding feature scaler.

» This One Spring Data JPA Pattern Cleaned Up to 3 Years of Repository Debt

This article explains how Spring Data JPA Specifications simplify building dynamic database queries without creating dozens of repository methods for every filter combination. By encapsulating each filter into small, reusable specifications, developers can compose queries at runtime using .and() and .or(), making search functionality far more flexible and maintainable. The article also covers joins, pagination, keyword search, and common pitfalls to avoid.

» Introduction to Spring MockMvc

This article introduces Spring MockMvc, a testing framework that lets us verify Spring MVC controllers without starting a web server. By executing requests through the real DispatcherServlet while mocking the servlet container, MockMvc provides fast, reliable tests that cover request mapping, validation, serialization, and error handling.

» Building a Config-Driven SOAP/REST Integration Layer

This case study shows how a legacy SOAP middleware evolved to support both SOAP and REST without splitting into multiple services. Instead of hardcoding protocol-specific logic, the team made transport and authentication configurable, allowing the same application to communicate with different customers based on configuration alone. They also preserved their existing XSLT transformation pipeline by adding JSON conversion for REST integrations, avoiding a costly rewrite.

» Application Startup Tracking in Spring

This article explains how to profile and analyze Spring application's startup process using the Spring Boot Actuator /startup endpoint. By enabling BufferingApplicationStartup, Spring records detailed startup events, bean initialization, and application lifecycle steps, making it easier to identify slow components and optimize startup performance. The article also demonstrates how to expose and inspect this data through Actuator, making it a valuable tool for diagnosing startup bottlenecks in complex Spring Boot applications.

📢 If you have a product or services that you like to present in front of ~8000 Java and Spring Developers , considering sponsoring this newsletter.

Sponsorship Details

Videos Of The Week (4)

» Upgrading Dependencies with AI: A Practical Guide

Dan Vega demonstrates a practical workflow for using AI to perform dependency upgrades safely. Using Claude to upgrade a Nuxt application, he emphasizes reviewing release notes first, letting the AI generate a migration plan, working in a separate branch, and validating every step with local builds and preview deployments before merging. The key takeaway is that AI can significantly speed up low-risk upgrades, but for large enterprise codebases, deterministic tools like OpenRewrite remain a better choice due to their predictable, repeatable results.

» Empowering GPU Acceleration for Java

This talk introduces HAT (Heterogeneous Accelerator Toolkit), an experimental Java project that enables developers to offload compute-intensive workloads to GPUs while writing only Java. Built on Project Babylon and Project Panama, HAT uses Java's reflection capabilities to generate optimized GPU code for backends like CUDA and OpenCL.

» JIT Compiler From the Ground Up

This Inside Java Podcast explores how HotSpot's Just-In-Time (JIT) compiler turns Java bytecode into highly optimized native machine code. Oracle compiler engineer Roberto Lozano explains core concepts including tiered compilation (C1 and C2), profiling, speculative optimizations, deoptimization, inlining, escape analysis, and scalar replacement. The discussion also highlights how techniques like fuzz testing, hardware-specific intrinsics, and upcoming projects such as Valhalla continue to push JVM performance forward, making it a great deep dive into the internals of Java execution.

» 95% of AI Projects Fail. Here's Why

In this episode, Josh Long reflects on Spring's evolution, from its early days to Spring Boot, cloud-native development, and now AI. He shares how developer advocacy, great documentation, and continuous community engagement played a major role in Spring's success, while explaining how Spring Boot simplified dependency management and developer productivity. Josh also discusses AI's impact on software engineering, arguing that frameworks like Spring become even more valuable as developers remain responsible for reviewing, integrating, and maintaining AI-generated code.

In-house Blogs (4)

Spring Boot Interview: The Event That Lied About Being Saved

Spring Boot Interview Quiz : Why Is CPU Low but Latency High?

Spring Boot Interview Quiz: The Hidden Order of Your Beans

Spring Data JPA Interview Quiz : Why did Hibernate execute an UPDATE without calling save()?

Checkout full list here

Thats all for this week friends! Thanks for reading this far. If you liked it please like and share with your network.

Share

Before you leave, don’t forget to unlock all the real world use case based interview questions , just at $4/mo (with annual subscription).

📢 If you have a product or services that you like to present in front of 8000+ Java and Spring Developers , considering sponsoring this newsletter.

Sponsorship Details

Happy Coding 🚀
Suraj

Subscribe | Sponsor us | LinkedIn | Twitter | Youtube

Consider the following service:

The application logs:

Order saved successfully
Sending order confirmation email
Transaction rolled back

What happens when publishEvent() is called?

A. The listener is not executed because the transaction eventually rolls back.

B. The listener executes immediately after publishEvent(), even though the transaction later rolls back.

C. Spring delays the listener until the transaction commits.

D. Spring automatically discards the event when the transaction fails.

🚀 Level up your Java & Spring Boot skills.

Join 8000+ developers and get weekly, no-fluff content featuring practical coding tips, real-world backend insights, and interview questions based on production scenarios.

Founding Member Offer: Lock in founding member price at $50/year (~$4/month) for life. Limited spot left.

So far we have covered 67+ real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

Correct Answer

B. The listener executes immediately after publishEvent(), even though the transaction later rolls back.

Explanation

A common misconception is:

“Spring events are transaction-aware by default.”

They’re not.

ApplicationEventPublisher.publishEvent() is synchronous by default.

When publishEvent() is called, Spring immediately invokes all matching @EventListener methods.

The listener has no knowledge that the surrounding transaction will later fail.

What actually happens?

The email has already been sent.

The Correct Solution

Read more

Your application reserves inventory

During a flash sale:

• Application CPU stays below 20%

• Database CPU stays below 30%

• API latency jumps from 80 ms to 12 seconds

• Thread dumps show many threads blocked inside findById()

What is the BEST explanation?

A. Spring Data JPA is leaking database connections.

B. The pessimistic lock is held while the external payment validation executes, forcing other transactions to wait.

C. Hibernate retries failed transactions automatically.

D. The database optimizer stopped using indexes because of the lock.

🚀 Level up your Java & Spring Boot skills.

Join 8000+ developers and get weekly, no-fluff content featuring practical coding tips, real-world backend insights, and interview questions based on production scenarios.

Founding Member Offer: Lock in founding member price at $50/year (~$4/month) for life. Limited spot left.

Subscribe now

See what readers are saying 👇

Answer

B.

PESSIMISTIC_WRITE acquires an exclusive row lock as soon as the row is read.

The transaction then performs a slow network call:

paymentGateway.validateCustomer();

Since the transaction hasn’t committed yet, the row lock remains held during the external API call.

Every other purchase for the same product waits for that lock to be released.

The result is:

• Low CPU utilization

• High response time

• Growing thread pool

• Long database lock wait times
  

The bottleneck isn’t computation, it’s waiting.

Some other important points

1. Lock Duration Matters More Than Lock Type

Holding a lock for 50 ms is very different from holding it for 5 seconds.

The real issue is that the transaction includes slow I/O.

2. Never Perform Remote Calls While Holding Database Locks

Bad:

Better:

Throughput Calculation

If one purchase takes 2 seconds while holding the lock:

Even though the servers appear mostly idle.

What we should monitor?

• Database lock wait time

• Active transaction duration

• Connection pool utilization

• Slow query logs

• Thread dumps

• Blocking sessions (pg_locks, SHOW ENGINE INNODB STATUS, etc.)

Better Alternatives (Depending on requirements)

• Optimistic locking with retries

• Atomic SQL update:

UPDATE product
SET quantity = quantity - 1
WHERE id = ?
  AND quantity > 0;

• Inventory reservation queue

Thats all for this week friends! Thanks for reading this far. If you liked it please share with your network.

Share

Before you leave, don’t forget to unlock all the real world use case based interview questions , just at $4/mo (with annual subscription).

Happy Coding 🚀
Suraj

Subscribe | Sponsor us | LinkedIn | Twitter | Youtube

1. Engineering With Java newsletter reached 100 paid subscribers 🎉.

2. I got promoted to Staff Software Engineer (MTS2) at PayPal 🥳

Thanks for all your wishes , it means world to me.

Now lets dive into this weeks edition.

Featuring: agents that actually plan things, batch jobs moving to MongoDB, and one very cautionary tale about running out of numbers.

Another week, another pile of Java and AI goodness, from patching (or not patching) end-of-life JDKs, to Embabel hitting GA, to Spring Batch getting cozy with MongoDB. Grab your coffee (or whatever Jerry was drinking) and dig in.

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 7900+ subscribers for hand-crafted, no-fluff content.

Upgrade to paid now (60% discount) and get the annual membership at $50/year forever that is ~ $4/mo.

Subscribe now

So far we have covered 67+ real world based interview questions and will add up to 100 by end of this year.

Testimonials

Articles Of The Week (8)

» AI Found the Bugs. Who’s Patching Your EOL Java Code?

AI usage accelerates the discovery of security vulnerabilities but it doesn’t address the growing risk for growing organization running end of life Java versions. AI helps uncover bug faster but unsupported JDK no longer receives security patches. This leaves critical system vulnerable. Finding bug with AI is just half the battle, real challenge is being on supported version so that the vulnerability can actually be fixed.

» Embabel 1.0 Is Here: AI Agent Framework for Java Goes GA

First stable release of Rod Johnson’s AI agent framework for JVM goes live. Embabel built on top of Spring AI, helps Java engineers build deterministic and production ready AI agents using Goal-Oriented Action Planning instead of relying solely on LLM reasoning. This first stable release promotes key API like RAG to production, adds broader model and MCP support, and is no fully available on Maven central.

» AR And VR In Java

Java is no longer limited to just backend systems. As a Java developer, we can build Augmented Reality (AR) and Virtual Reality (VR) applications by integrating with ARKit, ARCore, and virtual room environment.

» Spring AI 2.0 Tool Calling: Build a Live Claude-Style UI

Spring AI 2.0 provides Tool Calling features that prevents sending every available tool to LLM on every request. Instead, it intelligently identifies tools that are responsible for current prompt. This reduces token usage and drive cost down.

» Integrating Local LLMs with Spring AI Using LM Studio

One of the thing Spring AI solving is how easy it makes to use AI models locally. Spring AI integrates with LM studio ( “Docker desktop for AI models“) and allow application to use local chat and embedding models through OpenAI compatible API. One added advantage is that the sensitive data stays on the local system, enables offline development and saves API cost.

» Vertical Scaling for Java on Kubernetes with Azul Prime and Kedif

Do you know that Java application takes extra CPU during JVM warm-up, but keeping those resources allocated after startup wastes infrastructure. Azul Prime and Kedify can work together and temporarily boost CPU during JIT compilation and then automatically scale resources down once the JVM is fully optimized.

» Jerry Ran Out of Numbers But Drank All the Punch

A debugging story that shows how multiple production issues ( connection pool exhaustion, deadlocks and timeouts ) were all symptom of single root cause. An infinite identifier allocation loop triggered after finite ID range was exhausted. Good learning for us engineers is that the biggest production failures often start with small overlooked assumption.

» Spring Deep Dive: Transactions

This is great practical guide to Spring's @Transactional. Gist is that the transactional support provides Spring service a proxy that handles begin/commit/rollback automatically, giving us atomicity. Discusses
- Isolation levels(READ_UNCOMMITTED → SERIALIZABLE) and
- Propagation (REQUIRED vs REQUIRES_NEW)
- Self-invocation silently skipping the proxy,
- Private methods not being proxied,
- Checked exceptions not triggering rollback by default,
- Holding transactions open too long exhausting the connection pool.

📢 If you have a product or services that you like to present in front of ~8000 Java and Spring Developers , considering sponsoring this newsletter.

Sponsorship Details

Videos Of The Week (4)

» From OTEL to SLMs: Distilling Frontier Model Behaviour from Production Telemetry

Ben built an AI powered code editor tool (LSP) and used OpenTelemetry to capture his own accept/reject/regenerate interaction as training data to use it as small local fine-tuned model to his coding style. Ben generalizes this into platform pattern, instrument with OTel, captures user feedback, distill into small model, deploy and iterate. Ben argues that this approach let engineers stays in control with their tool.

» AI Solutions with Spring AI 2.0 and Java

Dan Vega and Lisa Ross discusses that the Spring AI’s model agnostic abstraction lets you swap the LLM without code change and structured JSON output makes responses reliably typed. They discuss Embabel framework for its deterministic and goal oriented agents. They also note that as model improve , prompt engineer will matters less, also Java is enough for AI integration and no need to re-platform to python.

» Stop Building AI Wrappers Build Agents

Prashant ( Google APAC lead ) touches on :

• MCP is stateful and build for chatty system

• Agents should be targeting user goals and not follow the rigid steps

• Local models like Gemma4 inherits reasoning from Gemma3 but they lack worlds knowledge and not good for deep reasoning but they are good at local task.

» MongoDB-backed Spring Batch Job Repositories

Josh Long is back with another demo where he uses mongodb as state tracker for spring boot batch job using new MongoDB support (via Spring Boot 4.1's auto-configuration). He reads customer records in chunks and load them to postgres but manages jobs progress tacker in MongoDB.

In-house Blogs (4)

Spring Data JPA Interview Quiz : Why did this query return duplicate users?

Spring Data JPA Interview Quiz : Why did Hibernate execute an UPDATE without calling save()?

Spring Data JPA Interview Quiz : Why did this query return duplicate users?

Spring Data JPA Interview Quiz: The Lazy Loading Trap

Checkout full list here

Thats all for this week friends! Thanks for reading this far. If you liked it please like and share with your network.

Share

Before you leave, don’t forget to unlock all the real world use case based interview questions , just at $4/mo (with annual subscription).

Subscribe now

📢 If you have a product or services that you like to present in front of ~8000 Java and Spring Developers , considering sponsoring this newsletter.

Sponsorship Details

Happy Coding 🚀
Suraj

Subscribe | Sponsor us | LinkedIn | Twitter | Youtube

Question

You have two implementations of the same interface and Your service injects all implementations:

What is the order of paymentServices?

A.

StripePaymentService
PaypalPaymentService

B.

PaypalPaymentService
StripePaymentService

C. Random order depending on JVM startup.

D. Spring throws an exception because multiple beans of the same type exist.

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 7900+ subscribers for hand-crafted, no-fluff content.

First 100 paid subscribers will get the annual membership at $50/year forever that is ~ $4/mo

So far we have covered 67 real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

Correct Answer

B.

PaypalPaymentService
StripePaymentService

Explanation

When Spring injects a single bean:

@Autowired
PaymentService paymentService;

multiple implementations cause:

NoUniqueBeanDefinitionException

unless we use @Primary or @Qualifier.

However, injecting a collection tells Spring:

“Inject every bean that implements this interface.”

@Autowired
List<PaymentService> paymentServices;

Spring collects all matching beans and sorts them before injection.

The sorting order is:

1. @Order

2. Ordered interface

3. Registration order (implementation detail—not guaranteed and shouldn’t be relied upon)
   

Since:

@Order(1)
PaypalPaymentService

comes before

@Order(2)
StripePaymentService

the injected list becomes:

PaypalPaymentService
StripePaymentService

What are different options to control ordering?

Option 1: @Order

@Order(1)
@Service
class PaypalPaymentService implements PaymentService {
}

Lower values indicate higher priority.

Option 2: Implement Ordered

@Service
class StripePaymentService implements PaymentService, Ordered {

    @Override
    public int getOrder() {
        return 2;
    }
}

Option 3: Sort Explicitly

For business-critical workflows, it’s often better to sort based on business rules instead of relying on Spring’s ordering.

paymentServices.stream()
    .sorted(comparing(PaymentService::priority))
    .toList();

Discuss Some Real-World Usage

Injecting a collection of strategy implementations is a common Spring pattern used for:

• Payment routing

• Fraud detection pipelines

• Authentication providers

• Validation chains

• Rule engines

• Message processors

• Notification channels

For example:

List<FraudCheck> fraudChecks;

Spring might inject:

VelocityCheck
BlacklistCheck
RiskScoreCheck

Application simply executes them in order.

What happens if @Order is removed?

Spring still injects all matching beans, but the order falls back to bean registration order. Since registration order is an implementation detail, we shouldn't depend on it.

Does @Order affect which bean is injected here?

@Autowired
PaymentService paymentService;

No.

@Order only affects collections, arrays, and ordered extension points. For a single bean injection, we should use @Primary or @Qualifier.

What if one payment strategy throws an exception?

A robust design should isolate failures so that one strategy doesn’t necessarily stop the rest of the pipeline.

Common approaches include:

• Catching exceptions per strategy and continuing when appropriate

• Logging failures and collecting results

• Using retry or circuit breaker patterns for external calls

• Returning a result object instead of throwing exceptions

• Applying resilience libraries such as Resilience4j

Thats all for this week friends! Thanks for reading this far. If you liked it please share with your network.

Share

Before you leave, don’t forget to unlock all the real world use case based interview questions , just at $4/mo (with annual subscription).

Happy Coding 🚀
Suraj

Subscribe | Sponsor us | LinkedIn | Twitter | Youtube

Question

Consider the following entity & service:

What happens when this method completes?

A.The database is not updated because save() was never called.

B.Hibernate automatically detects the change and executes an UPDATE.

C.The database is not updated because entities are immutable by default.

D.The database is updated only if flush() is called manually.

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 7900+ subscribers for hand-crafted, no-fluff content.

First 100 paid subscribers will get the annual membership at $50/year forever that is ~ $4/mo ( 97 already converted to paid, 3 remaining)

So far we have covered 67 real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

Correct Answer

B. Hibernate automatically detects the change and executes an UPDATE.

Explanation

The call to:

userRepository.findById(id)

returns a managed entity because it is loaded within an active transaction.

When we modify the entity:

user.setEmail("new@email.com");

Hibernate records that the managed object’s state has changed.

When the transaction commits, Hibernate performs Dirty Checking.

Transaction Starts
        │
        ▼
findById()
        │
Managed Entity
        │
        ▼
user.setEmail(...)
        │
Entity State Changes
        │
        ▼
Dirty Checking
        │
        ▼
UPDATE users
SET email='new@email.com'
WHERE id=?

No explicit save() call is required.

What SQL gets executed?

Read more

Question

Consider the following entity & repository :

Database:

Users

id name

1 Alice

Orders

id user_id product
101. 1 OrderA

102 1 OrderB

What will findUsers() return?

A.

Alice

B.

Alice
Alice

C.

Throws an exception

D.

Empty result

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 7900+ subscribers for hand-crafted, no-fluff content.

First 100 paid subscribers will get the annual membership at $50/year forever that is ~ $4/mo ( 97 already converted to paid, 3 remaining)

So far we have covered 67 real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

Correct Answer

B. Alice, Alice

Explanation

A JOIN FETCH performs a SQL join and eagerly loads the associated collection.

Hibernate generates SQL similar to:

SELECT u.*, o.*
FROM users u
JOIN orders o
ON u.id = o.user_id;

The database returns:

User Order

Alice OrderA

Alice OrderB

Notice that Alice appears once for every matching order.

Hibernate creates only one User entity instance in the persistence context (thanks to the first-level cache), but the result list contains one reference for each SQL row.

So the returned list looks like:

[
  User(id=1),
  User(id=1)
]

Both entries actually reference the same Java object, but the list contains duplicate references.

How would you fix this so that only one user is returned?

Use DISTINCT in JPQL:

@Query("""
select distinct u
from User u
join fetch u.orders
""")
List<User> findUsers();

Hibernate removes duplicate root entities from the result list while still fetching the collection efficiently.

Is JOIN FETCH safe with pagination?

Read more

This week is packed with content on two of the hottest topics in the Java ecosystem: AI and modern Java architecture.

We'll learn how Java is positioning itself for the AI era with Spring AI, MCP, and AI-agent workflows, while also diving into practical engineering topics like virtual threads, cache stampedes, HotSpot internals, resilient microservices, rollout strategies, and application modernization.

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 8000+ subscribers for hand-crafted, no-fluff content.

First 100 paid subscribers will get the annual membership at $50/year forever that is ~ $4/mo ( 94 already converted to paid, 6 remaining)

So far we have covered 68+ real world based interview questions and will add up to 100 by end of this year.

Subscribe now

Testimonials

Articles Of The Week

Can You Use Java for AI? Why Java Is Better Positioned Than You Think

This article argues that Java is no longer just an enterprise language, it’s becoming a strong choice for building production AI applications. Instead of focusing on model training (where Python dominates), Java excels at integrating LLMs into enterprise systems using frameworks like Spring AI, LangChain4j, and MCP. Existing Java developers can leverage their expertise in APIs, security, scalability, and business logic to build AI-powered applications without learning an entirely new ecosystem.

Mitigating Cache Stampedes in Dynamic API Translation Using Java 21 Virtual Threads

This article explores how cache stampedes (or the “thundering herd” problem) can overwhelm backend services when many concurrent requests try to rebuild the same expired cache entry. The article demonstrates how Java 21’s virtual threads make it easier to implement request coalescing, allowing only one thread to refresh the cache while others wait, reducing database load, improving throughput, and preventing cascading failures in high-concurrency applications.

Going Stateless: Scaling MCP Servers to Cloud-Native Java and HTTP

This article explains how designing Model Context Protocol (MCP) servers without session state improves scalability, resilience, and deployment flexibility. By making every request self-contained, MCP servers can be horizontally scaled behind load balancers, recover from failures more easily, and simplify cloud-native deployments while avoiding the complexity of sticky sessions and shared server state.

Stop Rewriting Working Java Applications: Modernize Without the Cost

This article argues that modernization doesn't have to mean a complete rewrite. Instead, organizations can extend the life of stable Java applications by upgrading runtimes, adopting modern JDKs, removing technical debt, and automating refactoring. This incremental approach reduces cost, minimizes risk, and delivers modernization benefits without disrupting proven business-critical systems.

How We Beat HotSpot Performance (By Cheating, But Not Like That)

This article explains how the authors improved JVM performance by exploiting implementation details rather than changing application logic. The article explores HotSpot internals, JIT compilation behavior, and low-level optimization techniques to outperform default JVM execution, highlighting how a deep understanding of the runtime can unlock performance gains that traditional application-level optimizations often miss.

Your Loom App Quietly Became a Thread Pool Again: A Field Guide to Virtual Thread Pinning

This article explains one of the biggest performance pitfalls of Project Loom: virtual thread pinning. It covers what causes pinning, how JDK 24 significantly reduces it with JEP 491, and practical techniques to detect and eliminate pinned threads using JFR, thread dumps, and better synchronization patterns like ReentrantLock. A must-read for anyone adopting virtual threads in production.

A Practical Guide to Software Rollout Strategies

This article explains how modern deployment techniques reduce the risk of production outages by separating deployment from release. It compares strategies like rolling deployments, blue-green, canary releases, feature flags, dark launches, and ring-based rollouts, highlighting their trade-offs, rollback capabilities, and ideal use cases. The key takeaway is that successful software delivery relies on minimizing blast radius, automating rollbacks, and combining progressive delivery techniques with strong observability.

Resilience4j Bulkheads in Spring Boot for Concurrency Limits

This article explains how the Bulkhead pattern prevents a slow or failing dependency from exhausting application’s resources by limiting concurrent requests. It covers both SemaphoreBulkhead and ThreadPoolBulkhead, their configuration in Spring Boot, tuning options like maxConcurrentCalls and maxWaitDuration, and best practices for combining bulkheads with retries, timeouts, metrics, and observability to build resilient services.

AGENTS.md Makes Your Java Codebase AI-Agent Ready

This article explores how an AGENTS.md file acts as a repository-level guide for AI coding agents, providing project-specific instructions such as build commands, coding standards, testing requirements, and architectural conventions. By giving agents consistent context, teams can improve the quality, accuracy, and consistency of AI-generated code while reducing repetitive prompts and onboarding effort.

Videos Of The Week

The Java Story | The Official Documentary

Java began as Oak, a programming language for consumer electronics, but after that project failed, its creators pivoted to the emerging web. Its "write once, run anywhere" philosophy, powered by the JVM, solved cross-platform compatibility and combined advanced runtime features like garbage collection and multithreading with a familiar C-like syntax. Java quickly evolved from browser applets to enterprise applications through technologies like Servlets, becoming a foundation for modern backend development. The documentary also highlights Java's rivalry with Microsoft, whose leadership viewed the JVM as a major threat to Windows' dominance.

How a Junior Developer Created One of Java's Most Widely Used Server Technologies

Servlets became Java's bridge between web requests and enterprise applications. The collaborative development of the Servlet specification and its open-source reference implementation, Apache Tomcat, laid the foundation for modern Java web development and inspired the Java Community Process (JCP) that still governs Java standards today.

from Brackets to Beans to Boot

Josh Long explains why Spring exists by walking through the evolution from plain Java to Spring Boot. He starts with raw JDBC code to highlight common problems like boilerplate, manual dependency management, and transaction handling, then introduces core Spring concepts, dependency injection, portable service abstractions, and auto-configuration—to show how they eliminate complexity. The result is cleaner, more maintainable code where developers can focus on business logic instead of infrastructure.

Self-Correcting Structured Output in Spring AI 2.0

This video introduces a smarter way to generate reliable structured responses from LLMs. Instead of failing when AI output doesn't match the expected schema, Spring AI 2.0 automatically validates the response, sends validation errors back to the model, and retries until the output conforms to the required format. This reduces parsing failures, improves reliability, and lets developers work with strongly typed Java objects without writing complex validation or retry logic themselves.

In-house Blogs

• Spring Data JPA Interview Quiz: The Lazy Loading Trap

• Spring Boot Quiz: Which Bean Gets Injected?

• Spring Boot Interview Question — Real-Time Seat Map Updates

• Spring Boot Interview Question - Kafka Consumer Became a Zombie

• Java Bug Fix Interview Question — Payment Retry Bug

Checkout full list here

Thats all for this week friends! Thanks for reading this far. If you liked it please share with your network.

Share

Before you leave, don’t forget to unlock all the real world use case based interview questions , just at $4/mo (with annual subscription).

Happy Coding 🚀
Suraj

Subscribe | Sponsor us | LinkedIn | Twitter | Youtube

You have Open Session in View (OSIV) disabled:

spring.jpa.open-in-view=false

When a client calls:

GET /users/1

What happens?

A. The response is returned successfully because Hibernate automatically loads orders.

B. Spring changes LAZY to EAGER during JSON serialization.

C. The request fails with LazyInitializationException.

D. Hibernate silently returns an empty orders collection.

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 7800+ subscribers for hand-crafted, no-fluff content.

First 100 paid subscribers will get the annual membership at $50/year forever that is ~ $4/mo ( 95 already converted to paid, 5 remaining)

Subscribe now

So far we have covered 67 real world based interview questions and will add up to 100 by end of this year.

Testimonials

Answer

C. The request fails with LazyInitializationException.

Why?

The orders collection is marked as:

@OneToMany(fetch = FetchType.LAZY)

So when this executes:

repository.findById(id);

Hibernate loads only the User:

SELECT *
FROM users
WHERE id = 1;

It does not load the orders. Instead, Hibernate creates a lazy proxy for the collection.

This how the flow would look like

Typical error:

failed to lazily initialize a collection of role:
User.orders:
could not initialize proxy - no Session

Why doesn't this happen in every Spring Boot application?

Read more

This week, we cover essential insights on:

One Quick Announcement:

We are now planning to actively post on Youtube, mainly solving real world interview questions. So consider subscribing

Youtube Channel

Also, consider sharing your interview questions to me through DM or email (surajmishra150893@gmail.com). I will try to cover them.

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 8000+ subscribers for hand-crafted, no-fluff content.

First 100 paid subscribers will get the annual membership at $50/year forever that is ~ $4/mo ( 94 already converted to paid, 6 remaining)

Subscribe now

So far we have covered 68+ real world based interview questions and will add up to 100 by end of this year.

Testimonials

Articles Of The Week

Nulling Out References Won’t Help Your Garbage Collector : This article explains that manually setting object references to null rarely helps Java's garbage collector because modern JVMs already determine when objects are no longer reachable. Explicit nulling usually adds unnecessary code and can even interfere with JVM optimizations. The only situations where it may be beneficial are long-running methods or loops where releasing large objects earlier can reduce memory pressure before the method completes. Instead of manually nulling references, developers should focus on eliminating memory leaks, reducing unnecessary object allocations, and understanding object lifecycles—letting the JVM's garbage collector do its job

Guardrails with OPA Policies in Quarkus LangChain4j : This article demonstrates how to build fast and cost-effective AI guardrails in Quarkus LangChain4j by combining Open Policy Agent (OPA) with WebAssembly (Wasm). Instead of sending every prompt to an LLM for prompt injection detection, deterministic OPA policies quickly allow or block obvious cases in under a millisecond at zero token cost, while only ambiguous prompts are escalated to an LLM for deeper analysis. This hybrid approach improves performance, reduces LLM costs, externalizes security policies from application code, and provides auditable, platform-independent guardrails for enterprise AI applications.

LLM Tool Call Reasoning Using Embabel Agentic AI Framework : The article shows how to build explainable AI agents in Spring AI by capturing the LLM's reasoning during tool selection using the Tool Argument Augmenter. Instead of only seeing which tool was called, developers can also understand why the model chose it, improving debugging, observability, and trust in AI applications. This additional reasoning can be logged, audited, or analyzed to make agent behavior more transparent and easier to troubleshoot in production.

Airbnb Shares Architecture behind Sitar-Agent Dynamic Configuration Sidecar for Kubernetes Services : This article shows how to build explainable AI agents in Spring AI by capturing the LLM's reasoning during tool selection using the Tool Argument Augmenter. Instead of only seeing which tool was called, developers can also understand why the model chose it, improving debugging, observability, and trust in AI applications. This additional reasoning can be logged, audited, or analyzed to make agent behavior more transparent and easier to troubleshoot in production.

Level Up Your Programming Game with a Java Book and Smalltalk : Author explains how writing Eclipse Collections Categorically led him back to the ideas of Smalltalk, a language that heavily influenced his approach to software design and Java development. He argues that many of Java's best practices, including cleaner APIs, method categorization, and developer productivity, can be traced back to Smalltalk. It encourages Java developers to learn from classic programming books and languages, emphasizing that timeless design principles can make us better programmer regardless of the language we use.

The AI Threat to Your Java Estate’s Security Is Coming from Both Outside and In : This article explains that AI is changing the Java security landscape from both directions: attackers are using AI to discover and exploit vulnerabilities faster, while developers are increasingly introducing AI-generated code that may contain security flaws. It argues that traditional patching cycles are no longer sufficient and emphasizes the need for complete visibility into Java runtimes, prompt JVM updates, continuous vulnerability assessment, and proactive security governance. The key message is that securing Java estate now requires managing both external AI-driven threats and the internal risks introduced by AI-assisted development.

HTTP QUERY in Java: The Missing Method for Complex REST API Searches : This article introduces the new HTTP QUERY method (RFC 10008) as a better alternative for complex search operations in REST APIs. Unlike GET, which is limited by URL length and query parameters, or POST, which doesn't accurately represent read-only operations, QUERY allows clients to send a structured request body while preserving safe and idempotent HTTP semantics.

Tuning Resilience4j Retry in Spring Boot Without Making Outages Worse : This article explains how to tune Resilience4j Retry in Spring Boot to improve reliability without amplifying failures during outages. Rather than blindly increasing retry counts, it recommends configuring retry limits, exponential backoff with jitter, selective exception handling, and combining retries with circuit breakers and timeouts. The key takeaway is that poorly configured retries can overwhelm struggling services, while well-tuned retry policies help applications recover gracefully without causing retry storms or cascading failures.

The Java Story: A Film About All of Us : This article highlights "The Java Story," a community-driven documentary that celebrates Java's 30-year journey through the people, innovations, and ecosystem that shaped one of the world's most influential programming languages. Rather than focusing solely on technical features, the film explores Java's impact on developers, open source, enterprise software, and the global community, showcasing how collaboration and continuous evolution have kept Java relevant for decades. It serves as both a historical retrospective and a tribute to the developers who continue to drive the platform forward.

📢 Most developers learn Vim by reading cheat sheets.

The fastest ones build muscle memory instead.

Gamified practice is surprisingly effective because it trains your fingers—not just your brain. Even 10 minutes a day can make navigation feel effortless, and those tiny improvements compound over thousands of edits.

Small habits. Faster coding.

Checkout: https://vimgym.io/welcome

Videos Of The Week

Scripting JS and Python with Project Detroit : Project Detroit is a new OpenJDK initiative that enables Java applications to run JavaScript (via V8) and Python (via CPython) directly inside the JVM using the javax.script API. Rather than building its own scripting engines like Nashorn, it provides a lightweight bridge to existing native runtimes, simplifying interoperability while maintaining high performance. Detroit will be distributed separately from the JDK, allowing independent versioning, and although still experimental, Oracle says it is already working well internally with plans to expand it through community feedback.

Java is entering a new era : Java 26 continues the platform’s evolution with a simpler language, richer APIs, and faster runtime, introducing features like Stream Gatherers, Scoped Values, the Foreign Function & Memory API, Structured Concurrency, HTTP/3 support, and ongoing improvements to virtual threads, GC, and Project Leyden. The language also reduces boilerplate through compact source files, module imports, primitive pattern matching, lazy constants, and other developer-friendly enhancements while strengthening performance and JVM integrity.

Idiomatic Kotlin applications with Spring Boot 4 : shares best practices for building modern Kotlin applications with Spring Boot 4, recommending Gradle Kotlin DSL, Java 25, Kotlin 2.x, WebMVC with virtual threads, and Spring’s new null-safe APIs powered by JSpecify. He highlights major improvements in Spring Boot 4, including modularization, Bean Registrar DSL, and Kotlin-friendly enhancements that simplify configuration, validation, and Java interoperability.

Spring AI 2.0: Custom Advisors for Tool & Token Logging : Author demonstrates how to build custom Spring AI Advisors, which act like AOP interceptors around LLM calls, allowing developers to execute logic before and after AI requests. He creates advisors to log available and invoked tools, monitor token usage, and improve visibility into AI interactions without changing application code. The video highlights Advisors as a powerful extension mechanism for observability, debugging, guardrails, and upcoming features like dynamic tool search in Spring AI.

In-house Blogs

• Spring Boot Quiz: Which Bean Gets Injected?

• Spring Boot Interview Question — Real-Time Seat Map Updates

• Spring Boot Interview Question - Kafka Consumer Became a Zombie

• Java Bug Fix Interview Question — Payment Retry Bug

• Java Interview Question - Interval Aggregation Service Bug

Thats all for this week friends! Thanks for reading this far. If you liked it please share with your network.

Share

Before you leave, don’t forget to unlock all the real world use case based interview questions , just at $4/mo (with annual subscription).

Happy Coding 🚀
Suraj

Subscribe | Sponsor us | LinkedIn | Twitter | Youtube

You're working on a payment service where multiple payment providers exist.

Everything compiles successfully.

What does Spring inject into paymentService?

A. StripePaymentService

B. PaypalPaymentService

C. Spring randomly picks one implementation.

D. Nothing—the application fails to start because multiple beans match PaymentService.

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 7800+ subscribers for hand-crafted, no-fluff content.

First 100 paid subscribers will get the annual membership at $50/year forever that is ~ $4/mo ( 93 already converted to paid, 7 remaining)

Subscribe now

So far we have covered 67 real world based interview questions and will add up to 100 by end of this year.

Testimonials

Answer

D. Nothing—the application fails to start because multiple beans match PaymentService.

Typical Startup Error

Parameter 0 of constructor in CheckoutService required a single bean,
but 2 were found:

- stripePaymentService
- paypalPaymentService

Why?

Spring performs dependency injection by type.

When it finds multiple beans of the same type, it refuses to guess which one we intended. Unlike some frameworks, Spring does not inject one arbitrarily.

How would you fix it?

Option 1 — Use @Primary

@Service
@Primary
class StripePaymentService implements PaymentService {
}

Spring now injects StripePaymentService by default.

Option 2 — Use @Qualifier

@Autowired
@Qualifier("paypalPaymentService")
private PaymentService paymentService;

Now the desired implementation is explicit.

Option 3 — Inject all implementations

Sometimes we actually want every implementation.

@Autowired
private List<PaymentService> paymentServices;

Spring injects:

[
  StripePaymentService,
  PaypalPaymentService
]

This is commonly used for:

• Notification channels

• Authentication strategies

• Rule engines

• Plugin architectures

» Checkout more quizzes

This week, we cover essential insights on:

One Quick Announcement:

We are now planning to actively post on Youtube, mainly solving real world interview questions. So consider subscribing

Youtube Channel

Also, consider sharing your interview questions to me through DM or email (surajmishra150893@gmail.com). I will try to cover them.

📢 Get actionable Java and Spring Boot insights every week, including practical code tips and real-world, use-case-based interview questions, to help you level up your backend skills—join 7800+ subscribers for hand-crafted, no-fluff content.

First 100 paid subscribers will get the annual membership at $50/year forever that is ~ $4/mo ( 93 already converted to paid, 7 remaining)

Subscribe now

So far we have covered 68 real world based interview questions and will add up to 100 by end of this year.

Testimonials

Articles Of The Week

The Hidden Tradeoffs of Event-Driven Design : This article shares hard-earned lessons from building large-scale event-driven systems, showing that the biggest production challenges often come from state management, consumer bottlenecks, and cache consistency, not Kafka itself. It explains practical trade-offs between local caches, Redis, synchronous communication, and event streams, arguing that successful architectures combine asynchronous and synchronous patterns rather than relying on event-driven design everywhere.

Hardwood Promises High-Speed JVM Apache Parquet Processing : Hardwood is a new open-source Java library that reimagines Apache Parquet reading with near-zero mandatory dependencies and a multi-threaded architecture, delivering faster performance than the traditional parquet-java implementation. Designed by Gunnar Morling, it provides both row- and column-oriented APIs while avoiding the heavy Hadoop dependency tree, making it ideal for modern JVM data processing workloads.

Save Memory in Java by Making Memory Efficiency Your Top Priority : This article argues that memory efficiency should be a first-class design goal in Java, as reducing object overhead, choosing the right data structures, and optimizing object layouts often delivers bigger gains than GC tuning. Drawing on real-world experience and Eclipse Collections, Don Raab demonstrates how measuring memory with tools like JOL and making small, deliberate optimizations can dramatically improve scalability without sacrificing performance.

Dead Letter Queue Patterns in Apache Flink : This article explains why Dead Letter Queues (DLQs) are essential in Apache Flink to prevent a single "poison message" from repeatedly crashing a streaming job. It recommends production-ready patterns such as side outputs, exponential backoff retries, tiered DLQs, durable Kafka/S3 sinks, monitoring, and dedicated replay pipelines to ensure bad records are isolated, debuggable, and safely reprocessable.

Resilience4j Circuit Breakers in Spring Boot That Actually Trip : This article explains that Resilience4j circuit breakers only trip after collecting enough failure data—they don't block traffic on the first error. It walks through how sliding windows, minimum call thresholds, failure/slow-call rates, and the CLOSED → OPEN → HALF_OPEN state transitions determine when requests are rejected, helping developers understand why breakers sometimes appear to "never trip."

Continuous Development with Claude Code on GitHub : This article demonstrates how to turn Claude Code into a continuous AI contributor on GitHub by integrating the Claude GitHub App with GitHub Actions, allowing it to implement issues, review pull requests, and submit tested code automatically. Using a Spring Boot sample project, it shows how AI-driven development workflows can automate much of the feature implementation and review cycle while keeping developers in control through GitHub's existing collaboration model.

Building an AI-Powered Operations Assistant with Spring AI and MongoDB Atlas : This article completes the AI Operations Assistant series by adding stateful workflows, checkpointing, and human-in-the-loop approvals, enabling multi-step investigations to pause, resume, and survive application restarts. Built with Spring AI and MongoDB Atlas, it combines tool calling, persistent workflow state, audit trails, and operator approval to create production-ready AI agents that are reliable, transparent, and safe for operational tasks.

Quarkus REST with Apache Camel and Keycloak : This article demonstrates how to build a secure Quarkus REST API using Apache Camel's REST DSL, Hibernate Panache, and Keycloak for OIDC authentication, all with minimal configuration. It also highlights Quarkus Dev Services, automatic Keycloak provisioning, and the integration of Swagger/OpenAPI with Camel routes, making it easy to develop, test, and document secured REST services.

Videos Of The Week

A Decade of Redefining Java Performance : This talk traces the evolution of Java garbage collection, showing how ZGC transformed Java from suffering long GC pauses to delivering sub-millisecond pause times suitable for low-latency applications. It explains ZGC’s concurrent, generational design, its scalability to terabyte-sized heaps, and recent improvements in JDK 21–26 that make it easier to use, more efficient, and ready for future innovations like automatic heap sizing.

SIMD Vectors in the HotSpot JVM : Java is steadily improving its ability to leverage modern CPUs through auto-vectorization and the Vector API, enabling multiple data elements to be processed with a single instruction for significant performance gains. This talk demonstrates how these technologies accelerate common algorithms like reductions and dot products while keeping Java portable across hardware. It also highlights ongoing OpenJDK work to expand automatic optimizations and mature the Vector API for AI, scientific computing, cryptography, and other compute-intensive workloads.

The Spring AI Ecosystem in 2026: From Foundations to Agents : Spring AI is evolving from simple prompt pipelines into a complete framework for building AI applications with memory, RAG, guardrails, structured outputs, tool calling, and agentic workflows using a pluggable Advisor pattern. It also embraces Model Context Protocol (MCP), making it easier for LLMs to securely interact with external systems, APIs, databases, and enterprise tools through standardized connectors. Together, Spring AI and MCP provide the foundation for building observable, extensible, production-ready AI agents in the Java ecosystem.

The New @RedisListener Simplifies Everything : Spring Boot 4.1 introduces first-class Redis Pub/Sub listeners with @RedisListener, eliminating the boilerplate of manually configuring RedisMessageListenerContainer and MessageListenerAdapter. Developers can now consume typed JSON payloads directly, making Redis messaging feel as simple and consistent as @KafkaListener or @RabbitListener. This significantly reduces setup code while improving readability and developer experience.

In-house Blogs

• Spring Boot Interview Question — Real-Time Seat Map Updates

• Spring Boot Interview Question - Kafka Consumer Became a Zombie

• Java Bug Fix Interview Question — Payment Retry Bug

• Java Interview Question - Find Minimum Version in Rotated Release History

• Java Interview Question - Interval Aggregation Service Bug

Thats all for this week friends! Thanks for reading this far. If you liked it please share with your network.

Share

Before you leave, don’t forget to unlock all the real world use case based interview questions , just at $4/mo (with annual subscription).

Subscribe now

Happy Coding 🚀
Suraj

Subscribe | Sponsor us | LinkedIn | Twitter | Youtube