Skip to main content

Cognizant Java Developer Interview Questions & Answers

This guide covers real-world technical interview questions asked during a Cognizant Java Developer interview. The candidate had 3 years of experience. The interview focused heavily on Spring Boot internals, Microservices architecture (Eureka, Zuul), API performance optimization, and database migration strategies.

1. Spring Boot Internals & Configuration​

Q: What are Conditional Annotations in Spring Boot? Have you used them?​

A: Conditional annotations are a set of special instructions that tell Spring Boot to execute a part of the code (like registering a Bean) only if certain conditions are met.

  • Example: I have used @ConditionalOnClass. It tells Spring Boot to initialize a specific bean only if a certain class is present on the application's classpath.
  • Purpose: They provide fine-grained control over the application, make the code highly flexible across different environments, and increase efficiency by ensuring unnecessary code is not executed if conditions aren't met.

Q: Explain the role of @EnableAutoConfiguration and how Spring Boot achieves this internally.​

A: @EnableAutoConfiguration tells Spring Boot to automatically configure the application based on the dependencies added in the pom.xml. For example, if you add the spring-web-mvc dependency, it automatically sets up a default web server (Tomcat), configures Spring MVC, and handles default error routing, saving you from writing boilerplate setup code.

  • Internal Working: It achieves this through Classpath Scanning. At runtime, Spring Boot looks at the libraries present on the classpath. It reads the auto-configuration manifest files (like spring.factories) and uses @Conditional annotations to determine exactly which default beans to inject.

Q: What are Actuator endpoints? What is the dependency name, and how can we secure them?​

A: Actuator endpoints are used to monitor and manage a Spring Boot application in production (e.g., checking health, viewing logs, gathering metrics). The dependency is spring-boot-starter-actuator. Securing them: Because they expose sensitive application data, they must be secured:

  1. Limit Exposure: Only expose strictly necessary endpoints (like /health) to the web via the application.properties file.
  2. Spring Security: Integrate Spring Security to require authentication to access the actuator URLs.
  3. Role-Based Access: Create a specific administrative role (e.g., ACTUATOR_ADMIN) and restrict endpoint access exclusively to users with that role.
  4. HTTPS: Serve the endpoints over a secure, encrypted connection.

Q: How do Spring Boot Profiles work? Why use .yml over .properties?​

A: Profiles allow you to separate and manage different configurations for different environments (e.g., dev, test, prod). You can set different database URLs or use mock services in dev and real services in prod. You activate them using spring.profiles.active=dev.

  • YML Benefits: .yml (YAML) files are widely preferred over .properties because they offer a clean, hierarchical, tree-like structure using indentation. This vastly improves readability for deeply nested configurations and natively supports lists and maps.

Q: Is it possible to change the default embedded server provided by Spring Boot?​

A: Yes. The default server is Apache Tomcat. To change it, you simply exclude the spring-boot-starter-tomcat dependency from the spring-boot-starter-web package in your pom.xml, and add the dependency for your preferred server, such as spring-boot-starter-jetty or undertow.

2. Microservices Architecture​

Q: You mentioned using Eureka and Zuul. How did they increase the efficiency of your microservice architecture?​

A: * Eureka (Service Discovery): In a distributed system with multiple running services, it's crucial to locate them dynamically. Eureka provided a central registry where all microservices registered themselves upon startup. This simplified the process of services finding and communicating with each other without hardcoding IP addresses.

  • Zuul (API Gateway): Zuul acted as the "front door" for all incoming client requests. It handled dynamic routing (forwarding requests to the correct microservice based on the URL path). More importantly, it allowed us to implement cross-cutting concerns globally—such as Security, Logging, and Request Filtering—at the Gateway level, rather than duplicating that logic inside every single microservice.

Q: What is Spring Cloud and how is it useful for building Microservices?​

A: Spring Cloud is a suite of tools built on top of Spring Boot to manage the complexities of distributed microservice architectures. In an application where different independent services handle Login, Shopping Cart, and Payments, Spring Cloud provides infrastructure patterns like Service Discovery (Eureka), Centralized Configuration (Config Server), and Circuit Breakers to seamlessly connect, secure, and balance traffic between these independent sections.

3. Performance Optimization, AOP & Reactive Programming​

Q: What strategies would you use to optimize the performance of a Spring Boot application?​

A: 1. Caching: Implement caching (e.g., Redis) for frequently accessed, read-heavy data. 2. Database Optimization: Optimize complex SQL queries to reduce load and latency. 3. Asynchronous Processing: Use asynchronous methods (@Async) for slow, non-blocking operations like sending emails. 4. Load Balancing: Use a load balancer to distribute high traffic across multiple server instances. 5. Code Optimization: Improve underlying algorithms (e.g., reducing time complexity from $O(n^2)$ to $O(n \log n)$). 6. Reactive Programming: Utilize Spring WebFlux to handle a massive number of concurrent connections efficiently.

Q: What is Spring WebFlux? Can you provide a real-world analogy?​

A: Spring WebFlux is a reactive, non-blocking web framework used to build highly responsive applications capable of handling massive concurrent traffic without slowing down.

  • Analogy: In a traditional fast-food setup (Spring MVC), one cashier takes an order, waits doing nothing until the kitchen cooks it, hands it to the customer, and then takes the next order. The line gets long. With WebFlux, the cashier takes an order, passes it to the kitchen, and immediately takes the next customer's order. When the food is ready, the customer is notified asynchronously. It handles sudden traffic rushes smoothly without blocking resources.

Q: What is Aspect-Oriented Programming (AOP) in Spring? Give an advanced use case.​

A: AOP is a programming approach that separates "cross-cutting concerns" from the main business logic. Instead of repeating boilerplate code (like logging, security, or transactions) inside every single method, AOP allows you to define this logic once in an Aspect and specify exactly where and when it should execute across the application.

  • Advanced Use Case: Authorization. Instead of writing repetitive if(user.hasPermission()) checks in 50 different controller methods, you write a single Aspect that intercepts incoming API requests, performs the security check globally, and either grants execution or blocks it. This keeps the core controllers perfectly clean.

4. Databases, Caching & System Migration​

Q: How would you integrate a non-relational database like MongoDB into a Spring Boot application?​

A: 1. Add the spring-boot-starter-data-mongodb dependency in the pom.xml. 2. Configure the connection details (Database URL, credentials) inside the application.properties file. 3. Create Repository interfaces by extending MongoRepository, which provides built-in methods for interacting with MongoDB. 4. Inject and use these repositories in the Service layer to save, retrieve, and manage document data just like you would with a relational database.

Q: How would you implement caching in a Spring Boot application?​

A: 1. Add a caching dependency (like EhCache or Redis) to the project. 2. Add the @EnableCaching annotation to the main Spring Boot application class. 3. Use the @Cacheable annotation on service methods to store their results in memory. 4. Use the @CacheEvict annotation on update/delete methods to remove outdated data from the cache, ensuring data consistency.

Q: Describe a scenario where you can implement Asynchronous Messaging in a Spring Boot application.​

A: In an online e-commerce store, when a customer places an order, the main thread can instantly return a "Success" response to the UI, while sending the order details to a Message Queue (like RabbitMQ or Kafka) asynchronously. Background worker services can then consume this message to handle heavy tasks like checking inventory, arranging delivery, and sending confirmation emails without forcing the customer to wait on a loading screen.

Q: If a Spring Boot application is significantly slower in Production than in Development, how would you fix it?​

A: 1. Check Logs: Look for errors, stack traces, or unusually slow processes. 2. Monitor Metrics: Use tools (like Actuator, Prometheus, or APM tools) to track memory usage, CPU load, and endpoint response times. 3. Compare Configurations: Ensure that production configurations (like connection pool sizes or JVM heap settings) are correctly tuned and match the expected production load, unlike the lightweight Dev configs. 4. Analyze Databases & External APIs: Check if database queries are missing indexes in production, or if third-party external services are causing network bottlenecks.

Q: Suppose you need to migrate an existing application to use a new Database Schema without downtime. How would you plan and execute this?​

A: Achieving zero-downtime database migration requires a phased approach:

  1. Design: Create a new schema that is backward-compatible with the old one.
  2. Dual Writes: Update the application code to write incoming data to both the old and the new schemas simultaneously.
  3. Migration Tools: Use tools like Flyway or Liquibase to tightly control and version the schema changes.
  4. Data Sync: Run background batch jobs to carefully migrate all historical data from the old schema to the new one.
  5. Switch & Deprecate: Test thoroughly in a staging environment. Once verified, deploy an update to switch all read operations to the new schema. Finally, deprecate and remove the old schema code entirely.