Meesho SDE-1 — Hiring Structure, Syllabus & 8-Week Prep Plan 2026
Meesho hires SDE-1s through a rigorous process that goes beyond standard DSA. The journey includes a challenging online assessment (often featuring Graph and Digit DP), a machine-coding round where you build working software, and design discussions focused on e-commerce scalability, idempotency, and fault tolerance.
3 coding problems in 90–165 min (Medium–Hard) · Machine coding round · LLD/System design · Hiring manager round.
Last updated:
Exam Pattern
3 coding problems in 90–165 min (Medium–Hard) · Machine coding round · LLD/System design · Hiring manager round.
| Section | Questions | Time | Type | Difficulty |
|---|---|---|---|---|
| Online assessment | 3 coding problems (+ optional MCQs) | 90–165 min | DSA (Med–Hard) | Hard |
| Machine coding | 1 project task | 60–90 min | Build working software + LLD | Medium–Hard |
| DSA interview | 1–2 problems | 45–90 min | Live coding & optimization | Hard |
| LLD / system design | Varies | 45–60 min | Interfaces, scalability, trade-offs | Medium–Hard |
| Hiring manager | Varies | 30–60 min | Ownership, impact, culture | Medium |
Section-Wise Syllabus
Everything that appears in the assessment, grouped by section.
1. DSA & Problem Solving
Arrays & strings
- • Prefix sums
- • Difference arrays
- • Two pointers
- • Sliding window
- • Hashing
- • Sorting-based optimisation
- • Subarrays & subsequences
- • Frequency counting
- • Minimum window substring
- • String hashing
- • Coordinate compression
Linked lists
- • Reverse in groups of k
- • Detect & find cycle entry
- • Merge k sorted lists
- • Clone list with random pointers
- • Flatten multilevel list
- • Palindrome check
Stacks & queues
- • Monotonic stack
- • Largest rectangle in histogram
- • Sliding window maximum
- • Min stack
- • Expression evaluation
- • Task scheduler design
Trees & BSTs
- • Lowest common ancestor
- • Serialize & deserialize
- • Maximum path sum
- • Tree views
- • Vertical & boundary traversal
- • Binary lifting basics
Graphs (High weightage)
- • BFS & DFS
- • Multi-source BFS
- • 0–1 BFS
- • Cycle detection (Directed/Undirected)
- • Topological sort
- • Dijkstra’s algorithm
- • DSU
- • Number of islands
- • Word ladder
- • Bridges & articulation points
Dynamic programming
- • Digit DP (Reported in OAs)
- • 1D & Grid DP
- • 0/1 & Unbounded knapsack
- • Subset sum
- • Edit distance
- • Stock buy-sell
- • Tree DP
- • Bitmask DP
2. Machine Coding & Design
LLD principles
- • SOLID principles
- • Class design & interfaces
- • Factory pattern
- • Strategy pattern
- • Observer pattern
- • Repository pattern
- • State pattern
- • Dependency injection
- • Thread safety
- • Unit testing
System design (E-commerce focus)
- • Cart & checkout lifecycle
- • Inventory reservation with expiry
- • Idempotency in APIs
- • Payment retries & callbacks
- • Scalable product search
- • Notification service
- • Flash-sale handling
- • Consistency vs Availability (CAP)
3. Core CS & Engineering
DBMS
- • ACID properties
- • Indexing strategies
- • Transactions & isolation levels
- • Joins & window functions
- • Normalisation
- • Deadlocks
- • Sharding & replication basics
OS & networking
- • Process vs Thread
- • Race conditions & Mutex/Semaphore
- • Paging & virtual memory
- • TCP vs UDP
- • HTTP/HTTPS
- • Load balancing
- • Caching & message queues
Most Asked Topics
Highest-frequency areas across recent test papers.
Graph multi-source BFS
Used for reachability and shortest distance in delivery networks with multiple starting points.
Digit DP constraints
Frequently reported in recent assessments: counting numbers with digit sums or specific adjacent digit rules.
Machine coding (Social Feed)
Implementing follow/unfollow and fetching top N posts using efficient data structures (Heaps + Graphs).
API Idempotency
How to prevent duplicate orders or charges during network failures—a common design question.
Inventory locking
Mechanisms to prevent overselling the same item during high-concurrency events (Flash sales).
Free Resources
Curated practice links per section.
Machine coding & LLD
System design
50+ DSA Practice Problems
Solve in order — arrays and strings first, then sorting and recursion.
Arrays & strings
- Smallest missing positive integer
- Product of array except self
- Minimum window substring
- Longest consecutive sequence
- Group anagrams
- Subarray sum equals K
Linked lists & stacks
- Reverse in groups of k
- Clone list with random pointers
- Next greater element
- Largest rectangle in histogram
- Sliding window maximum
Trees & graphs
- Lowest common ancestor
- Serialize & deserialize
- Number of islands
- Course schedule
- Word ladder
- Dijkstra's shortest path
DP & advanced
- Digit DP: Count numbers with digit sum K
- Edit distance
- Longest increasing subsequence
- LRU cache implementation
- Trie: Prefix matching
Previous Year Questions & Patterns
Repeat coding questions with the expected approach.
Coding assessment style
- Find reachability in a graph with constraints on specific edges (Multi-source BFS/DFS).
- Count numbers in range [L, R] where no two adjacent digits are same (Digit DP).
- Find the minimum swaps required to sort an array using cycle decomposition.
- Implement a social media feed with follow/unfollow and getTopPosts(N).
- Detect a cycle in a directed graph using DFS colouring.
Design & LLD tasks
- Design a Splitwise-like expense sharing application.
- Design a parking lot management system with different vehicle types.
- Design an e-commerce checkout system handling inventory reservation and payment callbacks.
- How would you handle a payment service outage in an order lifecycle?
- Explain how you would scale product search for millions of users.
Core CS & HR
- Explain ACID properties with a banking transaction example.
- What is a race condition? How do you prevent it using semaphores?
- Difference between process and thread context switching.
- Describe a time you took ownership of a critical failure and resolved it.
- Why do you want to join Meesho’s engineering team?
20+ SQL Query Bank
Write these out by hand — joins and subqueries are asked in both the test and the interview.
Order Analysis
Top spending users
SELECT user_id, SUM(order_amount)
FROM orders
WHERE status = 'DELIVERED'
GROUP BY user_id
ORDER BY SUM(order_amount) DESC
LIMIT 10;Monthly growth rate
SELECT DATE_TRUNC('month', order_date) AS month,
COUNT(*) AS total_orders,
LAG(COUNT(*)) OVER (ORDER BY DATE_TRUNC('month', order_date)) AS prev_month_orders
FROM orders
GROUP BY 1;Inventory & Sellers
Out of stock items by seller
SELECT seller_id, COUNT(*)
FROM inventory
WHERE stock_quantity = 0
GROUP BY seller_id
HAVING COUNT(*) > 5;Seller ranking by city
SELECT seller_name, city, rating,
RANK() OVER (PARTITION BY city ORDER BY rating DESC) as city_rank
FROM sellers;DBMS & Core Interview Q&A
Short answers you should be able to say out loud.
What is the purpose of a Write-Ahead Log (WAL)?
It ensures atomicity and durability by logging changes to a stable storage before applying them to the database.
Explain the difference between optimistic and pessimistic locking.
Optimistic assumes no conflict and checks at commit; pessimistic locks the record immediately to prevent any concurrent access.
What is database sharding?
Horizontal partitioning of a database into smaller, faster, more easily managed parts called shards.
Why use indexing?
To speed up data retrieval at the cost of slower writes and additional storage space.
OOPs Concepts + 10 Code Snippets
Theory plus the exact snippets asked in the technical round.
Composition vs Inheritance
Meesho rounds probe why 'has-a' (composition) is often preferred over 'is-a' (inheritance) for flexible design.
Strategy Pattern
Used to define a family of algorithms (e.g., different discount calculations) and make them interchangeable.
Observer Pattern
Ideal for notification systems where multiple services need to react to an order state change.
Interface Segregation
Ensuring a class doesn't have to implement methods it doesn't use, keeping the system clean.
LRU Cache (Hash Map + Doubly Linked List)
class LRUCache {
Node head, tail;
Map<Integer, Node> map;
int capacity;
public int get(int key) {
if (!map.containsKey(key)) return -1;
Node node = map.get(key);
remove(node);
addToHead(node);
return node.value;
}
public void put(int key, int value) {
if (map.containsKey(key)) remove(map.get(key));
if (map.size() == capacity) {
map.remove(tail.key);
remove(tail);
}
Node newNode = new Node(key, value);
map.put(key, newNode);
addToHead(newNode);
}
}Social Feed Skeleton (Max-Heap for Top Posts)
class FeedService {
Map<Integer, Set<Integer>> following = new HashMap<>();
Map<Integer, List<Post>> userPosts = new HashMap<>();
public List<Post> getFeed(int userId, int n) {
PriorityQueue<Post> pq = new PriorityQueue<>((a, b) -> b.timestamp - a.timestamp);
for (int followedId : following.getOrDefault(userId, new HashSet<>())) {
pq.addAll(userPosts.getOrDefault(followedId, new ArrayList<>()));
}
List<Post> result = new ArrayList<>();
while (n-- > 0 && !pq.isEmpty()) result.add(pq.poll());
return result;
}
}Operating System Basics
Scheduling, deadlock and memory management essentials.
Concurrency & Deadlocks
- • Mutual Exclusion
- • Hold and Wait
- • No Preemption
- • Circular Wait
- • Prevention: Resource ordering or Banker's algorithm
Memory Management
- • Paging vs Segmentation
- • Thrashing
- • Virtual memory implementation
- • LRU Page Replacement
4-Week Preparation Roadmap
From zero to test-ready in 28 days.
Arrays & Strings
- Two pointers, Sliding window, Hashing
- Solve 15 Med-Hard problems
Goal: Master basic data manipulation and string algorithms.
Linked Lists & Stacks
- Groups of K, cycle detection, Monotonic stack
- Implement LRU Cache
Goal: Understand memory pointers and linear structures.
Trees & Heaps
- LCA, Serialisation, Tree DP basics
- Solve Top-K problems
Goal: Master recursive thinking and priority queues.
Graphs (Deep Dive)
- Multi-source BFS, Dijkstra, DSU, Topological sort
- Solve 10 graph problems
Goal: Build confidence in graph traversal and connectivity.
Dynamic Programming
- Grid DP, Knapsack, Digit DP
- Focus on state transitions
Goal: Master complex state management and range counting.
Machine Coding
- Build Splitwise or Parking Lot from scratch
- Focus on LLD and SOLID
Goal: Create clean, testable, and working software.
System Design & Core CS
- E-commerce lifecycle, Idempotency, DBMS, OS
- Distributed system basics
Goal: Learn to scale systems and reason about trade-offs.
Revision & Mocks
- Timed OAs (3 problems in 90 min)
- Mock interviews & HR prep
Goal: Refine speed and communication skills.
Exam Day Strategy
Score targets and time allocation.
Section targets
- Problem 1 (Medium): Finish in 25-30 minutes.
- Problem 2 (Medium/Hard): Allocate 40-45 minutes.
- Problem 3 (Hard/Graph/DP): Reserve 60 minutes for complex logic and debugging.
Coding time split (50 min)
- 25m
- 45m
- 60m
Interview Process
What follows the online test.
Technical Intensity
- • Strong focus on code quality in machine coding
- • DSA rounds probe edge cases and time/space optimization
- • Design rounds test product thinking alongside engineering
Mock Test Plan
Four simulations to run before the real test.
Assessment Mock
- • 3 Problems: 1 Graph (Hard), 1 String (Med), 1 DP (Med)
- • 90-minute timer
Machine Coding Mock
- • Build a 'Mini E-commerce Order Tracker'
- • Time: 90 minutes
- • Requirement: Working code + LLD Diagram
Final Checklist
Tick all of these before test day.
Recent Interview Experiences
First-hand write-ups from students who actually sat the Meesho process.
Be the first to share a Meesho interview experience.
Frequently Asked Questions
Is Meesho SDE-1 harder than other unicorns?
Yes, Meesho is known for asking advanced topics like Digit DP and multi-source BFS even for junior roles.
What is the most important round?
Both the OA and Machine Coding are high-filtering rounds. Strong design skills are required in later stages.
Want the full structured prep for Meesho?
The Premium Vault covers Aptitude, Core CS, DSA, SQL and HR rounds with module-wise courses and drill sheets.
Related Prep
Next steps chosen from the Meesho pattern and other Indian Unicorn recruiters.
Other Indian Unicorn companies
Flipkart Interview Prep Guide
Flipkart exam pattern, syllabus and previous year questions · ₹18–32 LPA · intern ₹80k–1.2L/mo.
Swiggy Interview Prep Guide
Swiggy exam pattern, syllabus and previous year questions · ₹16–30 LPA.
Zomato & Blinkit Interview Prep Guide
Zomato & Blinkit exam pattern, syllabus and previous year questions · ₹14–28 LPA.
Core CS subjects for this pattern
DBMS & SQL Essentials
Normalisation, keys, transactions and the SQL queries asked in written rounds.
Operating System Essentials
Processes, scheduling, deadlock and memory management in interview-ready form.
Computer Networks Essentials
OSI vs TCP/IP, HTTP, DNS and the networking questions freshers actually get.
Recommended practice path