/ \
Distributed Systems Low-Level Design (LLD)
\ /
\ /
\ /
CS Core & Java Fundamentals
#### 1. Data Structures & Algorithms (Coding)
Coding sessions test your core problem-solving capability and ability to write bug-free code under live observation. Questions lean heavily toward array manipulation, sliding windows, string operations, dynamic programming, and binary search variants.
**Be ready to go over:**
- **Array & String Operations** – Two-pointer techniques, sliding window max/min, prefix sums, and string reordering algorithms.
- **Searching & Sorting** – Modified binary search algorithms (e.g., searching in rotated sorted arrays, finding peak elements).
- **Structures & Graphs** – Priority queues, deques, dynamic programming, and graph traversals (BFS/DFS).
- **Advanced concepts (less common)** – Trie-based string matching algorithms and KMP string search optimizations.
**Example scenarios:**
- "Given a string of daily stock values, compute the maximum profit possible using a single buy and sell operation."
- "Implement an algorithm using a double-ended queue to find the maximum element in every sliding window of size $k$."
- "Write an optimal solution to find the minimum platforms required for a railway station given arrival and departure schedule arrays."
#### 2. Low-Level Design (LLD) & Machine Coding
Low-Level Design is heavily weighted in the Kotak interview process. You will be asked to model complete real-world applications within 30 to 45 minutes, producing clean domain models, class relationships, API contracts, and database schemas.
**Be ready to go over:**
- **Domain Modeling & Classes** – Identifying core entities, applying encapsulation, inheritance, and composition correctly.
- **Design Patterns** – Practical implementation of Strategy, Factory, Observer, Singleton, and Chain of Responsibility patterns.
- **Concurrency & Thread Safety** – Handling race conditions, managing concurrent DB access, thread locks, and preventing starvation in shared resources.
- **Advanced concepts (less common)** – Implementing complete machine coding exercises (e.g., Battleship game) on your local IDE with working execution logic.
**Example scenarios:**
- "Design an e-commerce cart system: create classes, define relationships, establish payment interface patterns, and design the relational DB schema."
- "Design an Airport Scheduler for a single runway that handles priority landings, emergency requests, and concurrent access without thread starvation."
- "Model a food delivery service like Swiggy, focusing on order status transitions, driver allocation strategy, and payment status hooks."
#### 3. Distributed Systems & High-Level Design (HLD)
For backend and mid-level roles, interviewers probe your understanding of modern distributed software architectures. Questions focus on building high-throughput, fault-tolerant banking systems.
**Be ready to go over:**
- **Messaging & Event Streams** – Asynchronous processing, **Kafka** broker architectures, partition strategies, and handling consumer lag.
- **Data Consistency & Storage** – Relational vs NoSQL trade-offs, database indexing, **CAP theorem**, and the Saga pattern for distributed transactions.
- **Scalability & Resiliency** – Caching strategies (**Redis**), rate-limiting algorithms, load balancing, and failure handling (retries, circuit breakers).
- **Advanced concepts (less common)** – Network partition resolution across geographically distributed database clusters.
**Example scenarios:**
- "Design a scalable rate limiter that tracks API consumption across distributed nodes and enforces request limits per user."
- "Architect a multi-channel notification engine capable of queuing and sending SMS, email, and push notifications with scheduling capabilities."
- "How do you detect, isolate, and recover from an underperforming broker in a large-scale Apache Kafka cluster?"
#### 4. Java Core & Computer Science Fundamentals
Kotak's technical panels place significant emphasis on candidate knowledge of language runtimes and underlying operating system mechanics, particularly for Java backend roles.
**Be ready to go over:**
- **Java Internals** – **HashMap** bucket mechanics, garbage collection basics, Java Memory Model (JMM), and multithreading primitives.
- **Database Engineering** – ACID properties, transaction isolation levels, join operations, and query execution plans.
- **Operating Systems** – Memory management (heap vs stack), context switching overhead, process scheduling, and file I/O operations.
- **Advanced concepts (less common)** – Memory chunking and streaming approaches for processing multi-gigabyte files.
**Example scenarios:**
- "Explain step-by-step what happens inside a Java HashMap during a `put()` operation when two keys generate identical hash codes."
- "How do you make a Java class completely immutable? What are the common pitfalls with mutable object fields?"
- "Compare processes and threads in terms of shared memory, context switching overhead, and communication methods."
