Java Backend Developer – Core Interview Questions & Topics

Comprehensive Guide: Senior Java Backend Developer – Core Interview Questions & Topics

This blog post provides a deep dive into key interview questions and concepts relevant for seasoned Java backend developers (5–8 years of experience), with a particular focus on Java (including Java 21 features), Spring Boot, Microservices, Kubernetes, and cloud-native practices. Each section below breaks down critical areas you should master to excel in technical interviews and in real-world system design and implementation.

Java: Modern Features and Core Concepts

1. Key Enhancements in Java 21 Benefiting Backend Systems

• Improved performance, new language interoperability, better virtual thread support, and enhanced pattern matching.
• Features like the Foreign Function & Memory API, Record Patterns, and Sequenced Collections simplify development and boost efficiency.

2. Purpose and Usage of var in Local Variable Declarations

• Introduced in Java 10, var allows for local variable type inference, leading to more concise and readable code. It’s only available for local variables (not class fields or method parameters) and always infers the type at compile time.

3. Java Memory Model’s Impact on Multi-threading

• The Java Memory Model (JMM) defines how threads interact through memory. Understanding aspects like happens-before relationships, visibility guarantees, and synchronization is essential to ensure thread safety and minimize subtle concurrency bugs.

4. Difference Between synchronized and ReentrantLock

• synchronized is a simple monitor-based lock at the JVM level, whereas ReentrantLock offers advanced features such as explicit lock/control, try-locking, timed waiting, and fairness policies.

5. Virtual Threads and Scalability

• Virtual threads provide lightweight, high-concurrency threads (Project Loom), allowing Java applications to handle many more concurrent tasks with reduced memory and CPU overhead compared to traditional platform threads.

6. Purpose of Stream.iterate() and Its Use in Java 9+

• Generates streams of data based on an initial seed and function. In Java 9+, overloads allow specifying a termination condition, making loop-like infinite or finite stream generation possible.

7. Java and Backpressure in Stream Processing

• Backpressure is managed using APIs like Reactive Streams or Project Reactor. Java alone doesn’t support backpressure natively; frameworks built on top add this ability to efficiently control data flow.

8. Records vs Lombok’s @Data

• Java records are immutable data carriers with less boilerplate and built-in equals, hashCode, and toString. Lombok’s @Data generates similar methods on standard classes but doesn’t enforce immutability.

9. Sealed Classes and Design Advantages

• Sealed classes (Java 17+) tightly control subclassing by restricting which classes can extend them. This improves maintainability, readability, and compiler exhaustiveness checking in switch expressions.

10. Preventing Object Mutation in Java

• Use final fields, make classes final, avoid exposing setters, and provide defensive copies for mutable objects returned from methods.

Spring & Spring Boot Essentials

11. Role of spring.factories in Auto-configuration

• The spring.factories file lists classes for Spring Boot’s auto-configuration mechanism, allowing third-party libraries or custom code to participate in the configuration process automatically.

12. Overriding Default Configurations

• Achieved via application properties/yaml, environment variables, or @Configuration classes that define custom beans and settings.

13. Spring Bean Lifecycle

• Includes instantiation, dependency injection, initialization (using @PostConstruct or InitializingBean), use, and destruction (using @PreDestroy or DisposableBean).

14. Testing With @WebMvcTest and @SpringBootTest

• @WebMvcTest loads web-related components, ideal for controller tests. @SpringBootTest loads the complete context for integration and end-to-end tests.

15. @RequestScope vs @Singleton

• @RequestScope creates a bean per HTTP request, ideal for stateful request data. @Singleton (default) creates one instance per Spring context, ideal for stateless beans.

16. Pagination Support in Spring Boot REST APIs

• Spring Data provides Pageable and Page abstractions which can be used in controllers to return paginated data automatically.

17. Custom Qualifiers and Ambiguity Resolution

• Custom @Qualifier annotations distinguish between beans of the same type for injection, resolving ambiguity when multiple candidates exist.

18. Spring Data REST vs. Traditional Controllers

• Spring Data REST automatically exposes repository interfaces as REST endpoints, whereas traditional controllers define explicit request mappings and logic in controller methods.

19. Configuring HikariCP Connection Pool

• Set Hikari-specific properties in application.properties/yaml or define a HikariDataSource bean for advanced connection pool customization.

20. CommandLineRunner & ApplicationRunner

• Both interfaces allow execution of code at Spring Boot startup. CommandLineRunner passes string arguments; ApplicationRunner passes parsed application arguments.

Microservices: Design Patterns & Operations

21. Service Orchestration vs Choreography

• Orchestration uses a single service to coordinate calls and workflow, while choreography involves multiple services reacting to events and driving flow without a central coordinator.

22. Distributed Tracing and Correlation IDs

• Tools like OpenTracing, Zipkin, or Jaeger inject unique correlation IDs and trace spans into request headers, enabling end-to-end transaction tracing across services.

23. Sidecar Pattern Application

• The sidecar pattern places helper components (like logging, proxies, or monitoring agents) alongside app containers to provide supporting features without code changes to the main app.

24. Caching Strategies in Microservices

• Include local in-memory caches, distributed caches (e.g., Redis), and HTTP cache headers. Appropriate TTL, cache eviction, and data consistency policies are crucial.

Coding Questions: Sample Challenges

25. Java Function to Validate Balanced Parentheses

• Use a stack to ensure each opening bracket has a corresponding closing bracket in correct order.

26. Longest Common Prefix Among Strings

• Compare the first character of each string in the array, iterating until a mismatch occurs.

27. Recursive Binary Search and Its Time Complexity

• Divide-and-conquer algorithm that repeatedly splits the search array in half. Time complexity: O(log n)
  

Diverse Backend Engineering Topics

28. Kafka vs. RabbitMQ: Key Differences

• Apache Kafka: Distributed streaming, high throughput, horizontal scale, log-based storage.
• RabbitMQ: Traditional broker, message queues, flexible routing via exchanges, typically lower throughput, but more features for message guarantees and routing.

29. Scaling Stateless Microservices in Kubernetes

• Achieved easily by increasing pod replicas, leveraging service discovery and load balancing—statelessness ensures horizontal scalability.

30. StatefulSet in Kubernetes

• Specialized controller for managing stateful applications needing persistent storage, stable network IDs, and ordered, graceful deployment and scaling.

31. Cloud-Native 12-Factor App Principles and Spring Boot

• Principles like declarative setup, stateless processes, externalized config, robust logging, and easy disposability map directly to Spring Boot features.
• Spring Boot’s autoconfiguration, environment abstraction, and support for microservices align naturally with 12-factor methodology.

32. SQL Query: Second Highest Salary

SELECT MAX(salary) FROM employee WHERE salary < (SELECT MAX(salary) FROM employee);

33. Infrastructure as Code (IaC) in Cloud Deployments

• IaC uses tools like Terraform, CloudFormation, or Ansible to manage infrastructure declaratively, enabling repeatable, automated cloud setup and changes through versioned configuration files.

34. Safe Schema Migrations in Production

• Use migration tools (e.g., Flyway, Liquibase), apply non-breaking changes first, monitor application logs/metrics, and have a rollback strategy.

This guide covers the most critical technical interview topics for senior-level Java backend positions and serves as a practical resource for both interview prep and daily engineering excellence.