Spring Boot and Microservices Interview Questions (2026 Master Guide)

Q1. What is Spring Boot and how does it differ from traditional Spring Framework?

Foundation • 0-2 Yrs

Traditional Spring requires extensive manual XML or Java configuration, explicit dependency management, and external web server deployment (e.g., Apache Tomcat). Spring Boot provides opinionated convention-over-configuration: starter dependencies, automated bean configuration (Auto-Configuration), embedded servlet containers (Tomcat, Jetty), and production metrics via Actuator.

Q2. What is Inversion of Control (IoC) and Dependency Injection (DI)?

Foundation • 0-2 Yrs

IoC is a software design principle where control of object creation and lifecycle management is transferred from the application code to a framework container (Spring IoC Container). Dependency Injection is the pattern used to implement IoC: dependencies are passed (injected) into dependent objects at runtime.

Q3. Explain the difference between Constructor Injection, Setter Injection, and Field Injection.

Foundation • 0-2 Yrs

Constructor Injection: Dependencies are passed via constructor (recommended; guarantees immutability, facilitates unit testing, and prevents NPEs). Setter Injection: Dependencies are set via setter methods (good for optional dependencies). Field Injection: Uses @Autowired directly on private fields (discouraged; hides dependencies and makes testing difficult).

Q4. What are Spring Boot Starters and what is their benefit?

Foundation • 0-2 Yrs

Spring Boot Starters are pre-packaged sets of convenient dependency descriptors (e.g., spring-boot-starter-web, spring-boot-starter-data-jpa). They bundle compatible library versions, eliminating version conflicts and reducing build file configurations.

Q5. Explain the @SpringBootApplication annotation and what it encapsulates.

Foundation • 0-2 Yrs

@SpringBootApplication is a meta-annotation that encapsulates three critical annotations: @Configuration (declares class as bean source), @EnableAutoConfiguration (enables automatic bean creation based on classpath), and @ComponentScan (enables package scanning for @Component, @Service, @Repository).

Q6. What are Spring Bean Scopes and what is the default scope?

Foundation • 0-2 Yrs

Singleton: Exactly one bean instance per Spring IoC container (default). Prototype: New bean instance created every time requested. Web-aware scopes: Request (one per HTTP request), Session (one per HTTP session), Application (one per ServletContext), and WebSocket.

Q7. What is Spring Boot Actuator and what endpoints are most useful?

Foundation • 0-2 Yrs

Spring Boot Actuator provides production-ready monitoring and management endpoints. Key endpoints: /actuator/health (verifies service and DB status), /actuator/metrics (CPU, memory, JVM stats), /actuator/info, /actuator/beans, and /actuator/env.

Q8. Explain the difference between @RestController and @Controller in Spring.

Foundation • 0-2 Yrs

@Controller is used for traditional MVC web applications returning HTML view names resolved by a ViewResolver. @RestController is a convenience meta-annotation combining @Controller and @ResponseBody, which automatically serializes returned Java objects into JSON/XML payloads.

Q9. What is Spring Data JPA and how do derived query methods work?

Foundation • 0-2 Yrs

Spring Data JPA reduces boilerplate data access code. By extending JpaRepository, developers get CRUD and pagination out-of-the-box. Derived query methods parse method names (e.g., findByEmailAndStatus(String email, String status)) into SQL queries automatically at runtime.

Q10. What is Microservices Architecture and how does it differ from Monolithic?

Foundation • 0-2 Yrs

A Monolith bundles all business modules into a single unified deployment unit sharing a central database (difficult to scale, single point of failure). Microservices decompose applications into independently deployable, loosely coupled services communicating via lightweight protocols (REST, gRPC, Kafka) with decentralized data storage.

Q11. What is an API Gateway and what core responsibilities does it handle?

Foundation • 0-2 Yrs

An API Gateway (e.g., Spring Cloud Gateway) is the single entry point for all client requests. Responsibilities: Request routing, SSL termination, Authentication & Authorization, Rate Limiting, Cross-Origin Resource Sharing (CORS), and request/response transformation.

Q12. What is Service Discovery and how does Netflix Eureka work?

Foundation • 0-2 Yrs

In dynamic cloud environments, service instances scale up and down with dynamic IP addresses. Service Discovery acts as a phonebook. Eureka Server registers active services; Eureka Clients periodically register their IP/port (heartbeats) and resolve other services dynamically by service name.

Q13. What is a Circuit Breaker (Resilience4j) in microservices?

Foundation • 0-2 Yrs

A Circuit Breaker prevents cascading failures when a downstream service becomes unresponsive. States: Closed (normal traffic), Open (failure threshold breached, requests immediately fail-fast and invoke fallback methods), and Half-Open (trial requests test downstream recovery).

Q14. What is the difference between synchronous REST and asynchronous event-driven communication?

Foundation • 0-2 Yrs

Synchronous (REST/HTTP): Client sends request and blocks/waits for immediate response, tightly coupling service availability and increasing latency chains. Asynchronous (Kafka/RabbitMQ): Producer publishes event to a message broker and immediately continues; consumers process events independently, ensuring high decoupling and resilience.

Q15. What is Spring Profiles and how do you activate them?

Foundation • 0-2 Yrs

Spring Profiles allow segregating application configurations for different environments (dev, test, prod) via application-{profile}.properties. Activate via: spring.profiles.active=prod in application.properties or JVM argument -Dspring.profiles.active=prod.

Q16. Explain the Saga Pattern for handling distributed transactions across microservices.

Experienced • 3-5+ Yrs

Because distributed 2PC introduces high latency, the Saga pattern organizes transactions as a series of local transactions. Each service updates its local database and publishes an event. If a step fails, the Saga executes compensating transactions in reverse order. Sagas are Choreography-based (event-driven) or Orchestration-based (central coordinator service).

Q17. What is the Outbox Pattern and how does it guarantee Dual-Write consistency?

Experienced • 3-5+ Yrs

When a service must update its database AND publish an event to Kafka, network failures can cause partial success (data inconsistency). The Outbox pattern writes the event into an 'outbox' database table within the same local database transaction. A separate tool (Debezium via CDC) reads the outbox table and reliably pushes events to Kafka.

Q18. How does Spring Cloud Gateway route traffic and implement Rate Limiting?

Experienced • 3-5+ Yrs

Spring Cloud Gateway uses Project Reactor (non-blocking). It routes requests matching Route Predicates (path, header) through a chain of GatewayFilters. Rate limiting is implemented using Redis and the Token Bucket algorithm (RequestRateLimiter filter).

Q19. Explain the CQRS (Command Query Responsibility Segregation) design pattern.

Experienced • 3-5+ Yrs

CQRS separates read and write operations into distinct models. Commands (Write: Create, Update, Delete) are optimized for transactional integrity and business validation. Queries (Read) are optimized for fast, denormalized read-heavy searches (e.g., querying Elasticsearch or a read replica updated via event sourcing).

Q20. How do you implement Distributed Tracing using OpenTelemetry and Zipkin/Jaeger?

Experienced • 3-5+ Yrs

In distributed architectures, a user request spans multiple microservices. Spring Boot 3 Micrometer Tracing injects a unique TraceID (identifies entire request journey) and SpanID (identifies specific service hops) into HTTP headers, exported to Zipkin/Jaeger for latency visualization.

Q21. How do you handle Deadlocks and race conditions in high-throughput microservices?

Experienced • 3-5+ Yrs

1. Use Optimistic Locking (@Version in JPA) for low contention, detecting concurrent writes and throwing OptimisticLockException; 2. Use Distributed Locks (Redisson on Redis) for strict coordination across container instances; 3. Use partitioned Kafka topics for ordered single-consumer processing.

Q22. Explain Kafka Architecture: Topics, Partitions, Consumer Groups, and Offsets.

Experienced • 3-5+ Yrs

A Topic is a category of messages split into Partitions for parallel processing. Messages within a partition are strictly ordered by sequential Offset. A Consumer Group consists of multiple consumers; each partition is consumed by exactly one consumer within the group, enabling horizontal scalability.

Q23. What is idempotent consumer design and why is it mandatory with Kafka?

Experienced • 3-5+ Yrs

Kafka guarantees at-least-once delivery by default, meaning network glitches can cause duplicate messages. An idempotent consumer tracks processed message IDs (or transaction IDs) in a database table or cache, skipping execution if an event was already processed.

Q24. How do you configure Spring Security 6 with JWT for Stateless Authentication?

Experienced • 3-5+ Yrs

Disable session creation (SessionCreationPolicy.STATELESS), disable CSRF (stateless APIs), configure SecurityFilterChain bean with authorizeHttpRequests rules, and add a custom OncePerRequestFilter before UsernamePasswordAuthenticationFilter to extract, validate JWT claims, and populate SecurityContextHolder.

Q25. Explain Database per Service pattern and how to handle cross-service queries.

Experienced • 3-5+ Yrs

Each microservice exclusively owns its private database (loose coupling). Cross-service joins cannot use SQL JOINs; handle via: 1. API Composition (aggregator service calls both services); 2. CQRS (materialize combined read views via events); 3. Data replication via Kafka CDC.

Q26. What is Backpressure in Reactive Programming (Spring WebFlux)?

Experienced • 3-5+ Yrs

In reactive streams (Project Reactor), Backpressure is the feedback mechanism allowing a slow consumer to communicate with a fast producer, specifying how many items it is ready to handle (request(n)), preventing consumer buffer overflow and OutOfMemory errors.

Q27. How do you handle Zero-Downtime database schema migrations in microservices?

Experienced • 3-5+ Yrs

Use automated tools (Flyway, Liquibase) following Expand-and-Contract (Parallel Run) pattern: 1. Expand: Add new column/table without deleting old; 2. Dual-write: App writes to both old and new; 3. Backfill: Migrate historical data; 4. Contract: Deprecate and drop old column in next release.

Q28. Explain the Bulkhead Pattern in microservices resilience.

Experienced • 3-5+ Yrs

Inspired by ship hulls, the Bulkhead pattern isolates resources (thread pools, CPU) allocated to different downstream service calls. If one downstream dependency fails or becomes slow, only its dedicated thread pool is exhausted, preventing the entire service from crashing.

Q29. What is gRPC and when should it be chosen over REST for microservice communication?

Experienced • 3-5+ Yrs

gRPC uses HTTP/2 multiplexing and binary serialization via Protocol Buffers (Protobuf). It offers 7-10x faster serialization and lower network bandwidth than JSON over HTTP/1.1, ideal for internal low-latency microservice-to-microservice communication.

Q30. How do you optimize JVM Garbage Collection for Spring Boot microservices on Kubernetes?

Experienced • 3-5+ Yrs

Use modern garbage collectors (G1GC or ZGC for sub-millisecond pauses), set JVM container awareness (-XX:+UseContainerSupport), configure explicit memory limits (-XX:MaxRAMPercentage=75.0), and analyze thread/heap dumps via JDK Flight Recorder.

Q31. Write a Spring Boot REST Controller with Bean Validation and Exception Handling.

Live Coding Challenge

A controller with @Valid, DTO, and global @ExceptionHandler.

@RestController
@RequestMapping("/api/v1/users")
public class UserController {
    @Autowired private UserService userService;

    @PostMapping
    public ResponseEntity<UserDTO> createUser(@Valid @RequestBody UserCreateRequest req) {
        return ResponseEntity.status(HttpStatus.CREATED).body(userService.saveUser(req));
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<Map<String, String>> handleValidation(MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getFieldErrors().forEach(e -> errors.put(e.getField(), e.getDefaultMessage()));
        return ResponseEntity.badRequest().body(errors);
    }
}

Q32. Write a Resilience4j CircuitBreaker implementation in Spring Boot.

Live Coding Challenge

Using @CircuitBreaker annotation with a fallback method.

@Service
public class PaymentService {
    @CircuitBreaker(name = "paymentGateway", fallbackMethod = "paymentFallback")
    public PaymentResponse processPayment(PaymentRequest req) {
        return externalPaymentClient.charge(req);
    }

    public PaymentResponse paymentFallback(PaymentRequest req, Throwable t) {
        return new PaymentResponse("FAILED_RETRY_LATER", "Payment provider is down: " + t.getMessage());
    }
}

Q33. Write a Spring Kafka Producer that publishes events with a correlation key.

Live Coding Challenge

Using KafkaTemplate with CompletableFuture callbacks.

@Service
public class OrderEventProducer {
    @Autowired private KafkaTemplate<String, OrderEvent> kafkaTemplate;

    public void publishOrderCreated(OrderEvent event) {
        kafkaTemplate.send("order-events", event.getOrderId(), event)
            .whenComplete((result, ex) -> {
                if (ex == null) System.out.println("Sent offset: " + result.getRecordMetadata().offset());
                else System.err.println("Failed to send: " + ex.getMessage());
            });
    }
}

Q34. Write a Spring Kafka Consumer with dead-letter queue (DLQ) retry configuration.

Live Coding Challenge

Using @KafkaListener and @RetryableTopic.

@Component
public class OrderConsumer {
    @RetryableTopic(
        attempts = "3",
        backoff = @Backoff(delay = 1000, multiplier = 2.0),
        dltStrategy = DltStrategy.FAIL_ON_ERROR
    )
    @KafkaListener(topics = "order-events", groupId = "inventory-group")
    public void consume(OrderEvent event) {
        System.out.println("Processing order: " + event.getOrderId());
    }

    @DltHandler
    public void handleDlt(OrderEvent event, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) {
        System.err.println("Moved to DLQ from topic: " + topic);
    }
}

Q35. Write a Spring Security 6 SecurityFilterChain configuration bean.

Live Coding Challenge

Configure stateless session and permit public auth endpoints.

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(csrf -> csrf.disable())
            .sessionManagement(sm -> sm.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**", "/actuator/health").permitAll()
                .anyRequest().authenticated()
            )
            .build();
    }
}

Q36. Write a JPA Repository demonstrating Optimistic Locking with @Version.

Live Coding Challenge

Entity with @Version field throwing OptimisticLockException on race condition.

@Entity
public class AccountBalance {
    @Id private Long accountId;
    private BigDecimal balance;
    @Version private Integer version;
    // getters and setters
}

Q37. Write a Spring Cloud Gateway route configuration in application.yml.

Live Coding Challenge

Route path /orders/** to orders-service registered on Eureka.

spring:
  cloud:
    gateway:
      routes:
      - id: order-service-route
        uri: lb://ORDER-SERVICE
        predicates:
        - Path=/api/orders/**
        filters:
        - StripPrefix=1

Q38. Write a Spring Data JPA specification for dynamic multi-criteria filtering.

Live Coding Challenge

Using Specification interface and CriteriaBuilder.

public class UserSpecs {
    public static Specification<User> hasStatus(String status) {
        return (root, query, cb) -> status == null ? null : cb.equal(root.get("status"), status);
    }
    public static Specification<User> nameContains(String name) {
        return (root, query, cb) -> name == null ? null : cb.like(cb.lower(root.get("name")), "%" + name.toLowerCase() + "%");
    }
}

Q39. Write a Spring custom validator annotation and validator implementation.

Live Coding Challenge

Annotation and ConstraintValidator validating valid phone number.

@Constraint(validatedBy = PhoneValidator.class)
@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface ValidPhone {
    String message() default "Invalid phone format";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

public class PhoneValidator implements ConstraintValidator<ValidPhone, String> {
    public boolean isValid(String val, ConstraintValidatorContext ctx) {
        return val != null && val.matches("^[0-9]{10}$");
    }
}

Q40. Write an asynchronous service method in Spring using @Async and CompletableFuture.

Live Coding Challenge

Enable @Async with a custom TaskExecutor.

@Service
public class ReportService {
    @Async
    public CompletableFuture<String> generatePdfReport(Long reportId) {
        // Simulate heavy generation
        return CompletableFuture.completedFuture("Report-" + reportId + ".pdf");
    }
}