Background

• ~1.5 years experience as Backend Engineer (SE-1) at an MNC.
• Interview process consisted of 3 technical rounds, but I was rejected after Round 2.
• HR only mentioned to be prepared on all fronts; no round-wise agenda was shared.

Round 1 – System Design / HLD

Interviewer: Staff Software Engineer

Problem Statement

Design a Product Inventory & Pricing Service for an e-commerce platform supporting:

• Retrieving product details
• Updating product prices
• Updating inventory when orders are placed

Additional requirements:

• Read-heavy system
• Discuss consistency vs availability
• Authorization for inventory updates

Discussion

I first clarified the requirements and explained why I would prioritize Consistency over Availability, since overselling inventory should be avoided.

Some of the design choices I discussed:

• SQL over NoSQL for ACID guarantees.
• REST APIs for client communication.
• gRPC for service-to-service communication.
• Redis as the cache layer.
• Bloom Filter to reduce unnecessary database lookups.
• Master-Replica database architecture.
• Basic Product table containing UUID, name, description, price and available quantity.

Follow-up Questions

1. What if Redis goes down?

I initially answered that Redis should run as a Redis Cluster.

The interviewer then asked:

What if the entire Redis cluster becomes unavailable?

He was looking for an application-level L1 in-memory cache as an additional fallback.

2. Multiple users requesting the same product

He then asked what would happen if hundreds of users requested the same product simultaneously.

I suggested batching duplicate requests so that only distinct product IDs would hit the database. I don't think I explained this idea very clearly, so we moved on.

3. Multiple users purchasing the same product

Next, he asked how multiple users purchasing the same item simultaneously should be handled.

I first suggested locking writes. After some discussion, we converged on using Redis atomic decrement operations for inventory management.

Overall, the round was highly discussion-oriented, with most questions building on previous answers.

Round 2 – DSA

Interviewers: Senior Director & Principal Engineer

Q1: Print BST nodes in ascending order

Given a BST, print all nodes in ascending order.

I implemented the standard recursive inorder traversal.

The Senior Director then asked whether the solution would still work if the tree contained a very large number of nodes.

Initially, I only thought about the O(n) time complexity. After discussing how recursion works, I realized he was referring to the possibility of stack overflow on highly skewed trees.

When asked for alternatives, I mentioned increasing the process stack size (something I'd done previously during competitive programming), while also acknowledging that this would be environment-specific and not a production solution.

I also considered an iterative traversal but incorrectly dismissed it during the interview because it would still use O(h) auxiliary space. In hindsight, that would have been the practical solution, and I was simply not familiar with Morris Traversal.

Q2: Longest Subarray with At Most 2 Distinct Elements

I proposed a binary search on the answer combined with fixed-size window validation instead of the standard sliding window approach.

The interviewer asked me to implement it.

After reading through the implementation, he pointed out that the problem could be solved directly using a sliding window.

I agreed, explained the sliding window solution, and asked whether he wanted me to implement it instead. He replied that it wasn't necessary.

Interestingly, the interview concluded after around 35 minutes, although the slot was scheduled for one hour.

Result

Rejected after Round 2.

Hopefully this helps anyone preparing for Moody's backend interviews.