Meesho Open Campus Recruitment 2025: My Interview Journey & Key Learnings

Landing a role at Meesho – one of India’s fastest-growing e-commerce platforms – is a dream for many. I recently participated in their 2025 Open Campus Recruitment and documented my journey to help future aspirants. Here’s a detailed breakdown of the process, including the exact problems I solved!

⚡ Hackathon Round (Online Assessment)

Stats: 158,624 candidates registered!
Duration: 90 minutes
Result: I advanced by solving all three problems.

Disclaimer: These problems are recalled from memory after the round. The exact wording may differ, but the core logic and challenges remain the same.

Problem 1: Arrays and Queries

Task:

You’re given an array A and need to handle up to 10^6 queries of two types:

• Update: Set A[L] = X

• Search: In a range [L, R], find the first index P where A[P] ≤ X. Return P (1-based), or -1 if none exists.

Problem 2: Node Queries in a Tree

Task:

Given a rooted tree (root = 1), handle two types of queries efficiently:

• Type 1 (X Y): Add Y to all nodes in the subtree rooted at X

• Type 2 (X Y): Add Y to all nodes not in the subtree rooted at X

Problem 3: Maximum Profit from Binary Strings

Task:
Given two binary strings S and Q of length N, select non-empty substrings S' and Q' of equal length, compute:

iniCopyEditX = S' ⊕ Q'  (bitwise XOR)
Profit = (length(X) // 2) * decimal(X)

Goal: Maximize the profit.

---

🔍 Subsequent Interview Rounds

After clearing the hackathon, I received invites for virtual interviews via Google Meet:

Round 1: Problem Solving (30 mins)

Competencies Tested: DSA, Complexity Analysis
Problem: Unique Product ID Filtering
Task: Remove all duplicate IDs from a sorted linked list.
Optimized Solution: Single-pass traversal with dummy nodes.

python

Example:  
Input: [1,1,1,2,3] → Output: [2,3]
Input: [1,2,3,3,4,4,5] → Output: [1,2,5]

Round 2: Machine Coding (60 mins)

The Turning Point: My First LLD Experience

After successfully clearing the hackathon and DSA rounds, I faced the Machine Coding (LLD) round - my first-ever low-level design interview. While I implemented core functionality for the doctor booking system and passed sample test cases, I didn't receive further communication. This indicated I didn't meet Meesho's bar for clean, extensible OOP design - a crucial lesson for future attempts.

Problem (As I Remember It): Doctor Appointment Booking System

To build a console-based system with the following functionalities:

• Register Doctor with availability slots

• Register Patient with a unique name

• Book Appointment: A patient can book one slot at a time with a doctor

• Cancel Appointment using booking ID

• Show Available Slots for a specialization

Where I Likely Fell Short in LLD Round

1. Structural Rigidity
   My solution likely had monolithic classes instead of decoupled components.

2. Concurrency Gaps
   Didn't fully handle race conditions during slot booking - critical for real-world systems.

3. Extensibility Misses
   Failed to design for future requirements (e.g., waitlists, doctor calendars) mentioned in the problem statement.

4. SOLID Violations
   Probably implemented "working code" rather than "maintainable code" with proper interfaces.

Key Statistics from My Journey

Advice for Future Candidates

1. Practice LLD Early

2. Prioritize Extensibility
   Always ask: "How would this handle [new requirement X]?" during design.

3. Concurrency is Non-Negotiable
   Master synchronized, locks, and thread safety patterns in your language.

4. Learn from Rejections
   My first LLD failure became my biggest growth opportunity - yours will too.

Though I didn't clear the final bar, the process taught me more than any course could. For those preparing: Start LLD practice today - it's a different skillset from DSA! Share your experiences below 👇