Interviews 2026

--------------------------------------------------------------------------------------------------

Interviews 2026

--------------------------------------------------------------------------------------------------

Cognizant (CTS) - JUN 2026

Round 1 (1 hour, extended around 1.5 hours) :

Tell about class loaders (basic explanation is not enough)
What is immutable class?
How to make a class immutable?
Have you ever made class immutable for any purpose in your career journey ?
Before Records, How we used to make the class immutable ?
Tell about your any primary project that you worked in your previous company
What are the Java 8 features have you worked?
What is the purpose of Optional Classes? To prevent null pointer excEeption is the key purpose. For any other purpose have you used Optional Classes?
Tell the methods of Optional Classes
Difference between HashMap and ConcurrentHashMap?
Explain FailFast and FailSafe collections
What is Functional Interface? What if we don't use the annotation @FunctionalInterface?
Method overloading is runtime polymorphism or compile time polimorphism?
Method overriding is runtime polymorphism or compile time polimorphism?
Can you explain AutoClosable Interface
Do you know about Generics? Explain
Difference between CompletableFuture and Future ?
Explain Serializable class. Have you used anywhere?
What are the Spring annotations that you know?
Payment applications, security applications avoiding Lombok annotations @data. You know ?
Explain Spring Bean life cycle clearly? like predestroy, postconstructor
What is circular dependency and have can you solve circular dependency (in the context of Spring Boot application) ?
What is Dependency Injection?
You know about Lazy annotation ?
Explain Transactional annotation. (Basic explanation is not enough, expecting Propogation, Isolation)
When we get ClassDefNotFoundException? How to solve?
Some issue in production. We need to debug. How could you debug? Have you ever used any tool to debug? Which tool you used?
What is the job of JwtAuthenticationFilter?
What is SecurityFilterConfig?
Have you used any cache mechanisms? What annotation you used (enable cache annoation)?
Have you used any scheduler job? Can you explain EnableSchedulingAnnotation ?
Consider you have a method in your module. For that particular method only you need to calculate the time taken. How would you calculate ?
What is FlatMap?
Do you know stream with range to use in Java coding?

Java coding questions (Strictly use Java 8 features, else not accepted)

Find the number which is repeated the same number of times
Given List : [12,13,2,2,3,5,4,4,4,4], Can you guess the output?
Output {2,4}

Return the consecutive two numbers 2 peer. Output will be List<List>
Given list [1,2,4,5,7,8,9], Output {{1,2}, {4,5}, {7,8}, {8,9}}

Print non-repeating first character. Consider any String. your wish.

SQL question

Write the SELECT query for the following
"We have employee and department table and we need to find all the employees belonging to a dept having more than 20 employees"

--------------------------------------------------------------------------------------------------------
Wissen Technology - JUN 2026 (EXPECTED)

💳 Part 1: Payment Architecture & Domain Security (12 Questions)

Focus: Proving your resume's payment portfolio matches real production engineering.

Idempotency Execution: Walk me through the exact database table or Redis cache schema you used to implement an Idempotency Key mechanism. What happens if two identical requests arrive at the exact same millisecond?
504 Gateway Timeout Handling: If your microservice calls a payment gateway (like Razorpay/Stripe), the deduction happens on the user's card, but you receive a network timeout, how does your system reconcile the status without double-charging?
Webhook Security: How do you validate that an incoming payment success notification webhook is genuinely from the payment gateway and hasn't been intercepted or faked?
BigDecimal Scale & Rounding: Write down the exact syntax to initialize and add two monetary values using BigDecimal. Why is RoundingMode.HALF_EVEN (Banker's Rounding) preferred over HALF_UP in ledger applications?
Dual Ledger Consistency: In a wallet transfer, you must deduct money from Account A and credit Account B. If the database crashes exactly between the deduction and the credit, how does your application recover?
Tokenization: How are sensitive credit card details or bank account numbers stored and transmitted securely in your payment pipeline to maintain PCI-DSS compliance?
Reconciliation Batch Jobs: How do you design a nightly reconciliation job that matches your internal database transaction logs against the settlement CSV file provided by the clearing bank?
Handling Partial Refunds: If a transaction of ₹5,000 fails downstream but ₹2,000 was already captured, how does your system state-machine handle a state change from PENDING to PARTIALLY_REFUNDED?
API Rate Limiting: How do you prevent a malicious actor or a broken client script from spamming your /process-payment API endpoint and crashing your database connection pool?
Data Masking in Logs: How do you ensure that bank account numbers, CVVs, and user balances are automatically masked in your Logback/Log4j console outputs to prevent security audits from failing?
Encryption at Rest vs Motion: How did your project protect financial transaction data while traveling over the network (TLS/HTTPS) and while sitting inside your PostgreSQL/Oracle database?
SLA Breach Monitoring: If a payment transaction takes longer than 3 seconds to get a response from a bank, how does your system cleanly cut the connection and park it in a queue for asynchronous processing?

🧵 Part 2: High-Volume Concurrency & Thread-Safety (13 Questions)

Focus: Preventing balance corruption and system deadlocks under extreme transaction load.

Race Condition Prevention: Two immediate-payment threads try to withdraw ₹500 from an account with a balance of ₹600 at the exact same time. Show how you use JPA @Version (Optimistic Locking) to reject the second thread.
Pessimistic Row Locking: When would you explicitly choose a Pessimistic Lock (SELECT ... FOR UPDATE) over an Optimistic Lock for processing high-frequency ledger entries?
Deadlock Coding Logic: Write out the conceptual pseudocode to transfer money between two Account objects. How does sorting the account IDs before acquiring locks guarantee that a deadlock can never happen?
ConcurrentHashMap Striped Locking: Explain exactly how ConcurrentHashMap uses Compare-And-Swap (CAS) and bucket-level synchronized locks to allow 100 threads to write data simultaneously without blocking each other.
ThreadPool Tuning Formula: If your banking app processes I/O-heavy API calls to external payment gateways, what is the exact formula to calculate the optimal core and max pool size for your ExecutorService?
ThreadLocal Data Leaks: If you store a user's transaction session token inside a ThreadLocal variable and do not explicitly call .remove(), how does that pollute another user's request when the thread pool reuses that thread?
CompletableFuture Error Fallbacks: Write a code concept where you trigger 3 independent validation checks (Fraud check, Balance check, KYC check) in parallel. How do you handle it using .handle() if the Fraud check service times out?
Atomic Long Counters: For generating unique, sequential, non-database transaction tracking IDs inside a single JVM, why is AtomicLong or LongAdder safer than a standard long++ operation?
CopyOnWriteArrayList Use Case: Why is CopyOnWriteArrayList perfect for an in-memory cache of static bank branch routing codes, but completely disastrous for tracking a live stream of volatile transaction logs?
CountDownLatch Coordinating: How do you use a CountDownLatch to force a main settlement service to wait until exactly 5 separate regional payment processing threads finish their executions?
Synchronized Block vs ReentrantLock: Why is ReentrantLock vastly superior for complex banking workflows that require try-lock timeouts or fair-ordering thread allocation?
Volatile Keyword Limitation: Why does marking a private volatile boolean isServerRunning work perfectly for stopping an active payment consumer loop, but fails completely if used to synchronize a counter?
ForkJoinPool Overload: How do Java 8 parallel streams share the global common ForkJoinPool? What happens to your primary API performance if a heavy, slow report generation job chokes that common pool?

💻 Part 3: Live Screen-Share Java 8+ Coding Patterns (13 Questions)

Focus: Clean code, data structure mastery, and optimal time/space complexity calculations.

Transaction Grouping Stream: Given a list of Transaction objects, write a single clean Stream expression to group them by currencyType and sum up the total amount for each currency using Collectors.groupingBy.
Nested Payload Flattening: Given a nested payload structure where an Account object contains a List<Card>, and each Card contains a List<Transaction>, use flatMap to extract a single flat list of all transactions across all cards.
Top Merchant Filtering: Write a Java 8 Stream pipeline to find the Top 3 merchants based on the highest total transaction values from an incoming list of payment records.
Custom Immutable Key Mapping: Write a bulletproof immutable class named AccountKey containing a string accountNo and a mutable Date creation date. Ensure it can be safely used as a key in a HashMap.
Stream Performance Profiling: What is the performance difference between running .stream().filter().findFirst() versus .parallelStream().filter().findFirst() on an ordered transaction ledger array?
Avoiding NullPointerExceptions: Show your defensive coding standards. How do you use Optional inside a stream pipeline to process custom customer data mapping where some middle names or addresses might be null?
Custom Stream Collector: How would you write a custom implementation of a Collector to accumulate transaction strings into a specialized encrypted memory buffer?
Two-Sum Transaction Matching: Given an array of processing fee integers and a target total fee, write an optimized O(N) time-complexity algorithm using a HashSet to find the pair of indices that sum up to the target.
Sliding Window Ledger: Given a stream of continuous transaction amounts, write an optimized algorithm to find the maximum continuous sum of K consecutive transactions (Sliding Window pattern).
Merging Overlapping Intervals: Given an array of trading or settlement time blocks [[1,3],[2,6],[8,10]], write a Java method to merge all overlapping intervals into [[1,6],[8,10]].
String Frequency Count: Given a raw text string of payment metadata logs, count the frequency of every word and display the results sorted in descending order using pure Java 8 Streams.
Array Deduplication: Write an in-place, memory-optimized algorithm to remove duplicate merchant IDs from a pre-sorted primitive array without allocating any extra array memory (O(1) space complexity).
List to Map Collision Resolution: Convert a list of Employee objects into a Map<String, Double> (ID to Salary). If the list contains duplicate IDs, how do you provide a merge function inside Collectors.toMap to keep the higher salary?

🏛️ Part 4: Distributed Banking Systems & Frameworks (12 Questions)

Focus: System availability, transactional boundaries, and data consistency infrastructure.

Saga Orchestration vs Choreography: If a cross-border wire transfer involves 4 independent microservices (Debit, Forex, Anti-Money Laundering, Credit), how do you design a rolling back mechanism if the final Credit step fails?
Transactional Outbox Pattern: How do you guarantee that your Spring Boot application successfully updates the PostgreSQL account ledger and sends a message to Kafka atomically without using heavy distributed 2PC protocols?
Database Isolation Selection: Why do most high-scale payment gateways default their database isolation levels to Read Committed? What are the specific production risks of upgrading a database to Serializable under heavy load?
Spring @Transactional Self-Invocation Bug: Why does calling a @Transactional public void credit() method from inside a non-transactional method in the same service class completely fail to create a database transaction proxy?
Transaction Propagation Levels: What is the behavioral difference in a payment settlement execution if you mark a secondary logging service method with Propagation.REQUIRES_NEW versus Propagation.REQUIRED?
N+1 Query Resolution: You fetch 100 bank accounts from the database, and Hibernate triggers 100 extra queries to fetch the addresses for each account. Show the exact syntax to fix this using join fetch or @EntityGraph.
Resilience4j Circuit Breaker States: If a third-party bank authorization API starts timing out, walk me through how a circuit breaker moves from Closed to Open to Half-Open. How do you prevent it from blocking regular user organic traffic?
Kafka Partition Strategy: How do you choose a partition key for a payment-transactions Kafka topic to guarantee that all transactions belonging to a specific Account ID are processed strictly in chronological order?
Kafka Consumer Backpressure: If your database encounters connection pool exhaustion and your Kafka consumer cannot process incoming transaction events fast enough, how do you implement backpressure or scale the consumer group?
HikariCP Pool Starvation: Your production logs show Connection is not available, request timed out after 30000ms. What profiling tools and framework parameters would you check immediately to locate the leaked or slow connection?
Hibernate First vs Second-Level Cache: Why is relying on Hibernate's Second-Level Cache dangerous for a microservice cluster handling live, rapidly fluctuating financial transaction ledger records?
Centralized Configuration Drift: How do you update runtime interest rates or API credentials stored in a Spring Cloud Config server across 50 running microservice pods without restarting a single application container?

💻 Common Java 8 Stream Interview Problems [1]

At Wissen, you are frequently asked to solve algorithmic or data filtering tasks natively using the Stream API. Expect problems like: [1, 2]

Flattening a Complex/Nested Structure: Take an array containing mixed integers and nested arrays (e.g., {{1}, 2, {3, 4}}) and flatten it into a single-level stream.
- Key feature to use: Arrays.stream() combined with .flatMap(). [1, 2]
Grouping and Aggregations (Mock DB Tasks): Group a list of Employee or Product objects by a specific field (like category or department) and find the maximum or minimum value in each group.
- Key feature to use: Collectors.groupingBy() paired with Collectors.maxBy() or Collectors.summarizingInt(). [1, 2]
String / Character Frequency Counting: Given a string, count the frequency of each character or find the first non-repeating character using functional syntax.
- Key feature to use: Arrays.stream(s.split("")) with Collectors.groupingBy(Function.identity(), Collectors.counting()). [1, 2]
Filtering and Transforming Data: Given a list of financial transactions or loans, filter out specific statuses and map them to a targeted output list.
- Key feature to use: .filter(), .map(), and .collect(Collectors.toList()). [1, 2]

_____________________________________________________________________

ACCENTURE ROUND 1 - JUN 2026 (EXPECTED)

1. Java 8+ Streams & Collections (12 Questions)

Focus: How engines process data efficiently under the hood.

Streams Performance: How does a .parallelStream() decide thread allocation? What are the risks of using it in a high-traffic Spring Boot application?
Short-Circuiting: Explain how findFirst() vs findAny() behaves in a parallel stream.
Custom Collectors: How do you implement a custom Collector to group a list of objects into a specialized map structure?
Intermediate vs Terminal: Explain lazy evaluation in Streams. How does the JVM optimize pipeline execution?
FlatMap vs Map: When would you choose flatMap over map in a real-world nested JSON payload transformation?
HashMap Internals: Explain the structural change in Java 8 when a bucket encounters high collision (Linked List to Balanced Tree conversion threshold).
ConcurrentHashMap: How does ConcurrentHashMap achieve thread safety without locking the entire map? Contrast it with Collections.synchronizedMap().
Fail-Fast vs Fail-Safe: Differentiate between ArrayList and CopyOnWriteArrayList iterators under concurrent modification.
Identity vs Equality: Why must you override hashCode() alongside equals() when using custom objects as keys in a HashSet?
Memory Footprint: What happens to the underlying memory structure when you create millions of tiny, short-lived String objects inside a Stream loop?
Optional Anti-patterns: What are the performance and clean-code downsides of using Optional.get() or passing Optional as method parameters?
Method References: How do method references (Class::method) work dynamically under the hood compared to standard lambda expressions?

2. Multi-threading, Concurrency & JVM Internals (13 Questions)

Focus: High-concurrency operations and memory management.

Thread Pool Tuning: How do you compute the optimal number of threads for an ExecutorService handling I/O-bound tasks vs CPU-bound tasks?
Thread Starvation: How do you detect and resolve thread starvation or deadlocks in a production environment?
CompletableFuture: How do you chain asynchronous tasks where Task B depends on the output of Task A, and handle failures gracefully?
Volatile Keyword: When does volatile suffice for thread safety, and why is it insufficient for atomic operations like counter increments?
Atomic Variables: How do AtomicInteger or LongAdder work using Compare-And-Swap (CAS) instructions without native OS synchronization locks?
Synchronized vs ReentrantLock: What advantages does ReentrantLock offer over a standard synchronized block for complex concurrent code?
ThreadLocal Risks: Why can using ThreadLocal cause severe memory leaks in an application server running a managed thread pool?
Garbage Collection (G1/ZGC): How do modern garbage collectors minimize stop-the-world (STW) pauses? How do you choose between G1GC and ZGC?
Out Of Memory (OOM): Walk me through your step-by-step approach to diagnosing and fixing a java.lang.OutOfMemoryError: Java heap space using a heap dump.
Metaspace Tuning: What causes a java.lang.OutOfMemoryError: Metaspace? How is it different from PermGen memory?
CPU Spike: If your production server hits 100% CPU usage, how do you map OS-level thread IDs to a Java thread dump to isolate the culprit?
CountDownLatch vs CyclicBarrier: What are the architectural differences, and when would you use one over the other to coordinate parallel jobs?
ForkJoinPool: Explain how the work-stealing algorithm works within the common ForkJoinPool.

3. Spring Boot, Data & Hibernate/JPA (13 Questions)

Focus: Enterprise framework internals and database bottlenecks.

Bean Lifecycle: Walk through how Spring instantiates, configures, and destroys a prototype-scoped bean vs a singleton bean.
Circular Dependency: How does Spring resolve circular dependencies between two singleton beans using its three-stage cache mechanism?
Transactional Rollback: Why does a @Transactional annotation fail to roll back changes when a method calls another transaction-marked method within the same class?
Transaction Propagation: Explain the behavioral difference between REQUIRED and REQUIRES_NEW propagation levels.
N+1 Select Problem: What is the N+1 query issue in Hibernate/JPA, and how do you resolve it using join fetch or @EntityGraph?
Hibernate Caching: Differentiate between First-Level Cache and Second-Level Cache. What are the pitfalls of caching highly dynamic transactional data?
Connection Pool Starvation: What symptoms indicate your HikariCP connection pool is exhausted, and how do you fix it?
Spring Boot Autoconfiguration: How does @EnableAutoConfiguration work using spring.factories or conditional annotations (@ConditionalOnClass)?
Dirty Reads vs Non-Repeatable Reads: Explain how database isolation levels (Read Committed vs Repeatable Read) map to Spring transaction isolation settings.
Optimistic vs Pessimistic Locking: When would you use a version column (@Version) over an explicit row-level database lock for concurrent entity updates?
Filter vs Interceptor: What is the architectural difference between a Servlet Filter and a Spring MVC HandlerInterceptor?
Async Context: How does @Async behave under the hood? What happens if you do not declare a custom task executor configuration?
Lazy Initialization Exceptions: What causes a LazyInitializationException outside of a Hibernate session, and how do you cleanly structure your DTO layer to prevent it?

4. Microservices, Design Patterns & Architecture (12 Questions)

Focus: Level 8 system-level thinking and microservices infrastructure.

Circuit Breaker States: Explain the Closed, Open, and Half-Open states of a Resiliance4j circuit breaker. How do you tune its failure rate threshold?
Distributed Transactions: Since 2PC (Two-Phase Commit) reduces performance, how do you handle eventual consistency across microservices using the Saga Pattern?
Idempotent APIs: How do you guarantee that an API endpoint processing payments is strictly idempotent if a client retries a failed network request?
CQRS Pattern: When does it make sense to decouple your application's write database from its read database? What are the synchronization challenges?
API Gateway Roles: What infrastructural responsibilities belong to the API Gateway vs individual underlying microservices (e.g., rate limiting, authentication)?
Distributed Tracing: How do you track a single user request across 10 different microservices using tools like OpenTelemetry, Zipkin, or Sleuth?
Event-Driven Backpressure: If your Kafka/RabbitMQ consumer cannot process messages as fast as they arrive, how do you scale consumers or implement backpressure?
Kafka Partitions: How do Kafka partition counts affect your consumer group scalability? What happens if consumer count exceeds partition count?
Outbox Pattern: How do you guarantee that a database update and a corresponding event message publication both succeed atomically without using 2PC?
Solid Principles: Give a practical code example of where you applied the Dependency Inversion or Interface Segregation principle to simplify a system.
Factory vs Abstract Factory: When should you transition a design from a simple Factory pattern to an Abstract Factory architecture?
Centralized Config Drift: In a distributed system using Spring Cloud Config, how do you update properties across microservice clusters at runtime without restarting application pods?

1. Java 8 Stream API & Data Transformations (Crucial for Level 8)

Accenture heavily tests your ability to manipulate data structures cleanly without using legacy for loops.

Group and Aggregate Data: Given a list of Employee objects (with fields: id, name, department, salary), write a stream pipeline to find the highest-paid employee in each department.
Frequency Count: Given a string or a list of words, find the frequency of each character/word, and filter out the top 3 most frequent elements using Streams.
Flattening Nested Collections: Given a list of Order objects, where each order contains a list of Item objects, extract a distinct, sorted list of all item names across all orders using flatMap.
Partitioning Data: Given a list of transactions, partition them into two groups (e.g., transactions above ₹50,000 and below) and calculate the average transaction amount for each group simultaneously.
Custom String Joining: Given a list of strings, filter out empty strings, convert them to uppercase, and join them with a comma separator enclosed in square brackets [A, B, C].

2. Concurrency & Multi-threading Coding Tasks

As a Senior Developer, you must know how to execute tasks safely across multiple threads.

Producer-Consumer Implementation: Implement a classic Producer-Consumer runtime solution using a BlockingQueue where multiple producer threads generate data and a single consumer processes it.
CompletableFuture Orchestration: Write a method that calls three independent asynchronous external APIs simultaneously. Combine their results into a single consolidated response, and ensure that if one API fails, a fallback default response is used.
Thread-Safe Singleton/Cache: Write a bulletproof, thread-safe, lazy-initialized Singleton pattern (using Double-Checked Locking) or a simple in-memory cache utilizing ConcurrentHashMap.

3. Core Array, String & Collection Logic

Standard logical questions to check your foundational data structure proficiency.

Two-Sum Variant: Given an array of integers and a target sum, find all unique pairs of numbers that add up to that target. (Optimize for O(N) time complexity using a HashSet).
Subarray with Given Sum: Find a continuous subarray that adds up to a specified sum S. (Optimize using the Sliding Window technique).
Merge Overlapping Intervals: Given a collection of intervals (e.g., [1,3], [2,6], [8,10]), merge all overlapping intervals to output [1,6], [8,10]. (Tests sorting and custom collection logic).
Longest Substring Without Repeating Characters: Find the length of the longest substring in a given string without any duplicate characters.

4. Database-Aligned / SQL Coding Scenarios

Sometimes the interviewer will paste a table schema into the chat and ask you to write a clean SQL query.

Nth Highest Salary: Write a robust SQL query (and its equivalent Spring Data JPA method name/query) to find the 3rd highest salary from an Employee table without using hardcoded limits.
Duplicate Detection: Write an SQL query to identify duplicate rows in a table based on specific columns (e.g., email) and delete the older duplicate entries keeping only the latest one.
Complex Joins & Aggregations: Given an Orders table and a Customers table, find the names of customers who have placed more than 5 orders in the last 30 days along with their total spend.

_____________________________________________________________________

KPMG - JUN 2026 (EXPECTED)

1. Java 8+ & Concurrency (Advanced) [1]

Virtual Threads (Java 19/21): How do Virtual Threads differ from platform threads? How do they improve throughput for I/O-bound Spring Boot applications?
CompletableFuture: How would you orchestrate three asynchronous microservice calls where the third call depends on the combined results of the first two?
Garbage Collection: If a system experiences high latency due to long "Stop-the-World" pauses, how would you diagnose it? Explain the difference between G1GC and ZGC.
Concurrent Collections: How does ConcurrentHashMap achieve thread safety without locking the entire map? Compare its internal mechanics to Hashtable. [1, 2, 3]

2. Spring Boot & Microservices Architecture [1, 2]

Spring Boot Internals: Explain the lifecycle of a Spring Bean. How does @SpringBootApplication use auto-configuration underneath? [1]
Saga Pattern vs. 2PC: How do you handle distributed transactions across three independent microservices (e.g., Order, Inventory, Payment)?
Resilience & Fault Tolerance: How do you implement a Circuit Breaker using Resilience4j? What happens to incoming requests when the circuit transitions to an "Open" state?
CQS / CQRS: When and why would you split your read and write models in a high-traffic system?

3. Database, Kafka, and Cloud

Kafka Exactly-Once Semantics (EOS): How do you configure a Kafka producer and consumer to guarantee exactly-once processing?
JPA/Hibernate N+1 Problem: What causes the N+1 select problem? What are the three best ways to resolve it in a production Spring Boot app?
Database Sharding vs. Partitioning: At 9+ years of experience, how do you decide between horizontal database sharding and vertical partitioning for scaling relational data?

_____________________________________________________________________

4. Core Coding Questions (Be ready to share screen) [1]

You will likely be asked to code either in an IDE or a notepad tool. Here are the top three patterns KPMG interviewers use for senior roles:

Question 1: Java Stream API & Complex Grouping

Problem: Given a list of Employee objects with fields id, name, department, and salary, write a single Java Stream pipeline to find the top-earning employee in each department.

java

import java.util.*;
import java.util.stream.Collectors;

public class Main {
    static class Employee {
        String name;
        String department;
        double salary;
        // Constructor, Getters
        public Employee(String name, String department, double salary) {
            this.name = name; this.department = department; this.salary = salary;
        }
        public String getDepartment() { return department; }
        public double getSalary() { return salary; }
        public String toString() { return name + " (" + salary + ")"; }
    }

    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("Alice", "IT", 90000),
            new Employee("Bob", "IT", 110000),
            new Employee("Charlie", "HR", 70000),
            new Employee("David", "HR", 85000)
        );

        Map<String, Optional<Employee>> topByDept = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::getDepartment,
                Collectors.maxBy(Comparator.comparingDouble(Employee::getSalary))
            ));

        topByDept.forEach((dept, emp) -> System.out.println(dept + " : " + emp.orElse(null)));
    }
}

Question 2: Thread-Safe Singleton (Double-Checked Locking) [1]

Problem: Write a bulletproof, thread-safe Implementation of the Singleton Pattern using double-checked locking. Explain why the volatile keyword is mandatory here.

java

public class DatabaseConnectionManager {
    // The volatile keyword prevents instruction reordering issues
    private static volatile DatabaseConnectionManager instance;

    private DatabaseConnectionManager() {
        // Prevent reflection instantiation
        if (instance != null) {
            throw new IllegalStateException("Already initialized");
        }
    }

    public static DatabaseConnectionManager getInstance() {
        if (instance == null) { // First check (no locking)
            synchronized (DatabaseConnectionManager.class) {
                if (instance == null) { // Second check (with locking)
                    instance = new DatabaseConnectionManager();
                }
            }
        }
        return instance;
    }
}

Question 3: Sliding Window Pattern (LeetCode Medium) [1]

Problem: Given an array of integers and a number k, find the maximum sum of any contiguous subarray of size k. (Optimized to O(n) time complexity).

java

public class SlidingWindow {
    public static int findMaxSumSubarray(int[] arr, int k) {
        if (arr == null || arr.length < k || k <= 0) return 0;

        int windowSum = 0;
        int maxSum = 0;

        // Sum of the first window
        for (int i = 0; i < k; i++) {
            windowSum += arr[i];
        }
        maxSum = windowSum;

        // Slide the window across the array
        for (int i = k; i < arr.length; i++) {
            windowSum += arr[i] - arr[i - k]; // Add next element, drop first
            maxSum = Math.max(maxSum, windowSum);
        }

        return maxSum;
    }
}

_____________________________________________________________________

ACCENTURE ROUND 1- JUN 2026 (ASKED)

=> Interviewer asked only verbal questions (almost all are covered in the expected list)

=> No coding questions

_____________________________________________________________________

IBS SOFTWARE ROUND 1- JUN 2026 (ASKED)

Merge Overlapping Intervals: Given a collection of intervals (e.g., [1,3], [2,6], [8,10]), merge all overlapping intervals to output [1,6], [8,10]. (Tests sorting and custom collection logic).

_____________________________________________________________________

WIPRO AI ROUND 1- JUN 2026 (ASKED)

=> Verbal questions (Almost covered in the Accenture expected list)

=> Coding Question 1 :

You are given a list of Author objects, where each author has a list of Book objects. You need to print the name of the author who has the highest total number of sold book copies.

NOTE : Class structures for the Author, Book are not given in the AI platform. It was just with main class { public static void main(String[] args){}}

=> Coding Question 2 :

Given one product details. Asked to write product description (to test marketing skills)

_____________________________________________________________________

LTIMindtree ROUND 1- JUN 2026 (EXPECTED)

🧱 Architectural & Microservices Design (High Weightage)

Expect deep-dive scenarios regarding the design choices you make in your current project. [1]

Handling Traffic Spikes: If your Spring Boot service experiences a sudden spike from 1,500 concurrent users to 15,000, what immediate infrastructure and application-level adjustments will you implement? [1]
Distributed Transactions: How do you implement the Saga Pattern (Orchestration vs. Choreography) to maintain data consistency across microservices? [1, 2]
Microservices Failure: If a downstream service is down or slow, how do you handle it using the Circuit Breaker pattern? Detail your experience with resilience tools like Resilience4j. [1, 2]
Observability & Diagnostics: A production API is microservices-based, and a specific user request is failing intermittently. How do you trace this bug end-to-end? (Expect questions on Distributed Tracing via OpenTelemetry, Zipkin, or ELK stacks). [1, 2]

☕ Core Java, Concurrency & Performance

With 9+ years of experience, you must demonstrate mastery over JVM internals and performance engineering. [1]

Virtual Threads vs Platform Threads: With modern Java versions being standard, how do Virtual Threads (Project Loom) change how you handle concurrent execution compared to a standard ExecutorService?
Custom Data Structure & Concurrency: Implement or explain a thread-safe, high-performance LRU Cache using Java's built-in collections.
HashMap Internals under Stress: What is the Big O notation of a HashMap search operation when multiple keys have the same hashcode? How did Java 8 change the worst-case scenario from O(n) to \(O(\log n)\)?
Fork-Join Framework: Explain how the Fork-Join framework works in multi-threading and when you would prefer it over a normal thread pool. [1, 2, 3, 4]

🍃 Spring Boot & Database Optimization

Database Lazy Loading & N+1 Problem: How do you resolve the N+1 fetch problem in Spring Data JPA when dealing with complex entity mappings? Explain the trade-offs of using EntityGraph versus Join Fetches.
Removing Embedded Dependencies: How do you remove the default Tomcat server dependency from spring-boot-starter-web and switch it to Undertow or Jetty for high-performance requirements?
API Security: How do you design and configure role-based access control (RBAC) securely across decoupled microservices using Spring Security and centralized OAuth2 / JWT tokens? [1, 2, 3, 4]

📊 SQL & Complex Database Management

Indexing Strategy: Explain the difference between Clustered and Non-Clustered indexes. How do you determine if an index is actually being utilized by a slow query? [1]
Advanced Querying: Write an optimal SQL query to find the nth highest salary or the latest updated record per employee partition without using built-in rank functions. [1, 2]

💻 Expected Coding & Stream API Questions

LTIMindtree frequently uses Stream API and manipulation problems to assess your hands-on coding agility. You may be asked to share your screen or write logic in a compiler: [1, 2]

Grouping & Counting: Given a string, use Java 8 streams to find all duplicate characters along with their counts, ensuring spaces are treated as valid characters.
Binary Grouping: Take a number in binary form and count the groups of isolated 0s individually before a 1 appears (e.g., Input: 0011000 → Output: groups of size 2 and 3).
Data Aggregation: Given a collection of complex Employee or Transaction objects, use Streams to sort them dynamically by department name first, and then by salary descending. [1, 2, 3, 4]

🛠️ Generative AI Tools in Development

LTIMindtree interviewers are explicitly asking senior candidates how they incorporate AI into their daily development workflows: [1, 2]

How do you leverage GenAI tools (like GitHub Copilot or Amazon Q) to accelerate code reviews, optimize legacy structures, or auto-generate robust JUnit/Mockito unit tests? [1]

_____________________________________________________________________

VVDN Technologies ROUND 1- JUN 2026 (EXPECTED)

🏛️ 1. Project Architecture & System Design

Expect the interviewer to spend the first 15 minutes challenging your current application's layout. [1]

High-Throughput IoT Ingestion: "VVDN handles millions of hardware events. How would you design a Java-based backend ingestion layer to process 50k events per second without dropping packets?"
State Management: "If your application communicates via persistent device connections (like MQTT or WebSockets), how do you maintain state and distribute the connection load across instances?" [1]
Design Patterns in Production: "Explain where you have actively implemented structural or behavioral design patterns (e.g., Strategy or Factory patterns) to solve a complex business requirement in your past project." [1]

☕ 2. Advanced Core Java, Concurrency & JVM Tuning [1]

At 9+ years of experience, standard definitions will not suffice. Prepare for scenario-based multi-threading questions. [1, 2, 3]

Mutex vs. Semaphore: "Explain the practical difference between a Mutex and a Semaphore. In what scenario would you use a CountDownLatch or a CyclicBarrier over standard locks?" [1]
Memory Management: "How do you diagnose a memory leak in a production Spring Boot application? Which tools (e.g., JProfiler, VisualVM) do you use to analyse heap dumps?" [1]
Garbage Collection (GC) Tuning: "Given a low-latency requirement, how do you tune the JVM? What are the architectural trade-offs between G1GC and ZGC (Z Garbage Collector)?" [1, 2]
Java 8 to 21+ Streams Optimization: "How does a parallel stream split tasks under the hood? Explain the internal working of the ForkJoinPool and how it can cause thread starvation if misconfigured." [1]

🍃 3. Spring Boot, Data & Microservices Architecture

Bean Resolution Disambiguation: "What is the functional difference between using @Primary and @Qualifier annotations when managing multiple implementations of an interface?"
Distributed Transactions: "How do you maintain data consistency across multiple microservices without using heavy two-phase commits (2PC)? Explain your experience with the Saga Pattern."
Database Deadlocks & Tuning: "How do you detect and resolve deadlocks in PostgreSQL/MySQL under heavy concurrent writes? Explain your strategy for database indexing and query optimization at scale."
Resilience Frameworks: "How do you configure a Circuit Breaker (e.g., Resilience4j) to prevent cascading failures? What thresholds dictate moving from a Closed to an Open state?" [1, 2, 3]

💻 4. Expected Round 1 Live Coding Challenges

You will likely be asked to write clean, production-grade code on a shared IDE. [1, 2]

Array/String Manipulation with Optimal Complexity: "Write a function to sort an array containing only 0s and 1s in linear time O(n) complexity and O(1) space using a two-pointer approach." [1, 2]
Custom Concurrent Utility: "Write a thread-safe, bounded Custom In-Memory Cache implementation from scratch using ConcurrentHashMap and explicit locks, ensuring it handles data eviction (like LRU)." [1, 2]
Stream API Task: "Given a complex list of transactions, write a Java Stream pipeline to filter, group by category, and calculate the average transaction amount for each category dynamically."

💡 VVDN-Specific Interview Tips

Focus on Telecom/IoT Patterns: VVDN builds a lot of embedded-adjacent software. Showcasing familiarity with networking protocols (like HTTP/2, gRPC, or WebSockets) gives you a massive advantage.
Emphasize Code Quality: Since they assess senior folks on mentoring capability, explicitly mention your code review process, testing frameworks (Mockito, WireMock), and CI/CD pipelines. [1, 2, 3, 4, 5]

ACCORDING TO JD

☁️ 1. The Cloud Translation Guide (How to answer Azure questions)

When they ask about an Azure tool, translate it to its traditional VM/On-Premise equivalent. Use this script: "While my previous projects ran on-premise VMs, the architectural patterns are identical. For instance..."

Azure App Service → Tomcat / JBoss on a Linux VM
- What to say: "I deploy Spring Boot applications as self-contained executable JARs or on web servers like Tomcat inside VMs. On Azure, this maps directly to App Service."
Azure Service Bus / Event Hub → Kafka / RabbitMQ / ActiveMQ
- What to say: "I have extensive experience with asynchronous messaging using tools like RabbitMQ/Kafka for event-driven designs. Azure Service Bus and Event Hub serve the exact same purpose for message queuing and data ingestion."
Azure Key Vault → HashiCorp Vault / Property Encryption
- What to say: "To secure secrets on VMs, we used externalized configuration management (like HashiCorp Vault or encrypted properties files). I understand Key Vault is Azure's native way to handle this securely." [1]
Azure APIM (API Management) → NGINX / Zuul Gateway
- What to say: "We handled API routing, rate-limiting, and SSL termination using NGINX/Reverse Proxies at the VM level, which is what Azure APIM automates."

🔋 2. The BMS Cheat Sheet (What it means for a Java Dev)

BMS stands for Battery Management System. Think of it as thousands of hardware devices (like EV batteries or solar storage) constantly shouting their health data to your server.

As a Java Backend Developer, you do not need to know chemical battery engineering. You only need to know how to handle the data:

The Challenge: Devices send data nonstop (e.g., voltage, temperature, current every second). A relational database (MySQL/Oracle) will crash under this write load.
The Solution: You process these incoming streams asynchronously using a message broker (like Kafka) and dump them into a Time-Series Database (like InfluxDB). Time-series databases are specifically optimized for appending massive amounts of timestamped data sequentially.

🛡️ 3. Play to Your Strengths: The 3 PM Strategy

Shift the spotlight to what you are an expert in:

Java & Spring Boot Depth: Emphasize that cloud platforms are just infrastructure wrappers. Your core strength is writing optimized, multi-threaded Java code, tuning the JVM, and preventing memory leaks on any infrastructure (VM or Cloud).
PR Reviews & Mentorship: Emphasize your ability to review Angular/Java code for clean boundaries, separating concerns, and preventing developers from writing tightly coupled code.
Pragmatic Problem Solving: Frame yourself as someone who delivers stable software on physical servers where resource management is often stricter than the cloud.

_____________________________________________________________________

ACCENTURE/COGNIZANT/LTIMindtree/VVDN/INFOSYS ROUND 2- JUN 2026

(EXPECTED)

🏛️ Section 1: Monolith-to-Microservices & Migration Strategy

The Migration Blueprint: How do you systematically break down a legacy monolithic application into microservices using Domain-Driven Design (DDD) bounded contexts without causing system downtime?
The Strangler Fig Pattern: How do you route traffic incrementally from an old monolith to newly built Java microservices using an API Gateway?
The Shared Database Anti-Pattern: Why is a shared database across microservices considered a critical failure in architecture, and how do you execute a Database-per-Service migration?
Distributed Configuration Management: How do you manage centralized, environment-specific properties across 50+ microservice instances using Spring Cloud Config Server without requiring application restarts?
Service Discovery & Registry Routing: How do microservices dynamically locate, register, and route to each other using Netflix Eureka or Consul in an auto-scaling cloud environment?

🔄 Section 2: Data Integrity, Distributed Transactions & Event-Driven Design

The Saga Pattern for Data Consistency: How do you maintain transactional data consistency across multiple independent services (e.g., Order, Inventory, Payment) when a downstream service fails mid-way?
Orchestration vs. Choreography Sagas: What are the exact structural trade-offs between a centralized Orchestrator Saga and an event-driven Choreography Saga?
Compensating Transactions Design: How do you write reliable rollback/compensating actions to undo changes in previous databases when a final step (like payment) gets rejected?
Two-Phase Commit (2PC) Failure: Why do senior architects reject Two-Phase Commits (2PC) for scaling enterprise microservices, and how does Eventual Consistency solve this?
The CQRS Pattern: How do you implement Command Query Responsibility Segregation (CQRS) to separate high-frequency write operations from read-heavy user queries?
Asynchronous Data Syncing in CQRS: How do you keep your read-optimized database and write-heavy relational database synchronized asynchronously using Kafka or RabbitMQ?

🛡️ Section 3: System Fault Tolerance, Resilience & Gateways

The Circuit Breaker Pattern: What core problem does a Circuit Breaker solve, and how does it prevent a slow downstream service from causing thread starvation in your main calling service?
Resilience4j State Transitions: How do you configure a circuit breaker to move from Closed to Open (Failing Fast) and then to Half-Open using failure-rate and slow-call thresholds?
Graceful Fallback Logic: How do you design bulletproof fallback methods in Spring Boot to handle user requests gracefully when a circuit breaker trips open?
The Bulkhead Pattern: How do you isolate resource pools (dedicated thread counts or memory allocations) for different APIs so that a failure in one feature doesn't crash the entire application container?
API Gateway Architecture & Rate Limiting: How do you configure an API Gateway (like Spring Cloud Gateway) to handle centralized OAuth2/JWT token validation, dynamic routing, and token-bucket rate limiting?
Strict API Idempotency: How do you enforce strict API idempotency using unique request keys and a distributed cache like Redis to guarantee a financial transaction is never processed twice?

🧵 Section 4: Low-Level Design (LLD), Object-Oriented Design & GoF Patterns

The Parking Lot Design (LLD): Walk through the class structure of a Parking Lot. How do you design it using the Strategy Pattern for spot assignment, and how do you ensure the spot allocation is strictly thread-safe?
Movie Ticket Booking (BookMyShow LLD): How do you handle a 10-minute temporary seat hold while a user completes a payment? How do you implement this in code using a State Pattern or Redis TTL to automatically release seats if payment fails?
The ATM System Design (LLD): How does an ATM machine decide exactly how many currency notes of different denominations to dispense? Explain how to implement this using the Chain of Responsibility Pattern.
Notification Engine Design (LLD): How do you design an enterprise alerting engine that sends Email, SMS, and Push notifications using the Observer Pattern or an asynchronous event bus?
SOLID Principles in Production: Give a real-world example of how you have actively refactored tightly-coupled, legacy Java code to adhere to the Single Responsibility Principle (SRP) and Dependency Inversion Principle (DIP).

⚡ Section 5: Concurrency, Multithreading & Database Performance

Concurrent Data Updates (Race Conditions): Two users attempt to deduct money from the exact same account balance or book the same seat at the exact same millisecond. How do you prevent data corruption?
Optimistic vs. Pessimistic Locking: What are the exact production performance trade-offs of using Optimistic Locking (@Version in Hibernate) versus Pessimistic Locking (SELECT ... FOR UPDATE) in high-traffic database engines?
Database Deadlock Resolution: How do you isolate, analyze slow query logs, and permanently fix a DeadlockExpiredException occurring in a high-frequency relational database?
Connection Pool Optimization: How do you tune HikariCP configurations (max pool size, connection timeouts) to prevent connection leaks and application freezing under heavy concurrent write loads?
Custom Thread Pools Management: How do you safely configure dedicated, bounded ThreadPoolTaskExecutor beans for async processing to ensure you don't starve the JVM's main worker threads?

☁️ Section 6: Cloud-Native Architecture & Distributed Infrastructure

Horizontal vs. Vertical Scaling: How do you determine the auto-scaling rules (CPU/Memory thresholds) for horizontally scaling stateless container instances versus vertically upgrading cloud servers?
Zero-Trust Cloud Secret Management: How do you configure your cloud-deployed Spring Boot apps to fetch database passwords dynamically from Azure Key Vault or AWS Secrets Manager without storing secrets in git?
Serverless (Lambda/Functions) vs. Containers: What are the performance, cold-start latency, and cost trade-offs of using Serverless execution models versus long-running containerized Spring Boot apps?
High Availability & DR Failover: How do you design a multi-region deployment for a Java backend to handle real-time database replication lag during a critical disaster recovery (DR) switch?
Distributed Tracing (Sleuth/Zipkin): How do you track a single end-to-end user request as it travels across 5 different decoupled microservices using unique Trace IDs passed in HTTP headers?

🔎 Section 7: Code Governance, Pull Request Reviews & Troubleshooting

Catching Technical Debt in PR Reviews: As a Tech Lead, what specific anti-patterns (like leaky entities, circular dependencies, or running long REST calls inside a @Transactional block) cause you to reject a Pull Request?
Production CPU Spikes Debugging: If your containerized application suddenly hits 100% CPU utilization in production, what is your exact step-by-step diagnostic workflow using thread dumps?
Memory Leak Profiling (OOM): How do you analyze an .hprof heap dump using Eclipse MAT to isolate the exact cause of a slow, creeping java.lang.OutOfMemoryError crash?

☁️ Section 8: Cloud Infrastructure & Cloud-Native Java Architecture

Cloud Database Failover & Replication Lag: "When deploying a Spring Boot application across multiple cloud regions (e.g., Active-Passive deployment), how do you design your Java database layer to handle replication lag and prevent data loss during an automated cloud database failover?"
- The Answer: Explain that you use a multi-region deployment with synchronous replication for critical financial/ledger data, or asynchronous replication with a fallback queue (like Kafka) for non-critical data. In your Spring Boot app, configure read-heavy operations to route to local read-replicas, while write operations are explicitly directed to the primary database instance. [1, 2]
Cloud Auto-Scaling vs. JVM Memory Management: "Cloud platforms scale containers based on infrastructure metrics like CPU/Memory utilization. If your Spring Boot container’s JVM Heap size (-Xmx) is misconfigured relative to the Cloud Container Memory Limit (e.g., Docker/Kubernetes limits), what production issue occurs, and how do you resolve it?"
- The Answer: If the JVM heap allocation exceeds or approaches the container memory limit, the operating system/cloud host will instantly kill the process using an OOMKilled (Exit Code 137) error, before Java can even throw a java.lang.OutOfMemoryError. To resolve this, always ensure -Xmx is capped at roughly 70–80% of the total container memory allocation, leaving 20–30% for off-heap memory, thread stacks, and OS operations. [1]
Zero-Trust Cloud Identity Management: "How do you eliminate hardcoded cloud infrastructure credentials (like database passwords or AWS/Azure connection string access keys) from your Java code and configuration files using cloud-native security?"
- The Answer: You leverage Managed Identities (Azure) or IAM Roles for Service Accounts / IRSA (AWS). Instead of storing a connection string, you attach the cloud role directly to the virtual machine or container running your Java application. The Spring Boot application then uses the cloud SDK to automatically and transparently authenticate via temporary token generation at runtime.
Cloud Secret Manager Cache Optimization: "The JD highlights 'secret management.' If your Spring Boot microservices call a cloud secret manager (like Azure Key Vault or AWS Secrets Manager) every single time they need to decrypt an incoming payload or connect to a service, what infrastructure bottleneck occurs, and how do you fix it?"
- The Answer: Calling a cloud secret manager on every single API request causes network latency bottlenecks and can trigger severe API rate-limiting/throttling from the cloud provider. To resolve this, implement local application-level caching with an explicit TTL (e.g., caching secrets in memory for 1 hour) using tools like the Spring Cloud Starter for AWS/Azure Secrets Manager, so external network hits are minimized.
Serverless (Lambda/Functions) Cold Starts with Spring Boot: "When would you choose a Serverless execution model (like AWS Lambda or Azure Functions) over a standard containerized Spring Boot service for running business logic, and how do you handle the severe 'Cold Start' latency issue inherent to Java?"
- The Answer: Use Serverless for highly intermittent, unpredictable, short-lived tasks (e.g., a nightly batch file processing trigger, or webhooks that run for less than 5 minutes). Avoid running standard heavy Spring Boot architectures on Serverless for real-time user-facing APIs due to 5–10 second "cold start" dependency injection delays. To fix cold starts, look into GraalVM Native Image compilation or specific lightweight frameworks like Spring Cloud Function.

🔍 The Final 8-Section Verification

To give you absolute peace of mind, here is the exact structural verification of the topics we have locked down across your 40 questions:

System Migration & Architecture Boundaries (Questions 1–5): Encompasses Domain-Driven Design (DDD), Monolith-to-Microservices strategies, the Strangler Fig Pattern, and Shared Database anti-patterns.
Distributed Data Integrity & Messaging (Questions 6–11): Covers the Choreography and Orchestration Saga patterns, Compensating Transactions, eventual consistency over 2PC, CQRS implementation, and asynchronous data synchronization via Kafka/RabbitMQ.
Fault Tolerance & API Resilience (Questions 12–17): Includes Resilience4j Circuit Breaker state transitions, fallback logic, Bulkhead isolation, API Gateways, token-bucket rate limiting, and distributed cache-backed (Redis) strict transaction Idempotency. [1]
Low-Level Design (LLD) & Object-Oriented Design (Questions 18–22): Contains complete architectural class blueprints, SOLID principles application, and GoF patterns (Strategy, Factory, Chain of Responsibility, Observer) for systems like Parking Lot, BookMyShow, an ATM, and Notification Engines.
Concurrency, Threading & DB Tuning (Questions 23–27): Details concurrent update race conditions, Optimistic (@Version) vs. Pessimistic (FOR UPDATE) locking trade-offs, DeadlockExpiredException resolution, HikariCP database connection pool configuration, and bounded custom thread pool isolation.
Distributed Tracing & Monitoring (Questions 32–33): Tracks end-to-end request propagation across microservices boundaries using Trace/Span IDs via Micrometer/Sleuth and Zipkin/Jaeger.
Code Governance & Deep Production Debugging (Questions 34–35): Diagnoses 100% production CPU spikes via jstack Thread Dumps and isolates creeping memory leaks (OutOfMemoryError) using Eclipse MAT on .hprof Heap Dumps.
Cloud-Native Java Architecture (Questions 28–31, 36–40): Solves multi-region replication lag, container memory allocation conflicts vs. JVM sizing (OOMKilled Exit Code 137), Zero-Trust Managed Identities/IAM, Cloud Secret Manager throttling/caching optimization, and Serverless (Lambda) Java cold-start mitigation via GraalVM native images.

_____________________________________________________________________

LTIMindtree ROUND 2 (30 minutes round) - JUN 2026

(EXPECTED)

🏛️ Microservices, Data Integrity & System Boundaries

Distributed Transactions (Saga Pattern): "When you split a monolith into a database-per-service architecture, how do you handle a transaction spanning multiple services (e.g., Order, Inventory, Payment) when a downstream service fails midway?"
CQRS & Data Syncing: "How do you implement the Command Query Responsibility Segregation (CQRS) pattern to separate high-frequency writes from heavy reads, and how do you handle asynchronous data sync between them using Kafka?"
Monolith to Microservices Evolution: "As a senior engineer, what criteria or architectural guidelines do you use to draw clean domain boundaries and break a monolithic application down into microservices without causing tight coupling?"

🛡️ System Fault Tolerance & API Resilience

Circuit Breaker Mechanics: "Service A calls Service B synchronously. If Service B encounters sudden latency spikes, how do you configure Resilience4j thresholds (Closed to Open states) to prevent thread starvation in Service A?"
API Gateway Execution: "What cross-cutting concerns (like OAuth2/JWT token validation, dynamic routing, and token-bucket rate limiting) do you explicitly offload to an API Gateway instead of handling them inside individual microservices?"

🧵 Low-Level Design (LLD) & Database Concurrency

Concurrent Balance Updates (Race Conditions): "Two users execute an API call to deduct from the exact same wallet or account balance at the exact same millisecond. How do you prevent a race condition at the application and database layers?"
JPA/Hibernate Locking Trade-offs: "What are the strict performance and blocking trade-offs of implementing Optimistic Locking (@Version column) versus Pessimistic Locking (SELECT ... FOR UPDATE) under heavy database write load?"
Object-Oriented Design (LLD Scenarios): "How do you apply GoF design patterns (like the Strategy Pattern for dynamic rule processing or the Chain of Responsibility for multi-step processing) to keep an enterprise component extensible?"

🔎 Production Troubleshooting & Diagnostic Operations

Debugging 100% CPU Spikes: "If a production application instance suddenly spikes to 100% CPU utilization, walk me through your exact step-by-step diagnostic workflow using Thread Dumps (jstack)."
Memory Leak Profiling (OOM): "A container runs smoothly for 3 days and then crashes with a java.lang.OutOfMemoryError: Java heap space. How do you analyze an .hprof heap dump using Eclipse MAT to isolate the root cause?"

🛡️ How to Answer Cloud Questions Without Direct Cloud Exposure

1. The "Secret Management" Question

The Question: "How do you securely manage database passwords or API keys in a cloud environment?"
Your Answer: "In my previous projects, we ran on physical servers and handled security by using encrypted property files or centralized property management systems. While I haven't configured a cloud native tool like AWS Secrets Manager or Azure Key Vault myself, I completely understand the architectural concept: the Java application fetches the tokens dynamically at runtime via an API rather than storing hardcoded credentials in the git repository."

2. The "Deployment & Containers" Question

The Question: "How do you deploy your Spring Boot applications? Have you worked with cloud containers?"
Your Answer: "My core expertise is writing highly optimized Java code. In my previous organizations, we packaged our Spring Boot applications as self-contained executable JARs and deployed them onto Linux Virtual Machines. Once the JAR is ready, the deployment architecture remains identical whether it runs on a physical VM or inside a cloud container like AWS ECS or Azure App Service."

3. The "Distributed Tracing" Question

The Question: "How do you track a user request across multiple microservices in a cloud ecosystem?"
Your Answer: "We handle distributed tracing at the application layer using Spring Cloud Sleuth / Micrometer and Zipkin. A unique Trace ID is generated at the initial API entry point and passed along the HTTP headers to all downstream Java services. This allows us to aggregate and search logs smoothly, completely independent of the underlying cloud infrastructure."

_____________________________________________________________________

CTS Client (TD Bank) discussion (30 minutes round) - JUN 2026

(EXPECTED)

🏛️ Section 1: High-Level System Design, Data Integrity & Core Architecture

Handling High Concurrency & Race Conditions: How do you ensure absolute data consistency when multiple concurrent user threads or systems attempt to update the exact same account balance or inventory row at the exact same millisecond?
API Idempotency: If an automated client service or payment gateway retries a failed REST API call, how do you enforce strict idempotency at the architectural layer to prevent duplicate transaction processing?
Microservices Resilience: In a distributed environment, if a downstream microservice experiences high load or sudden latency spikes, how do you prevent cascading failures and thread starvation in your calling service?
Distributed Transactions (Saga Pattern): When you enforce a Database-per-Service architecture, how do you manage transactions that span multiple services? What are the trade-offs between Orchestration and Choreography when designing compensating rollback actions?
CQRS Implementation: How do you implement the Command Query Responsibility Segregation (CQRS) pattern to separate high-frequency writes from heavy reads, and how do you handle asynchronous data sync between them?
Data Redundancy vs. Coupling: How do you determine the boundaries of microservices using Domain-Driven Design (DDD) to prevent creating a "distributed monolith"? When is storing duplicate local data acceptable over making synchronous REST calls?

☁️ Section 2: Cloud-Native Concepts, Infrastructure & Distributed Tracking

Zero-Trust Cloud Security: How do your cloud-deployed Java applications securely communicate with cloud databases and external third-party systems without hardcoding credentials, access keys, or passwords in your code repository?
Cloud Secret Management Throttling: If a Spring Boot microservice calls an external cloud secret manager on every single API request, what infrastructure bottleneck occurs, and how do you optimize it?
Distributed Tracing & Log Aggregation: How do you track, correlate, and debug a single end-to-end user request as it traverses across multiple microservices and network boundaries in a cloud ecosystem?
Container Sizing vs. JVM Memory: When deploying a Spring Boot application on a cloud container service, how do you configure the JVM Heap size properties relative to the cloud host's memory limit to prevent automated OS process termination (like an OOMKilled exit)?
Serverless vs. Container Workloads: What are the performance, cold-start latency, and cost trade-offs of deploying business logic inside Serverless Functions versus long-running containerized services?
High Availability & DR Failover: How do you architect a multi-region deployment for a Java backend application to ensure zero downtime and handle database replication lag during a disaster recovery (DR) failover?

🔎 Section 3: Code Governance, Code Quality & Low-Level Design (LLD)

Catching Technical Debt in PR Reviews: As a Technical Lead conducting peer reviews on a Pull Request (PR), what specific structural flaws, anti-patterns, or architectural liabilities cause you to reject the code?
Enterprise Cross-Cutting Concerns: How do you design a reusable corporate-wide reference template or custom Spring Boot Starter to enforce standardized global exception handling and structured JSON logging across teams?
Object-Oriented Design (LLD Scenarios): How do you design real-world systems (like a Movie Ticket Booking System, an ATM, or a Parking Lot) using clean class structures, SOLID principles, and appropriate Gang of Four (GoF) design patterns?
API Contract Versioning: How do you manage API contract changes and versioning in production without breaking backward compatibility for existing downstream enterprise clients?
Dependency and Core Framework Upgrades: When a critical security vulnerability (like a Log4j or Spring framework exploit) is flagged, how do you plan and execute a mass dependency upgrade across multiple decoupled repositories?

🧵 Section 4: Performance Optimization & Production Troubleshooting

Database Deadlocks Isolation: How do you isolate, analyze slow logs, and permanently resolve a DeadlockExpiredException occurring in a high-frequency relational database engine?
Connection Pool Exhaustion: How do you optimize HikariCP properties (such as maximum pool size and connection timeouts) to prevent thread starvation and application freezing under peak write loads?
Custom Thread Pool Management: How do you safely configure dedicated, bounded execution thread pools for asynchronous processing to ensure you don't starve the global JVM or web container worker threads?
Debugging 100% Production CPU Spikes: If a production application container suddenly hits 100% CPU utilization on a weekend deployment, what is your exact step-by-step diagnostic workflow using thread dumps?
Memory Leak Profiling (OOM): A Java service runs fine for 3 days and then crashes with a java.lang.OutOfMemoryError: Java heap space. Walk me through your diagnostic workflow using an .hprof heap dump and memory analyzers.
Stream API Optimization: When processing massive data collections using Java Streams, how do you optimize execution? What are the specific performance risks of running blocking operations inside parallel streams?

🌾 Section 5: Agile Delivery, Scrum Dynamics & Team Management

Sprint Estimation and Blockers: Walk through how you evaluate complexity during sprint planning. What do you do if you realize mid-sprint that a critical technical component cannot be delivered on time?
Managing Technical Friction: As a Tech Lead, how do you handle a scenario where two senior developers on your team are completely deadlocked on a major architectural or low-level design approach?
Handling Changing Requirements: How do you manage technical delivery when a Product Owner or Client Business Analyst requests major changes to a feature requirement in the middle of an active sprint?
Balancing Technical Debt with Feature Delivery: How do you convince non-technical business stakeholders or project managers to allocate sprint capacity for code refactoring and technical debt reduction?
Mentoring and Code Standards: How do you ensure that junior or mid-level developers on your team strictly adhere to the defined code quality metrics and architectural standards without micromanaging them?

_____________________________________________________________________

CTS Client (TD Bank) discussion (30 minutes round) - JUN 2026

(ASKED)

Written Test (40 minutes)

Q1. Write code for LRU Cache

=> Average Time Complexity should be O(1)

=> Data Structure Selected

=> Explain Eviction mechanisms

Q2. REST API design for customer notification preferences

=> Write Create, Update, Fetch APIs

=> Validation also to be there

=> Global exception handling

=> Explain how you secure

Q3. SQL - Write SQL to fetch top 5 customers with total successful transactions in the last 30 days. For what columns will you add index and why ?

table transaction

_____________________________________________________________________

SQL Questions expected in interviews (Especially in banking domain client)

🏛️ Section 1: Complex Joins, Hierarchies & Transaction Correlation

01. The Classic Self-Join (Manager-Employee Hierarchy): Given an Employees table with columns emp_id, emp_name, and manager_id, write a query to display all employees along with their manager's name. How do you ensure employees who do not have a manager (like the CEO) are still included in the output? [1, 2, 3]

02. Multi-Table Left Join Verification: Given three tables: Customers (cust_id, name), Accounts (acc_id, cust_id, acc_type), and Transactions (tx_id, acc_id, amount), write a query to list all customers who have a bank account but have executed zero transactions in the last 6 months.

03. Unmatched Row Isolation (Anti-Join): Write a query to find all records in a Customers table that do not have any corresponding records in the Accounts table. Show three different architectural ways to achieve this (LEFT JOIN with IS NULL, NOT IN, and NOT EXISTS) and explain their internal execution plan differences. [1, 2]

04. Cross-Join Data Generation: How do you generate a matrix of every possible combination between a Branches table and a FinancialProducts table for a quarterly performance tracking template?

05. Self-Join for Consecutive Event Tracking: In a LoginAudit table (user_id, login_time, ip_address), write a query to detect fraud cases where the same user logged in from two different IP addresses within less than 5 minutes of each other. [1]

📊 Section 2: Aggregations, Window Functions & Analytical Subqueries

06. High-Volume Filtering (GROUP BY with HAVING): Given a Transactions table (tx_id, account_id, amount, tx_date), write a query to retrieve all account_ids that have performed more than 10 transactions with a total accumulated volume exceeding ₹50,00,000 within the current calendar month.

07. The Nth Highest Value: Write a database-agnostic query to find the 3rd highest account balance from an Accounts table without using vendor-specific keywords like TOP or LIMIT. Then, write the same query using modern analytical Window Functions.

08. Differentiating Ranking Window Functions: Write a query that assigns a row number, a rank, and a dense rank to accounts based on their balances. What is the exact behavioral difference between ROW_NUMBER(), RANK(), and DENSE_RANK() when multiple accounts hold identical balances?

09. Running Totals (Cumulative Sums): Write a query to generate a ledger statement for a specific account_id that displays each transaction chronologically along with a dynamically calculated running balance column.

10. Partitioned Top-N Analysis: In a Transactions table, write a query to find the top 3 highest-value transactions for every single bank branch in the system.

11. Correlated Subquery Execution: Write a query to fetch the complete details of the absolute latest transaction record for every active customer account in the system using a correlated subquery. [1, 2, 3]

🛡️ Section 3: Data Integrity, Duplication & Ledger Reconciliations

12. Identifying Multivariable Duplicates: Due to an API retry network glitch, some payments were processed multiple times. Write a query to scan a Ledger table and isolate all duplicate rows where source_account, destination_account, amount, and timestamp are identical, along with the total count of duplicates per occurrence.

13. Safely Removing Duplicate Rows: Write an executable query to permanently delete all exact duplicate rows from a transactional AuditLogs table while safely retaining exactly one unique record (the one with the lowest internal primary key id).

14. Ledger Reconciliation (Mismatched Balances): You have an Accounts table holding a summarized current_balance column, and a Transactions table holding a historical log of credits and debits (amount). Write a query to flag all accounts where the summarized current_balance does not match the mathematical sum of their historical transaction records.

15. Conditional Aggregation (Pivoting Data): Write a query to pivot a transactional log table into a summary report displaying account_id as rows, and the total sums of CREDIT versus DEBIT transactions as two separate horizontal columns.

🧵 Section 4: Advanced Subqueries, Common Table Expressions (CTEs) & Strings [1, 2]

16. Recursive CTEs for Hierarchical Structures: Given an organization chart or an asset category tree table (id, name, parent_id), write a recursive CTE query to trace the complete hierarchical ancestry path from a leaf node up to the root element.

17. Correlated EXISTS vs. IN Processing: When checking if an account has triggered any security alerts stored in an external ComplianceAlerts table, what is the internal performance optimization difference between using a WHERE account_id IN (subquery) versus a WHERE EXISTS (correlated subquery) block?

18. Complex String Manipulation & Regular Expressions: In a legacy banking database, customer names are stored uncleanly with trailing spaces, special characters, or mixed casing. Write a query to extract, trim, and standardize the formatting of these records to match compliance definitions.

19. Conditional Logic Using CASE WHEN: Write a query to categorize customer accounts into custom risk tiers (HIGH RISK, MEDIUM RISK, LOW RISK) dynamically based on a multivariable logic check combining their account_age, credit_score, and overdraft_frequency. [1, 2, 3, 4]

⚡ Section 5: Query Optimization, Indexing Mechanics & DB Internals

20. Analyzing Execution Plans (EXPLAIN ANALYZE): If a customer lookup query scanning by a unique identifier takes 20 seconds on a database containing 100 million rows, walk through how you interpret an execution plan output. What visual markers distinguish an expensive Full Table Scan / Sequential Scan from an Index Scan?

21. Composite Indexing & The Left-Most Prefix Rule: If you create a composite/multi-column index on a table using CREATE INDEX idx_user_location ON Users(country, state, city), will a query filtering strictly by state and city utilize this index? Explain the underlying execution behavior.

22. Index Coverage & Index Only Scans: What is a Covering Index? How do you design an index structure so that the database engine can fulfill an API query's entire select clause directly from the index tree without performing a secondary data heap lookup?

23. The Hidden Overhead of Indexes: If indexing speeds up read queries dramatically, why don't senior database architects index every single column inside an enterprise transaction table? What is the impact on INSERT, UPDATE, and DELETE operations?

24. Wildcard Searching Bottlenecks: Explain the performance difference between a string search executing LIKE 'A%' versus a search executing LIKE '%A%'. How does the placement of the percentage wildcard character affect B-Tree index traversal?

25. Function-Based/Functional Indexing: If a query executes a row-level function inside its filtering criteria, such as WHERE UPPER(email) = 'USER@BANK.COM', will a standard index on the email column be utilized? How do you optimize this query?

26. Optimizing Pagination for Deep Scaling: When designing a transaction history service that serves millions of rows, why does traditional pagination using LIMIT 10 OFFSET 500000 degrade system performance? What is the senior architectural alternative pattern (Keyset Pagination / Seek Method) to resolve this?

27. Deadlocks & Lock Escalation Mechanics: At the database storage engine layer, how does a high volume of concurrent uncommitted update queries trigger an automatic lock escalation from a single row-level lock up to a heavy, blocking table-level lock?

28. Database Views vs. Materialized Views: What are the structural, architectural, and memory-caching trade-offs of using a standard relational VIEW versus a MATERIALIZED VIEW when generating heavy end-of-day banking financial summaries?

Go through these 28 architectural scenarios and draft their query patterns one by one. Once you finish your answers and want to audit any tricky scenario (like Questions 12, 13, 20, or 26), paste your SQL syntax code here and I will instantly run a structural check on it against senior-level delivery standards.

--------------------- --------------------- --------------------- ---------------------

✅ Here is a curated list of the most commonly asked SQL interview questions for a 9+ years experienced Java Backend Developer.

I have grouped them by category for easy preparation.

1. Basic to Intermediate SQL

Write a query to find the second highest salary from Employee table.
Find all employees who earn more than their manager.
Find duplicate records in a table based on email.
Delete duplicate rows keeping the latest record.
Find Nth highest salary without using LIMIT/OFFSET.
Find customers who have placed more than 5 orders in the last 30 days with total spend.
Find all employees belonging to departments having more than 20 employees.

2. Joins & Aggregations

Difference between INNER JOIN, LEFT JOIN, RIGHT JOIN, FULL OUTER JOIN.
Write a query to find department-wise employee count and average salary.
Self-join example — find employees who work in the same department as a given employee.
Find the top 5 customers by total order value in the last 6 months.

3. Window Functions (Very Important for Senior Roles)

Find the rank of each employee based on salary (using RANK, DENSE_RANK, ROW_NUMBER).
Find running total (cumulative sum) of salary department-wise.
Find the difference between current and previous transaction amount for each customer.
Find the 3rd highest salary in each department.

4. Advanced / Performance

Difference between DELETE, TRUNCATE, and DROP.
How to optimize a slow query (indexing strategy).
Explain ACID properties with examples.
How do you handle pagination in SQL (efficient way)?
Explain the difference between clustered and non-clustered index.

5. Scenario-Based (Most Asked for 9+ YOE)

How do you find duplicate transactions in a payment table?
Write a query to find customers who have not placed any order in the last 90 days.
How do you handle concurrent updates on the same account balance?
Design a query to generate a monthly report of total transactions per customer.
How do you implement soft delete in a table?

Preparation Tip:

Focus more on:

Window Functions
Joins & Aggregations
Scenario-based questions (especially related to payments/banking)

Would you like me to give detailed answers with explanations for any of these questions? Just tell me the numbers. 😊

You can prepare 8-10 important ones and you’ll be good for most interviews. Good luck!

_____________________________________________________________________

AWS QUESTIONS LIST

🏛️ Section 1: Compute, Deployment Models & JVM Cloud-Native Tuning

EC2 Application Compute Scaling: When deploying containerised Spring Boot microservices across multiple AWS EC2 virtual machines behind an Application Load Balancer (ALB), how do you configure application-level health check probes (/actuator/health) to ensure traffic is never routed to a crashing JVM instance?
Container Sizing vs. JVM Memory Limits: If you package a Java application into a Docker container and deploy it onto an AWS EC2 instance or ECS, how do you mathematically align the JVM max heap parameters (-Xmx) with the container's hard memory allocation limits to prevent the host OS from triggering an sudden OOMKilled (Exit Code 137) crash?
Serverless (AWS Lambda) Java Cold Starts: What causes the severe "Cold Start" latency delays when running a standard Spring Boot framework inside an AWS Lambda serverless execution model? What architectural or compilation strategies (such as GraalVM Native Image or provisioning concurrency) do you use to mitigate this in user-facing APIs?
Lambda Event-Driven Triggers: In what specific enterprise architectural scenarios would you choose AWS Lambda over a continuous long-running EC2 instance workload for running backend Java processing logic?
Multi-AZ High Availability: How do you structure a Java deployment across multiple AWS Availability Zones (AZs) to achieve fault tolerance, and how does the application layer handle the slight network latency overhead when communicating across distinct data centers?

🛡️ Section 2: Zero-Trust Security, Identity & Secrets Governance

Zero-Trust Infrastructure Authentication: How do your Spring Boot applications securely authenticate and connect to AWS infrastructure services (like an SQS queue or S3 bucket) at runtime without hardcoding IAM access keys or secret tokens inside application property files or environment configurations?
AWS Secrets Manager Integration: Walk through how a Java backend fetches encrypted properties from AWS Secrets Manager dynamically at startup using an IAM Instance Profile / Role. How does the application framework handle local caching and secret rotation without requiring a cold restart of the JVM?
Secrets Manager API Throttling: If a high-throughput microservice attempts to fetch an encryption key or token from AWS Secrets Manager on every incoming REST API call, what infrastructure bottleneck occurs, and how do you implement application-level optimization (TTL caching) to prevent cloud rate-limiting?
VPC Networking Isolation: From a security architecture perspective, how do you utilize AWS VPC Private Subnets, Public Subnets, and Security Groups to completely isolate your database engines (RDS) while allowing your EC2-hosted Spring Boot APIs to establish secure network handshakes?

📊 Section 3: Managed Data Persistence & Distributed Caching

RDS Connection Pool Exhaustion: If your application layer encounters high connection latency or thread blocking when talking to an AWS RDS (Relational Database Service) instance under peak user load, what steps do you take to isolate the bottleneck? How do you optimize HikariCP pool properties relative to AWS RDS database capacity limits?
RDS Failover & Replication Lag: During an automated Multi-AZ database failover in AWS RDS, how does a Spring Boot application layer running Hibernate handle connection dropouts? How do you design your read/write data routing strategies to prevent data inconsistency caused by asynchronous read-replica lag?
Cache-Aside Pattern with ElastiCache: How do you implement a distributed cache-aside pattern inside a Java microservices framework using AWS ElastiCache for Redis? What strategies do you use for data eviction and Time-To-Live (TTL) configuration to prevent stale data bugs?
Cache Invalidation & Thundering Herd: In a high-traffic system, what happens when a popular Redis cache key expires simultaneously under a peak load wave? How do you design your Java code to prevent a "thundering herd" bottleneck from hitting your primary AWS RDS database? [1, 2]

🔎 Section 4: Messaging, Event-Driven Architecture & Scalability

Decoupling with AWS SQS vs. Kafka: Architectural review: In what production scenario would you choose a managed message queue like AWS SQS (Simple Queue Service) over a distributed streaming platform like Apache Kafka or AWS Kinesis for handling inter-service communication?
Handling SQS Message Duplication & Visibility Timeouts: When a consumer JVM fetches a payment event from an AWS SQS queue, processes the business logic, but crashes before deleting the message from the queue, what happens? How do you configure SQS Visibility Timeouts and enforce Idempotency in your Java code to handle this?
Dead Letter Queue (DLQ) Management: How do you configure and leverage an AWS SQS Dead Letter Queue (DLQ) within a Spring Cloud AWS messaging architecture to gracefully trap, log, and recover from unhandled runtime processing exceptions without blocking the main event pipeline?
AWS S3 Event-Driven Pipelines: How do you architect a high-volume batch file processing engine where an automated upload to an AWS S3 (Simple Storage Service) bucket triggers an immediate, multi-threaded asynchronous parsing operation inside your Java backend cluster?

🧵 Section 5: Observability, Distributed Tracing & Cloud Troubleshooting

CloudWatch Log Aggregation: How do you route container or EC2-based Spring Boot console logs into AWS CloudWatch Logs in real-time? How do you configure the log formatting (JSON vs. raw text) to allow efficient infrastructure metric filtering and production alert triggering?
Distributed Tracing across AWS Networks: When an API request crosses multiple microservices hosted on separate EC2 nodes, how do you track and aggregate the complete request lifecycle? How do you align application trace frameworks (like Micrometer/Sleuth) with cloud observability tools like AWS X-Ray?
Diagnosing Cloud Resource Contention: If an AWS CloudWatch alarm indicates that your EC2 cluster's CPU utilization is spiking to 100% on a fresh deployment, how do you correlate that cloud metric with low-level JVM thread states to isolate the root cause? [1]

🏛️ The 5 Essential AWS Questions For a Tech Lead

IAM Roles & Secrets Manager (Security): How does your Spring Boot application securely fetch database passwords or API keys from AWS Secrets Manager at runtime without hardcoding them in application.yml or properties files?
EC2 vs. Lambda (Compute Trade-offs): What are the architectural, performance, and "Cold Start" latency trade-offs of deploying a heavy Java Spring Boot microservice inside an AWS Lambda (Serverless) function versus running it on a continuous AWS EC2 instance? [1, 2]
ElastiCache for Redis (Caching Pattern): How do you design a high-performance, distributed cache-aside architecture using AWS ElastiCache for Redis to offload read-heavy traffic from your primary database, and how do you handle cache expiration (TTL)?
RDS Connection Pools & Alerting (Database Performance): If your application encounters connection timeouts or high latency under peak transactional load, how do you cross-verify AWS CloudWatch metrics for RDS against your application’s internal HikariCP connection pool settings?
SQS Messaging & Idempotency (Event-Driven Architecture): If a Java service processes a message from an AWS SQS (Simple Queue Service) queue but crashes before deleting it, how do you configure SQS Visibility Timeouts and enforce application-layer Idempotency to handle the duplicate message retry safely?

TOPICS

Featured Post

Spring Framework basic interview Q&A

Popular Posts

1. Basic to Intermediate SQL

2. Joins & Aggregations

3. Window Functions (Very Important for Senior Roles)

4. Advanced / Performance

5. Scenario-Based (Most Asked for 9+ YOE)