Background

2.5 years of experience (non-internship) at Amadeus Software Labs.

Applied for the Flipkart SDE-2 role in the first week of January. Got a call from HR shortly after, followed by an assessment link the next day.

Round 1 — Online Assessment (2 hours)

The OA had 2 coding problems:

1. Graph problem — A graph traversal question with a twist and some tricky edge cases to handle. Medium level.
2. Trie question — A standard Trie-based problem. Medium level.

Both were solvable if your fundamentals are solid. Focus on edge cases for the graph problem — that's where most people slip.

Cleared the OA and received a call from HR for the offline rounds.

Round 2 — Machine Coding (90 mins) (In-person)

Problem: Buy Now Pay Later (BNPL) System

This was a full-fledged machine coding round. The problem statement was detailed — design and implement a BNPL system for Flipkart from scratch.

Core requirements:

1. seed_inventory — Load products (name, count, price) into in-memory store
2. view_inventory — Display current inventory state
3. register_user — Register a user with an initial BNPL credit limit
4. buy(user, items, payment_method, date) — Place an order via PREPAID or BNPL. For BNPL, reduce credit limit; block if limit exhausted
5. clear_dues(user, orderIds, date) — Partial or full due clearance against specific orders
6. view_dues(user, date) — Show all pending dues before the given date, sorted by purchase date, with status: PENDING or DELAYED (if 30-day window crossed)
7. order_status(user) — Show full order history + available BNPL credit limit

Bonus requirements:

1. blacklisting — Blacklist users who default on 3+ orders; block BNPL for them
2. add_inventory / remove_inventory — Dynamic inventory management

What they looked for:

• Clean OOP design — interfaces, contracts, separation of concerns
• Extensibility — easy to add/remove features without rewriting
  Proper edge case handling (credit exhaustion, 30-day window, partial payments)
• No DB usage — everything in memory
• Demo-able code via a driver/main program

My experience:

I was able to complete all 7 core requirements + 1 bonus (blacklisting) within the 90-minute window.
The key is to spend the first 10–15 minutes clarifying requirements and sketching the design before writing a single line of code. Design patterns and clean abstractions matter as much as correctness here.

Round 3 — LLD + MC Review (1.5 hours) (In-person)

Two interviewers joined me in the meeting room. This round was a deep dive into the code I built in Round 2.

Code walkthrough & demo:

I walked them through the core flow — how I structured the service classes, separated concerns across different layers, and applied design patterns like Factory and Strategy. I also explained the exception handling strategy — no raw runtime exceptions anywhere; every failure surfaces as a custom-defined exception.

Stress testing on the fly:

The interviewers hammered the code with edge cases. The expectation was clear — the application should never throw an unexpected exception. Every error path had to be gracefully handled with meaningful custom exceptions.

Live coding:

They asked me to implement additional strategies on the spot and handle a new requirement that wasn't in the original problem statement. This tested both adaptability and how extensible my original design was. Being able to plug in a new strategy without touching existing code (thanks to the Strategy pattern) made this manageable.

UML diagram:

Towards the end, they asked me to sketch a UML class diagram covering the core classes, their relationships, and the design patterns used. This is where having a clean mental model of your own design really helps — don't just code, understand what you've built.

Tip: Don't treat the machine coding round as over once you submit. Round 3 is essentially a viva on your own code. Know every design decision you made and be ready to justify and extend it.

Round 4 — DSA (In-Person)

Two DSA problems on the board:

1. House Robber IV variant — Server Maintenance Topology

The classic House Robber IV was wrapped in a server maintenance context — a real-world twist that required understanding the problem beneath the framing before jumping to a solution. I started with the brute force approach, explained the reasoning clearly, and then walked through the optimized binary search + greedy solution. Wrote the pseudocode on the board.

2. Binary Tree Zigzag Level Order Traversal

A familiar one. Jumped straight to the approach — BFS with a deque, alternating insertion direction per level. Explained it confidently and moved directly to pseudocode.

Tip: For DSA rounds, always verbalize your thought process. Starting with brute force and improving shows structured thinking — even if you already know the optimal solution.

Round 5 — System Design + Hiring Manager (1.5 hours)

The HM himself took this round. Even though it was titled System Design, he went deep into low-level aspects throughout.

Structure we followed:

Requirement Gathering — He wanted me to drive this.

• Functional and non-functional requirements, clarifying assumptions before touching design.
• Entities & DB Schema — Detailed entity modelling with proper relationships. No hand-waving — constraints, cardinality, and schema decisions needed justification.
• API Design — Request/response structure for each endpoint. Clean contracts matter here.
• High-Level Architecture — Service communication, how components talk to each other.

He seemed satisfied with the design. The conversation then shifted to:

• Microservice patterns — Circuit breaker, Saga, CQRS, event-driven patterns etc. Be prepared to go deep, not just name-drop.
• Project deep-dive — Walked through my work at Amadeus, technical decisions, challenges faced.
• LP questions — Leadership principle style behavioural questions. Ownership, conflict resolution, handling ambiguity.

Tip: Even in an HM round, be technically sharp. The behavioural questions are a conversation, not a recital — be genuine and specific with examples from your work.

Result

Got a call from HR a week after the drive saying an offer was on its way. Received the offer letter the following week. 🎉

Overall Tips

1. Flipkart's process is heavily weighted towards LLD and machine coding — invest serious time here.
2. Design patterns aren't just theory — know when and why to apply them in real code.
3. Round 3 is a viva on your own Round 2 code. Write code you can defend and extend.
4. For system design, drive the conversation — don't wait to be led.
5. Practice DSA but don't neglect the design side. At SDE-2 level, design is the differentiator.

Happy learning everyone! Feel free to ask anything in the comments. 🙌