Java Backend Developer 1st Round Interview Questions

Java Backend Developer – 2nd Round Interview These 20 questions separate good developers from great ones. 1. How does the G1 Garbage Collector work? What are regions, and how does it decide what to collect? 2. What is a memory leak in Java? Walk through how you’d detect and fix one in production. 3. How does ReentrantLock differ from synchronized? When would you prefer one over the other? 4. Explain happens-before in Java Memory Model. Why does it matter in multithreaded code? 5. How does Spring’s @Transactional handle rollback internally? What are common pitfalls? 6. What is the difference between REQUIRED, REQUIRES_NEW and NESTED propagation in transactions? 7. How would you implement distributed locking across microservices? 8. How does Hibernate’s first-level vs second-level cache work? When does it hurt you? 9. Explain the N+1 problem in JPA. How do you detect and fix it? 10. How would you design an idempotent REST API? Why does it matter? 11. How does database connection pooling work? How do you tune HikariCP for high throughput? 12. What is eventual consistency? How would you handle it in a microservices architecture? 13. How do you implement optimistic vs pessimistic locking? When would you use each? 14. How would you design a rate limiter for a public API? 15. What is the Saga pattern? How does it compare to 2PC for distributed transactions? 16. How would you secure inter-service communication in a microservices setup? 17. How does Kafka ensure message ordering and exactly-once delivery? 18. How would you design a system that processes 1 million requests per day without downtime? 19. How do you do zero-downtime deployment for a Spring Boot service running in Kubernetes? 20. Your service’s p99 latency spiked from 80ms to 2s overnight. Walk me through your debugging process. Preparing for interviews? Start revising these today 𝗜’𝘃𝗲 𝗽𝗿𝗲𝗽𝗮𝗿𝗲𝗱 𝗶𝗻 𝗗𝗲𝗽𝘁𝗵 𝗝𝗮𝘃𝗮 𝗦𝗽𝗿𝗶𝗻𝗴𝗯𝗼𝗼𝘁 𝗯𝗮𝗰𝗸𝗲𝗻𝗱 𝗚𝘂𝗶𝗱𝗲, 𝟏𝟬𝟬𝟬+ 𝗽𝗲𝗼𝗽𝗹𝗲 𝗮𝗿𝗲 𝗮𝗹𝗿𝗲𝗮𝗱𝘆 𝘂𝘀𝗶𝗻𝗴 𝗶𝘁. 𝗚𝗲𝘁 𝘁𝗵𝗲 𝗴𝘂𝗶𝗱𝗲 𝗵𝗲𝗿𝗲: https://lnkd.in/dfhsJKMj keep learning, keep sharing ! #java #backend #javaresources

IF YOU THINK YOU’RE GOOD AT JAVA & SPRING BOOT, TRY ANSWERING THESE WITHOUT GOOGLE. These are real scenario-based questions interviewers use to test production-level thinking: Java (Runtime, JVM, Concurrency) 1) Your Java app slows down over time without errors. What could be happening internally? 2) CPU is low but response time is high. What might be blocking threads? 3) OutOfMemoryError occurs even with sufficient heap. Why? 4) Increasing heap size made performance worse. Explain. 5) Threads are free but requests are queued. Why? 6) GC pauses increased after a small change. What might have changed? 7) JVM doesn’t exit after main() completes. What’s holding it? 8) Parallel streams reduced performance instead of improving it. Why? 9) Memory usage keeps increasing slowly. What do you suspect? 10) Logging change caused slowdown. How? 11) ThreadLocal fixed one issue but caused another. Why? 12) ExecutorService tasks fail silently. What went wrong? 13) Retry logic overloaded the system. What mistake was made? 14) Deadlock happens only in production. Why? 15) Scaling instances made performance worse. Why? Spring Boot (Production Scenarios) 16) App works locally but fails in production. What do you check first? 17) APIs are fast locally but slow in prod. Why? 18) application.properties change didn’t reflect. Why? 19) CPU is low but requests timeout. What’s the bottleneck? 20) Multiple beans cause startup failure. How to fix? 21) @Transactional present but rollback doesn’t happen. Why? 22) DB connection pool exhausts under load. Why? 23) Scheduled jobs affect API latency. How to isolate? 24) App behaves differently in Docker vs local. Why? 25) New deployment but users see old behavior. What went wrong? 26) Logs missing in production but present locally. Where to check? 27) Async processing made performance worse. How? 28) Circuit breaker stays open even when service is healthy. Why? 29) Adding more resources didn’t improve performance. Why? 30) What Spring Boot decision you made could cause production issues? These questions are not about syntax. They test whether you can THINK when systems behave unexpectedly. I’ll share the detailed PDF with interested folks.

IF YOU THINK YOU’RE GOOD AT JAVA & SPRING BOOT, TRY ANSWERING THESE WITHOUT GOOGLE. These are real scenario-based questions interviewers use to test production-level thinking: Java (Runtime, JVM, Concurrency) 1) Your Java app slows down over time without errors. What could be happening internally? 2) CPU is low but response time is high. What might be blocking threads? 3) OutOfMemoryError occurs even with sufficient heap. Why? 4) Increasing heap size made performance worse. Explain. 5) Threads are free but requests are queued. Why? 6) GC pauses increased after a small change. What might have changed? 7) JVM doesn’t exit after main() completes. What’s holding it? 8) Parallel streams reduced performance instead of improving it. Why? 9) Memory usage keeps increasing slowly. What do you suspect? 10) Logging change caused slowdown. How? 11) ThreadLocal fixed one issue but caused another. Why? 12) ExecutorService tasks fail silently. What went wrong? 13) Retry logic overloaded the system. What mistake was made? 14) Deadlock happens only in production. Why? 15) Scaling instances made performance worse. Why? Spring Boot (Production Scenarios) 16) App works locally but fails in production. What do you check first? 17) APIs are fast locally but slow in prod. Why? 18) application.properties change didn’t reflect. Why? 19) CPU is low but requests timeout. What’s the bottleneck? 20) Multiple beans cause startup failure. How to fix? 21) @Transactional present but rollback doesn’t happen. Why? 22) DB connection pool exhausts under load. Why? 23) Scheduled jobs affect API latency. How to isolate? 24) App behaves differently in Docker vs local. Why? 25) New deployment but users see old behavior. What went wrong? 26) Logs missing in production but present locally. Where to check? 27) Async processing made performance worse. How? 28) Circuit breaker stays open even when service is healthy. Why? 29) Adding more resources didn’t improve performance. Why? 30) What Spring Boot decision you made could cause production issues? These questions are not about syntax. They test whether you can THINK when systems behave unexpectedly.

When working in backend development, a common question is: which is better, Java or Node.js? In reality, there is no absolute answer. Each technology is designed for different types of problems. Node.js uses a single-threaded event loop model and excels at handling I/O-bound tasks such as database queries or API calls. Thanks to its non-blocking nature, Node.js can efficiently handle thousands of concurrent requests. This makes it a great fit for APIs, microservices, and real-time systems. On the other hand, Java (Spring Boot) runs on the JVM with a multi-threaded model, making it more suitable for CPU-intensive tasks. The JVM provides advanced garbage collection mechanisms, multiple optimization strategies, and deep tuning capabilities. As a result, Java is often used in large-scale systems like banking or enterprise applications, where stability and performance are critical. One limitation of Node.js is that it can be blocked by heavy computations and requires careful memory management. However, these issues can be mitigated by using message queues like Kafka or by splitting workloads into separate services. In conclusion, the goal is not to choose the “stronger” technology, but the more appropriate one. A well-designed system often combines the right tools for the right tasks.

Java Backend Developer 1st Round Interview These 20 questions are being asked in 2026 1. How does HashMap work internally? Explain buckets, hashing & resizing. 2. What is the difference between HashMap and ConcurrentHashMap? 3. How does JVM memory structure work? (Heap, Stack, Metaspace) 4. What causes OutOfMemoryError in production? How would you debug it? 5. How do you make a class thread-safe? Give a real scenario. 6. Explain the complete lifecycle of a Spring Bean. 7. How does Dependency Injection work internally in Spring? 8. What actually happens when you use @Transactional? 9. Difference between @Component, @Service and @Repository? 10. How would you handle global exception handling in Spring Boot? 11. What is lazy vs eager loading in JPA? When can it cause performance issues? 12. How do you handle concurrent updates to the same database row? 13. Explain ACID properties with a banking transaction example. 14. How do you optimize a slow SQL query? 15. How would you design pagination & sorting in a REST API? 16. How does JWT authentication work step by step? 17. If your API is slow under load, how would you identify the bottleneck? 18. REST vs Messaging (Kafka), when would you choose which? 19. How would you Dockerize a Spring Boot application? 20. If two microservices fail during communication, how do you handle fault tolerance? 𝗞𝗲𝗲𝗽𝗶𝗻𝗴 𝘁𝗵𝗶𝘀 𝗶𝗻 𝗺𝗶𝗻𝗱, 𝗜 𝘄𝗲𝗻𝘁 𝗱𝗲𝗲𝗽 𝗮𝗻𝗱 𝗱𝗼𝗰𝘂𝗺𝗲𝗻𝘁𝗲𝗱 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 𝗶𝗻𝘁𝗼 𝗮 𝗝𝗮𝘃𝗮 𝗕𝗮𝗰𝗸𝗲𝗻𝗱 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗚𝘂𝗶𝗱𝗲. 𝗚𝗲𝘁 𝘁𝗵𝗲 𝗚𝘂𝗶𝗱𝗲 𝗵𝗲𝗿𝗲: https://lnkd.in/dTvYVutD Use SDE20 to get 20% off. Stay Hungry, Stay FoolisH!

I've been playing with Java applications recently, and the first thing you deal with is memory. Java (via the Xmx parameter) grabs all its allocated memory at startup, even though the JVM doesn't actually *need* it all right away. From the OS's point of view, it's fully consumed immediately. Kind of annoying. Most other runtimes do the opposite: use memory as needed, give it back when you don't. Golang, PHP, and others work this way. And to be clear, this is a runtime thing, not a language thing. Common Lisp is a great example; its most popular runtime uses memory on demand, but there's a Common Lisp runtime on the JVM that behaves like... well, Java. Databases do something similar too. PostgreSQL, MySQL, Redis; they all have this concept of reserved memory. It's not quite the same (it's about max memory for caches that ramp up over time), but the pattern rhymes. The thing I actually appreciate about Java's approach: you fail fast. If you don't have enough memory, you know at boot, not 3 hours into production when traffic spikes. Databases and on-demand runtimes give you that nasty surprise later. Now, the trade-off. If you're running 5-10 apps on the same host and assuming not all of them peak at the same time, Java's "grab everything now" model is wasteful. But we're increasingly moving toward isolated environments; containers, single-process setups, reserved resources. In that world, claiming all your memory upfront actually fits pretty well. ...until you zoom out and remember that container still runs on a host with other containers. And you're back to the same trade-off. I'm honestly torn. Both models have real advantages, and I don't think there's a clean winner.

15 LPA. 6 years experience. 35 LPA. 3 years experience. Same Java. Same Spring Boot. Different mindset. I have observed this pattern across multiple interviews and developer interactions. Experience alone does not lead to 35 LPA. Depth of understanding does. Here is how the thinking differs: ‣ Writing a query: 15 LPA: This query returns the correct data. 35 LPA: This query returns the correct data. How will it perform with 100 million rows? ‣ Building an API: 15 LPA: The API works. Tests are passing. 35 LPA: The API works. How will it behave under 10,000 requests per second? ‣ Fixing a bug: 15 LPA: The bug is resolved and deployed. 35 LPA: The bug is resolved. What was the root cause? Can it reoccur at scale? ‣ Designing a feature: 15 LPA: The feature works end-to-end. 35 LPA: The feature works. What will fail first if traffic doubles at peak hours? This shift in thinking is what 35 LPA interviews truly evaluate. Not syntax. Not frameworks. Not years of experience. It is about: How you analyze failure. How you design for scalability. How you anticipate system breakdowns. Most developers never make this transition. Not due to lack of capability. But due to lack of guidance. This is the exact gap my Java Guide is designed to address. https://lnkd.in/gbK6g7Xq Not syntax. Not tutorials. But how production-grade systems are actually engineered. Developers who adopted this approach stopped just writing code. They started building resilient systems. Stay Hungry, Stay Foolish!!

Most Java developers write this code every day. And don't realize it's making 50 database calls instead of 1. 🧵 It looks completely fine: List<Orders> orders = orderRepository.findAll(); for (Order order : orders) { System.out.println(order.getUser().getName()); } Clean. Readable. Innocent. But here's what's actually happening behind the scenes: 👉 1 query to fetch all orders 👉 1 query PER order to fetch the user 50 orders = 51 queries. 500 orders = 501 queries. This is the N+1 problem. And it silently kills performance. I hit this exact issue in my project. API response was creeping from 300ms to 2+ seconds. No errors. Nothing in logs. Just slow. Profiled it. Found 51 database calls for a simple list fetch. The fix was 1 line: @Query("SELECT o FROM Order o JOIN FETCH o.user") List<Order> findAllWithUser(); Result: 2100ms → 290ms ⚡ Why does this happen? JPA's default fetch type is LAZY — it waits until you access the relationship to query it. Inside a loop, that means one query per iteration. JOIN FETCH tells Hibernate — get everything in one query. The rule I follow now: If you're looping through entities and accessing relationships — always check your query count first. One annotation. Massive difference. Have you run into N+1 in your project? 👇 #Java #SpringBoot #Hibernate #JPA #BackendDevelopment #JavaDeveloper #SoftwareEngineering

Every Java developer uses these 3 terms daily. But 90% of beginners can't explain the difference. JDK vs JRE vs JVM — let me break it down in the simplest way possible. 🧵 ───────────────────── 🔵 JVM — Java Virtual Machine ───────────────────── This is the MAGIC behind Java. Remember Java's biggest promise? "Write Once, Run Anywhere." The JVM is WHY that's possible. Your Java code doesn't run directly on your computer. It runs inside the JVM — a virtual machine that sits between your code and your operating system. Windows? Linux? Mac? The JVM handles it. Your code doesn't care. What JVM does: → Loads your compiled code (.class files) → Verifies it for security → Executes it line by line → Manages memory via Garbage Collection → Optimises performance via JIT (Just-In-Time) Compiler JVM is what makes Java platform-independent. But here's the catch — JVM itself is platform-dependent. There's a different JVM for Windows, Linux, and Mac. ───────────────────── 🟢 JRE — Java Runtime Environment ───────────────────── JRE = JVM + Libraries The JVM alone can't run your program. It needs support — pre-built classes and libraries that Java programs rely on. That's what JRE packages together: → The JVM → Core Java class libraries (java.lang, java.util, java.io etc.) → Supporting files and configs If someone just wants to RUN a Java application — not build one — they need the JRE. Think of it like this: JRE is the PLAYER. It runs the game. But it can't develop the game. ───────────────────── 🟡 JDK — Java Development Kit ───────────────────── JDK = JRE + Developer Tools This is what YOU install when you want to BUILD Java applications. JDK includes everything in JRE, plus: → javac — the Java compiler (converts .java → .class) → javadoc — generates documentation → jdb — Java debugger → jar — packages your app into a .jar file → And many more dev tools As a developer, you always install the JDK. Never just the JRE. ───────────────────── 🧠 The Simple Mental Model ───────────────────── Think of it like a kitchen: 🔵 JVM = The chef (does the actual cooking / executing) 🟢 JRE = The kitchen (chef + all utensils and ingredients) 🟡 JDK = The entire restaurant setup (kitchen + recipe books + tools to create new dishes) ───────────────────── So next time someone asks: "Why do I need to install JDK and not just JRE?" You tell them: "Because you're not just running Java — you're building with it." Dropping one concept every single day. Follow along if you're on the same journey. 🚀 Which of these 3 confused you the most when you started? 👇 #Java #JDK #JVM #JRE #LearnInPublic #SoftwareEngineering #Day2 #FullStackDeveloper #JavaDeveloper

✨ Exploring the Power of Strings in Java ✨ Strings may look simple, but they’re one of the most powerful and frequently used features in Java. Every Java developer works with them daily—whether it’s handling user input, building applications, or processing data. 💡 What makes Java Strings special? A string is a sequence of characters enclosed in double quotes. Unlike characters (which use single quotes), strings can store entire words, sentences, and even large data. But here’s the interesting part 👇 🔹 Strings are Objects In Java, strings aren’t primitive types—they’re objects stored in the heap memory of the JRE. This gives them powerful built-in functionality and efficient memory management. 🔹 Immutable vs Mutable Strings • Immutable (String class) → Once created, the value cannot change. Perfect for fixed data like names or IDs. • Mutable (StringBuffer & StringBuilder) → Can be modified anytime. Ideal for dynamic data like passwords, emails, or large text processing. 🔹 String Pool Magic Java optimizes memory using the String Constant Pool: • Strings created without new → Stored in constant pool (no duplicates). • Strings created with new → Stored in heap (duplicates allowed). This small detail makes Java memory management super efficient 🚀 🔹 Common String Operations Every Developer Uses ✔ Concatenation → + operator or concat() ✔ Comparison → equals(), equalsIgnoreCase(), compareTo() ✔ Handy Methods → length() | charAt() | substring() | replace() | split() | trim() | toUpperCase() | toLowerCase() These methods are the everyday tools that make Java development smooth and powerful.