Kotak Mahindra Bank SDE-1 Interview Experience : DSA, LLD, Kafka, PostgreSQL & Distributed Systems

Recently, I interviewed for an SDE-1 role at Kotak Mahindra Bank and the experience was honestly much more technical and backend-focused than I initially expected. I went into the interview thinking it would mostly revolve around basic Java and DSA questions, but the process covered a surprisingly wide range of topics including distributed systems, Kafka, database concepts, low-level design and coding problems.

The complete process consisted of 3 rounds and was conducted remotely. The overall difficulty level was medium, but what made the interview interesting was the balance between coding ability and engineering fundamentals. The interviewers were not just checking whether I could solve LeetCode problems. They were trying to evaluate whether I understood how real backend systems work and whether I could think like an engineer while discussing scalability, system behavior and production-level concepts.

If you are preparing for:

• Kotak Mahindra Bank SDE-1 interview
• backend developer interviews
• Kafka interview questions
• distributed systems interview preparation
• Java backend interviews for freshers or SDE-1

then this experience can genuinely help you understand what kind of preparation is actually useful.

One important observation from this interview was: Banking companies are increasingly asking product-company style backend questions. Especially around: distributed systems, data consistency, scalability, Kafka, SQL databases, system design fundamentals.

which means backend preparation has become extremely important even outside big product companies.

Interview Process Overview

The process had 3 rounds:

The interview process was smooth overall and every round explored different aspects of backend engineering and problem-solving.

Round 1 : Distributed Systems, DSA & Low-Level Design

This was the longest round, around 1.5 hours. It was conducted through BarRaiser. The round was divided into three sections: Distributed Systems, DSA and LLD.

What I liked was that the interviewer did not immediately jump into coding. The discussion started gradually with backend concepts and system-level thinking.

Distributed Systems Questions

The first section focused entirely on distributed systems concepts.

Initially, I expected surface-level questions, but the interviewer actually explored practical reasoning behind scalability and consistency.

One of the first questions was:How do you maintain consistency in distributed database systems?

I explained concepts like: replication strategies, distributed transactions, quorum-based approaches, eventual consistency vs strong consistency.

I also mentioned that maintaining strong consistency across distributed systems can impact availability and latency, so many large-scale systems use eventual consistency depending on business requirements.

The interviewer then asked: How do you scale a system?

Instead of giving a generic answer, I explained scaling from both perspectives:

Vertical Scaling Increasing server resources like CPU and RAM.

Horizontal Scaling Adding multiple servers and distributing traffic among them.

I also discussed: load balancing, database sharding, caching, stateless services.

The interviewer seemed particularly interested in how scaling decisions change when traffic suddenly increases.

Another interesting question was: How do you handle deployment failures in production?

This felt more like a real engineering discussion rather than an interview question. I explained approaches such as: rollback strategies, blue-green deployment, canary deployment, monitoring and alerting, feature flags.

I also discussed why automated deployment pipelines are important to reduce human error.

This part of the interview gave me the feeling that they were trying to evaluate practical backend maturity instead of textbook knowledge.

DSA Problem :Container With Most Water

After the system discussions, we moved into coding. The DSA question asked in this round was: Container With Most Water

This is a classic two-pointer problem where we need to find the maximum area of water that can be trapped between two vertical lines.

At first glance, brute force looks straightforward because we can try every pair of lines. But that approach leads to O(N²) time complexity, which is inefficient for large inputs.

I explained my thought process before writing code because interviewers often care a lot about approach clarity. The key observation is : The area depends on distance between lines and minimum height between the two lines. So moving the taller line is usually useless because the smaller line limits the area. That naturally leads to the optimal two-pointer solution.

public class ContainerWithMostWater {

    public int maxArea(int[] height) {
        int left = 0;
        int right = height.length - 1;
        int maxArea = 0;
        while (left < right) {
            int area = Math.min(height[left], height[right])
                    * (right - left);
            maxArea = Math.max(maxArea, area);
            if (height[left] < height[right]) {
                left++;
            } else {
                right--;
            }
        }

        return maxArea;
    }
}

The interviewer asked several follow-up questions around:

• why the optimization works
• edge cases
• time complexity
• space complexity

So make sure you can explain the reasoning, not just memorize the solution.

Low-Level Design Round – Design Uber/Ola

The final section of Round 1 was LLD. The interviewer asked me to design a simplified version of Uber/Ola.

Initially, I thought they would only ask for class diagrams, but the discussion became much broader. The interviewer expected:

• class design
• APIs
• database schema
• entity relationships
• booking workflow
• ride allocation logic

I started by identifying the main entities:

• User
• Driver
• Ride
• Vehicle
• Payment

Then I discussed: ride booking APIs, location tracking, driver assignment and fare calculation.

One thing I learned from this round is: In LLD interviews, communication matters more than perfect UML diagrams The interviewer mainly wanted to understand how I structure backend systems logically.

Round 2 : DSA Round

This round was around 1 hour and focused completely on coding problems. Both questions were medium-level problems and fully working solutions were expected. The interviewer was very particular about: clean code, optimization, handling edge cases, explaining thought process,

Problem 1 – Group Anagrams

The problem statement was straightforward: Given an array of strings, group all strings that are anagrams of each other.

Example:

Input:
["eat","tea","tan","ate","nat","bat"]

Output:
[["eat","tea","ate"],["tan","nat"],["bat"]]

The key observation is that anagrams have the same sorted character sequence. So for every string: sort its characters and use sorted string as hashmap key

class Solution {

    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();
        for (String str : strs) {
            char[] chars = str.toCharArray();
            Arrays.sort(chars);
            String key = new String(chars);
            map.putIfAbsent(key, new ArrayList<>());
            map.get(key).add(str);
        }
        return new ArrayList<>(map.values());
    }
}

The interviewer also asked:

• why hashmap works efficiently here
• time complexity analysis
• alternate approaches without sorting

Problem 2 – Permutations

The second problem was: Generate All Permutations of an Array This problem tests recursion and backtracking fundamentals. The interviewer wanted a complete running solution.

I explained how recursion explores every possible arrangement by: choosing one element, marking it visited and recursively building remaining permutations.

class Solution {

    public List<List<Integer>> permute(int[] nums) {

        List<List<Integer>> result = new ArrayList<>();

        backtrack(nums, new ArrayList<>(), new boolean[nums.length], result);

        return result;
    }

    private void backtrack(int[] nums,
                           List<Integer> current,
                           boolean[] visited,
                           List<List<Integer>> result) {

        if (current.size() == nums.length) {
            result.add(new ArrayList<>(current));
            return;
        }

        for (int i = 0; i < nums.length; i++) {

            if (visited[i]) continue;

            visited[i] = true;
            current.add(nums[i]);

            backtrack(nums, current, visited, result);

            current.remove(current.size() - 1);
            visited[i] = false;
        }
    }
}

The interviewer paid close attention to: recursion flow, backtracking cleanup and space complexity.

Round 3 : Resume Discussion + Kafka + PostgreSQL + DSA

This round was probably the most discussion-heavy round. The interviewer explored: Kafka, PostgreSQL, transactions, ACID properties and DSA basics. This round felt more like a backend engineering conversation than a coding interview.

Kafka Questions

The interviewer asked several practical Kafka questions.

Difference Between Topic and Partition

I explained:

• Topic : Logical category of messages.
• Partition : Physical division of a topic used for scalability and parallel processing.

I also explained how partitions enable Kafka to distribute load across brokers.

Consumer vs Consumer Group

I explained that:

• consumers read messages
• consumer groups allow parallel consumption

Within a consumer group: one partition is consumed by only one consumer This ensures message processing balance.

Scenario Question – 2 Partitions and 3 Consumers

The interviewer asked: If there are 2 partitions and 3 consumers, how are they distributed?

I explained that: only 2 consumers will actively consume and the third consumer remains idle. because one partition cannot be shared among multiple consumers within the same group simultaneously.

Another important question was: How do you maintain message order in Kafka?

I explained that ordering is guaranteed only within a partition. So messages with the same key should be routed to the same partition. This ensures proper sequential processing.

PostgreSQL Questions

The interviewer then shifted toward SQL concepts. One question was: Difference Between Primary Key and Unique Constraint

I explained:

Primary Key

• uniquely identifies records
• cannot contain NULL
• only one per table

Unique Constraint

• also prevents duplicates
• allows NULL values (depending on DB)
• multiple unique constraints possible

Next, The interviewer asked: Explain ACID properties

Instead of rushing definitions, I explained each property with practical examples.

• Atomicity Either entire transaction succeeds or fails completely.

• Consistency Database remains in valid state after transaction.

• Isolation Concurrent transactions should not interfere incorrectly.

• Durability Committed changes must survive failures.

The interviewer also asked: What is a transaction? and What are isolation levels?

I discussed: Read Uncommitted, Read Committed, Repeatable Read and Serializable. along with concurrency issues like: dirty reads, phantom reads, and non-repeatable reads.

DSA Questions

Two smaller coding questions were asked toward the end.

1. Reverse a String Without Extra Space

The interviewer expected an in-place solution using two pointers.

class Solution {

    public void reverseString(char[] s) {
        int left = 0;
        int right = s.length - 1;
        while (left < right) {
            char temp = s[left];
            s[left] = s[right];
            s[right] = temp;
            left++;
            right--;
        }
    }
}

2. Find Kth Smallest Element in Array

I discussed multiple approaches: sorting, min/max heap and quickselect.

The interviewer seemed more interested in optimization trade-offs than final syntax.

Final Result & Overall Experience

Overall, the interview experience at Kotak Mahindra Bank was quite good and much more technical than I expected from a banking company. The process tested:

• coding ability
• backend fundamentals
• distributed systems understanding
• communication skills
• system design thinking

One important takeaway from this interview was: Backend engineering interviews are becoming increasingly practical . Companies now expect engineers to understand not only algorithms, but also:

• scalability
• distributed systems
• messaging systems
• databases
• deployment strategies
• backend architecture decisions

Preparation Tips for Kotak SDE-1 Interviews

If you’re preparing for similar backend-focused interviews, I would strongly recommend focusing on:

• medium-level DSA problems
• Kafka fundamentals
• SQL and PostgreSQL concepts
• ACID properties
• distributed systems basics
• microservices concepts
• LLD fundamentals
• recursion and backtracking

Most importantly: Practice explaining your thought process clearly Because many interviewers evaluate communication and reasoning as much as coding ability itself.

Recommended Interview Experience