Advanced Spring Boot for Interviews

Write reliable, environment-independent integration tests using modern Spring testing strategies and containerized infrastructure.

• @SpringBootTest vs slicing annotations — when to load the full context vs targeted slices

• @DataJpaTest for repository-layer tests without spinning up the full application context

• @WebMvcTest for controller-layer tests with mocked service dependencies

• Testcontainers — spinning up throwaway Postgres and Redis instances during the build cycle

• @DynamicPropertySource — injecting container-assigned dynamic ports into Spring environment

• Why hardcoding static ports for Testcontainers breaks builds on CI/CD servers

• Performance trade-offs — full integration tests vs slicing for build speed and coverage

Implement cross-cutting concerns cleanly and understand the proxy mechanisms that power Spring AOP under the hood.

• Cross-cutting concerns — implementing logging, security, and transactions without cluttering business logic

• @Around advice — intercepting method execution to add pre- and post-processing logic

• @Before and @AfterThrowing advice — executing logic before calls or on exception

• Pointcut expressions — writing precise expressions to target specific join points

• JDK Dynamic Proxies vs CGLIB — how Spring chooses a proxy mechanism and the differences

• Self-invocation bypass — why calling an @Async or @Cacheable method internally skips the proxy

• Fixing self-invocation — moving annotated methods to a separate Spring bean

Optimize application performance using strategic Redis caching and understand the pitfalls of cache misconfigurations in production.

• @Cacheable — caching method return values to reduce redundant computation and DB calls

• @CacheEvict — invalidating stale cache entries on data updates or deletions

• @CachePut — forcing cache updates without skipping method execution

• TTL and eviction policies — configuring Time-To-Live for cache entries in Redis

• RedisTemplate — fine-grained control over Redis data structures beyond simple caching

• Serialization requirement — why cached objects must implement Serializable to avoid runtime errors

• Cache strategy trade-offs — when caching improves latency vs when it introduces consistency risks

Design fault-tolerant, discoverable, and resilient distributed systems using Spring Cloud components and proven resilience patterns.

• Netflix Eureka — dynamic service registration and lookup for microservice discovery

• Spring Cloud Gateway — routing, filtering, and load-balancing requests across microservices

• Resilience4j @CircuitBreaker — preventing cascading failures when downstream services are unavailable

• Fallback mechanisms — returning default responses when a circuit is open instead of hanging

• Retry patterns — configuring retry logic for transient failures in distributed systems

• Missing fallback risk — how unprotected external service calls cause system-wide outages

• API Gateway custom filters — applying authentication, rate limiting, and logging at the gateway level

Build non-blocking background processing and reliable scheduled jobs using Spring's async and scheduling capabilities.

• @Async — offloading long-running tasks to background threads without blocking the caller

• Custom ThreadPoolTaskExecutor — configuring thread pool size, queue capacity, and rejection policy

• CompletableFuture return type — enabling callers to track async task results and handle exceptions

• Returning void from @Async — why fire-and-forget hides failures and when it is acceptable

• @Scheduled with cron expressions — scheduling tasks at precise calendar-based intervals

• fixedRate vs fixedDelay — understanding overlap risk and choosing the right mode for each use case

• Thread exhaustion risk — how overlapping fixedRate tasks with long execution times exhaust the pool

Deploy and integrate production-grade Spring Boot applications with core AWS services including S3, RDS, EC2, and CI/CD pipelines.

• Amazon S3 integration — storing and retrieving unstructured data using the AWS SDK

• Amazon RDS — connecting Spring Boot to managed relational databases with CloudWatch monitoring

• EC2 and ECS deployment — packaging Spring Boot JARs and deploying to cloud compute environments

• AWS CodePipeline — automating build and deployment pipelines for continuous delivery

• IAM Roles and Instance Profiles — the secure way to authenticate AWS SDK calls without hardcoded keys

• Hardcoding credentials risk — why storing AWS keys in application.properties is a critical security vulnerability

• Environment-based credential resolution — how the AWS SDK automatically detects credentials from the environment