Meesho Placement Papers 2026 — Complete Preparation Guide

Last Updated: March 2026

Meta Description: Prepare for Meesho 2026 placements with our comprehensive guide featuring hiring process details, 20+ solved technical questions on system design, DSA, backend engineering, and behavioral interview tips for India's largest social commerce platform.

---

Company Overview

Meesho is India's fastest-growing and largest social commerce platform, enabling millions of small businesses and individuals to start online stores via social media channels like WhatsApp, Instagram, and Facebook. Founded by IIT Delhi alumni, Meesho has democratized e-commerce for Bharat — making it possible for anyone to become an entrepreneur with zero investment.

Attribute	Details
Founded	2015 by Vidit Aatrey and Sanjeev Barnwal (IIT Delhi)
Headquarters	Bangalore, India
Employees	2,000+
Valuation	~$5 billion (peak; adjusted in 2023-24 but still unicorn)
Users	150+ million monthly active users
Sellers	15+ million registered sellers
Orders	200+ million orders per month
Key Investors	SoftBank, Prosus, Meta (Facebook), Elevation Capital, B Capital
Tech Stack	Go, Java, Kotlin, Python, React, React Native, AWS, Kafka, Redis, PostgreSQL, Elasticsearch

Why Work at Meesho?

• Massive scale — 200M+ orders/month, complex distributed systems
• Competitive packages — SDE-1 salary ranges from ₹25-45 LPA (base + ESOPs)
• High-growth startup culture — fast promotions, high ownership
• Tech-first company — engineering is central to the business
• Social impact — enabling millions of micro-entrepreneurs across India

---

Eligibility Criteria

Parameter	Requirement
Degree	B.E./B.Tech (CS/IT preferred), M.Tech
CGPA	7.0+ (varies by campus)
Backlogs	No active backlogs
Preferred Skills	Strong DSA, System Design awareness, Backend Engineering

---

Hiring Process

Round 1: Online Assessment (90-120 minutes)

• 3-4 coding problems on HackerRank/Codility
• Difficulty: Medium to Hard
• Topics: Arrays, Strings, Trees, Graphs, Dynamic Programming, Greedy
• Focus on optimal solutions with clean code

Round 2: Technical Interview 1 — DSA Deep Dive (60 minutes)

• 2 coding problems (Medium-Hard)
• Emphasis on approach, edge cases, time/space complexity
• Follow-up optimizations
• Code must compile and pass all test cases

Round 3: Technical Interview 2 — System Design (60 minutes)

• Design a real-world system (e.g., Meesho order system, feed, search)
• Focus on scalability, availability, consistency trade-offs
• Database choices, caching strategies, message queues
• API design and microservices architecture

Round 4: Technical Interview 3 — Low-Level Design (LLD) (45-60 minutes)

• Design classes and interfaces for a system component
• SOLID principles, Design Patterns
• Clean code, extensibility, testability
• Example: Design a notification system, rate limiter, parking lot

Round 5: Hiring Manager Round (30-45 minutes)

• Behavioral questions (STAR format)
• Past project deep dive — impact, challenges, learnings
• Culture fit — ownership, bias for action, customer obsession
• Why Meesho? Career goals

---

Meesho Technical Interview Questions with Solutions

Data Structures & Algorithms

Question 1

Given an array of integers, find the length of the longest subarray with sum equal to K.

def longest_subarray_sum_k(arr, k):
    prefix_sum = 0
    max_len = 0
    sum_index = {0: -1}  # base case: prefix sum 0 at index -1
    
    for i, num in enumerate(arr):
        prefix_sum += num
        
        if prefix_sum - k in sum_index:
            max_len = max(max_len, i - sum_index[prefix_sum - k])
        
        if prefix_sum not in sum_index:
            sum_index[prefix_sum] = i  # Store first occurrence
    
    return max_len

# Example: arr = [1, 2, 3, 1, 1, 1, 1], k = 3
# Output: 4 (subarray [1, 1, 1] is wrong — it's [3] or [1,1,1])
# Actually: [1,1,1] at indices 3-5 has sum 3 and length 3
# [1,1,1,1] would need sum 4... let me recalculate
# Subarrays with sum 3: [1,2], [3], [1,1,1] → max length = 3

# Time: O(n), Space: O(n)

---

Question 2

Find the median of two sorted arrays in O(log(min(n,m))) time.

def findMedianSortedArrays(nums1, nums2):
    if len(nums1) > len(nums2):
        nums1, nums2 = nums2, nums1
    
    n, m = len(nums1), len(nums2)
    low, high = 0, n
    
    while low <= high:
        cut1 = (low + high) // 2
        cut2 = (n + m + 1) // 2 - cut1
        
        left1 = nums1[cut1 - 1] if cut1 > 0 else float('-inf')
        left2 = nums2[cut2 - 1] if cut2 > 0 else float('-inf')
        right1 = nums1[cut1] if cut1 < n else float('inf')
        right2 = nums2[cut2] if cut2 < m else float('inf')
        
        if left1 <= right2 and left2 <= right1:
            if (n + m) % 2 == 0:
                return (max(left1, left2) + min(right1, right2)) / 2
            return max(left1, left2)
        elif left1 > right2:
            high = cut1 - 1
        else:
            low = cut1 + 1
    
    return -1

# Time: O(log(min(n,m))), Space: O(1)

---

Question 3

Given a binary tree, find the maximum path sum. A path can start and end at any node.

class Solution:
    def maxPathSum(self, root):
        self.max_sum = float('-inf')
        
        def dfs(node):
            if not node:
                return 0
            
            left = max(0, dfs(node.left))    # Ignore negative paths
            right = max(0, dfs(node.right))
            
            # Path through current node
            self.max_sum = max(self.max_sum, left + node.val + right)
            
            # Return max path going through one side only
            return node.val + max(left, right)
        
        dfs(root)
        return self.max_sum

# Time: O(n), Space: O(h) where h = height of tree

---

Question 4

Implement a function to merge K sorted linked lists efficiently.

import heapq

def mergeKLists(lists):
    heap = []
    dummy = ListNode(0)
    current = dummy
    
    # Initialize heap with head of each list
    for i, l in enumerate(lists):
        if l:
            heapq.heappush(heap, (l.val, i, l))
    
    while heap:
        val, idx, node = heapq.heappop(heap)
        current.next = node
        current = current.next
        
        if node.next:
            heapq.heappush(heap, (node.next.val, idx, node.next))
    
    return dummy.next

# Time: O(N log K) where N = total nodes, K = number of lists
# Space: O(K) for the heap

---

System Design

Question 5

Design Meesho's order management system handling 200M+ orders per month.

Requirements:

• Place orders from app/web
• Track order status (placed → confirmed → shipped → delivered)
• Handle cancellations and returns
• Support 200M+ orders/month (~77 orders/second average, 500+ peak)

High-Level Architecture:

Client App → API Gateway → Order Service → Order DB (PostgreSQL)
                                ↓
                         Event Bus (Kafka)
                        ↙    ↓    ↘
              Payment   Inventory  Notification
              Service   Service    Service
                                      ↓
                              Push / SMS / Email

Key Design Decisions:

1. Database: PostgreSQL with read replicas. Shard by user_id for horizontal scaling. Archive old orders to cold storage (S3 + Athena for analytics).

2. Order Status Machine:

   CREATED → PAYMENT_PENDING → CONFIRMED → SHIPPED → OUT_FOR_DELIVERY → DELIVERED
                    ↓                            ↓
               PAYMENT_FAILED              RETURNED/CANCELLED
   

3. Event-Driven Architecture: Every state change publishes to Kafka. Downstream services consume events asynchronously — no synchronous coupling.

4. Idempotency: Every order mutation has an idempotency key to prevent duplicate processing. Essential for payment retries.

5. Caching: Redis for hot data (active orders, user's recent orders). Write-through cache for consistency.

6. Search: Elasticsearch for order search (by order ID, product, date range).

Scalability Considerations:

• Horizontal scaling of order service instances behind load balancer
• Database sharding by user_id (even distribution)
• Kafka partitioning by order_id for ordered processing
• CDN for static assets (product images, invoices)

---

Question 6

Design a product recommendation engine for Meesho.

Approach: Hybrid Recommendation System

1. Collaborative Filtering:

   • User-User: "Users who bought X also bought Y"
   • Item-Item: "Products frequently bought together"
   • Matrix factorization (ALS algorithm) on user-item interaction matrix

2. Content-Based Filtering:

   • Product embeddings from product attributes (category, price, brand, color)
   • User profile built from purchase history and browsing behavior
   • Cosine similarity between user profile and product embeddings

3. Real-Time Personalization:

   • Kafka stream processing for real-time events (clicks, cart adds, purchases)
   • Feature store (Redis) for real-time feature serving
   • ML model (TensorFlow/PyTorch) for ranking candidates

Pipeline:

User Request → Candidate Generation (100s) → Ranking Model (top 20) → Business Rules → Display

Key Metrics: CTR (Click-Through Rate), Conversion Rate, Revenue per Session, Diversity Score

---

Low-Level Design

Question 7

Design a notification service that supports push, SMS, and email channels.

from abc import ABC, abstractmethod
from enum import Enum

class NotificationType(Enum):
    PUSH = "push"
    SMS = "sms"
    EMAIL = "email"

# Strategy Pattern for notification channels
class NotificationChannel(ABC):
    @abstractmethod
    def send(self, recipient: str, message: str) -> bool:
        pass

class PushNotification(NotificationChannel):
    def send(self, device_token: str, message: str) -> bool:
        # FCM/APNs API call
        print(f"Push to {device_token}: {message}")
        return True

class SMSNotification(NotificationChannel):
    def send(self, phone: str, message: str) -> bool:
        # Twilio/MSG91 API call
        print(f"SMS to {phone}: {message}")
        return True

class EmailNotification(NotificationChannel):
    def send(self, email: str, message: str) -> bool:
        # SES/SendGrid API call
        print(f"Email to {email}: {message}")
        return True

# Factory Pattern
class NotificationFactory:
    _channels = {
        NotificationType.PUSH: PushNotification,
        NotificationType.SMS: SMSNotification,
        NotificationType.EMAIL: EmailNotification,
    }
    
    @staticmethod
    def get_channel(channel_type: NotificationType) -> NotificationChannel:
        return NotificationFactory._channels[channel_type]()

# Notification Service with retry and template support
class NotificationService:
    def __init__(self):
        self.factory = NotificationFactory()
        self.templates = {}  # template_id -> template
    
    def send(self, user_id: str, channel: NotificationType, 
             template_id: str, params: dict, max_retries=3):
        message = self._render_template(template_id, params)
        recipient = self._get_recipient(user_id, channel)
        
        channel_handler = self.factory.get_channel(channel)
        
        for attempt in range(max_retries):
            try:
                if channel_handler.send(recipient, message):
                    self._log_success(user_id, channel, template_id)
                    return True
            except Exception as e:
                self._log_failure(user_id, channel, attempt, str(e))
        
        self._move_to_dead_letter(user_id, channel, message)
        return False

Design Patterns Used: Strategy, Factory, Template Method, Observer (for event-driven triggers)

---

Question 8

Design a rate limiter using the Sliding Window Log algorithm.

import time
from collections import defaultdict

class SlidingWindowRateLimiter:
    def __init__(self, max_requests: int, window_seconds: int):
        self.max_requests = max_requests
        self.window = window_seconds
        self.logs = defaultdict(list)  # user_id -> [timestamps]
    
    def is_allowed(self, user_id: str) -> bool:
        now = time.time()
        window_start = now - self.window
        
        # Remove expired entries
        self.logs[user_id] = [
            ts for ts in self.logs[user_id] if ts > window_start
        ]
        
        if len(self.logs[user_id]) < self.max_requests:
            self.logs[user_id].append(now)
            return True
        
        return False  # Rate limited

# Usage: 100 requests per minute
limiter = SlidingWindowRateLimiter(max_requests=100, window_seconds=60)

Trade-offs:

• Sliding Window Log: Precise, but memory-intensive (stores all timestamps)
• Fixed Window Counter: Simple, but boundary burst problem
• Sliding Window Counter: Good balance — weighted count of current + previous window
• Token Bucket: Best for bursty traffic, used by AWS API Gateway

---

Backend Engineering

Question 9

What is database sharding? How would you shard Meesho's order database?

Sharding = Horizontal partitioning of data across multiple database instances.

Sharding Strategy for Orders:

• Shard Key: user_id (hash-based distribution)
• Why user_id? Most queries are user-centric (my orders, my history). All of a user's orders on the same shard = no cross-shard queries for common operations.

Implementation:

shard_number = hash(user_id) % total_shards

Challenges & Solutions:

Challenge	Solution
Cross-shard queries (search by order_id)	Maintain order_id → shard mapping in a lookup table or use Elasticsearch
Uneven distribution (hot shards)	Consistent hashing with virtual nodes
Shard rebalancing	Use logical sharding with routing layer; add physical shards without downtime
Transactions across shards	Saga pattern instead of distributed transactions
Analytics queries	Replicate to data warehouse (BigQuery/Redshift) for analytics

---

Question 10

Explain CAP theorem. How does Meesho's architecture handle it?

CAP Theorem: In a distributed system, you can guarantee only 2 of 3:

• Consistency: Every read gets the latest write
• Availability: Every request gets a response (not error)
• Partition Tolerance: System works despite network partitions

In practice, P is mandatory (network failures happen), so the choice is between CP and AP:

Service	Choice	Rationale
Payment Service	CP	Must be consistent — double payments are catastrophic
Product Catalog	AP	Slight staleness is OK; availability is critical for browsing
Order Service	CP (write) + AP (read)	Writes must be consistent; reads can tolerate eventual consistency
Inventory	CP	Overselling must be prevented
Recommendation	AP	Stale recommendations are fine; page must always load
Search	AP	Results can be slightly outdated; must always respond

---

Behavioral Questions

Question 11

Tell me about a time you had to make a technical decision with limited information.

STAR Framework Answer:

• Situation: During hackathon, needed to choose between Redis and MongoDB for a real-time leaderboard
• Task: Make an architecture decision with 24-hour deadline
• Action: Quickly benchmarked both with sample data. Redis sorted sets gave O(log N) rank queries vs. MongoDB's O(N). Chose Redis with MongoDB as persistent backup
• Result: Leaderboard handled 10K concurrent users smoothly. Won first prize. Learned that quick prototyping beats analysis paralysis

---

Preparation Strategy

45-Day Meesho Prep Plan

Week 1-2: DSA Intensive

• LeetCode Medium-Hard: 5 problems/day
• Focus: Arrays, Trees, Graphs, DP, Sliding Window, Two Pointers
• Target: Solve 70+ problems across all patterns

Week 3: System Design

• Read "Designing Data-Intensive Applications" by Martin Kleppmann
• Study: Load Balancing, Caching, Message Queues, Database Sharding
• Practice: Design 5 systems (e-commerce, feed, chat, search, notification)

Week 4-5: LLD + Backend Deep Dive

• SOLID principles, Design Patterns (Factory, Strategy, Observer, Singleton)
• Practice LLD: Parking Lot, Elevator, Food Delivery, Notification System
• Study: Kafka, Redis, PostgreSQL, Microservices, gRPC vs REST

Week 6: Mock Interviews & Revision

• 3-4 mock interviews with peers
• Revise all DSA patterns
• Prepare behavioral stories (STAR format)
• Research Meesho's recent product launches and tech blog posts

---

Related Preparation Guides

• Amazon Placement Papers 2026 — E-commerce tech interviews
• Groww Placement Papers 2026 — Fintech startup interviews
• Slice Placement Papers 2026 — Fintech startup preparation
• BrowserStack Placement Papers 2026 — SaaS product interviews
• TCS Placement Papers 2026 — Large-scale campus hiring
• 30-Day Placement Preparation Plan — Structured approach

---

Frequently Asked Questions

Q: What is the salary at Meesho for SDE-1? A: SDE-1 at Meesho ranges from ₹25-45 LPA (CTC including ESOPs). Base salary is typically ₹18-28 LPA. Exact package varies by campus and performance.

Q: Does Meesho hire from non-IIT colleges? A: Yes, Meesho hires from NITs, IIITs, and top private colleges through campus drives. They also conduct off-campus hiring through referrals and direct applications.

Q: What tech stack should I focus on? A: For interviews, focus on DSA (any language) + System Design. For role preparation, learn Go or Java (backend), React/React Native (frontend), and understand Kafka, Redis, PostgreSQL.

Q: How competitive is Meesho's hiring? A: Very competitive. Typical selection ratio is 1-2% from online assessment to offer. DSA must be strong (solve LeetCode Hard consistently), and system design knowledge is expected even for freshers.

---

Last Updated: March 2026