Myntra SDE-1 — Hiring Pattern, Technical Syllabus & 8-Week Prep Roadmap 2026
Myntra's SDE-1 hiring is a product-engineering focused process rather than a mass-recruitment aptitude exam. It starts with a rigorous coding assessment followed by multiple rounds covering DSA, Low-Level Design (LLD), CS fundamentals, and hiring manager discussions. This guide provides a comprehensive roadmap for both backend and frontend tracks, focusing on real-world engineering problem solving.
2–3 DSA problems in 60–90 min + technical MCQs (10-20 min) followed by multiple interview rounds.
Last updated:
Exam Pattern
2–3 DSA problems in 60–90 min + technical MCQs (10-20 min) followed by multiple interview rounds.
| Section | Questions | Time | Type | Difficulty |
|---|---|---|---|---|
| Online Coding | 2–3 problems | 60–90 min | Coding (DSA) | Medium–Hard |
| Technical MCQs | 10–20 | 10–20 min | MCQ (CS Fundamentals) | Medium |
| DSA Interview | 1–2 problems | 45–60 min | Live Coding | Medium–Hard |
| Technical / LLD Round | 1–2 design tasks | 45–60 min | LLD & Fundamentals | Hard |
| Hiring Manager | Varies | 30–60 min | Product & Ownership | Medium |
Section-Wise Syllabus
Everything that appears in the assessment, grouped by section.
1. Core DSA & Algorithms
Arrays & Strings
- • Prefix sums
- • Difference arrays
- • Two pointers
- • Sliding window
- • Hashing
- • Sorting-based optimisation
- • Subarrays and subsequences
- • Frequency counting
- • Palindromes
- • Anagrams
- • String matching
- • Minimum window
Linked Lists
- • Reverse (iterative/recursive)
- • Reverse in groups of k
- • Detect cycle
- • Cycle-entry point
- • Middle node
- • Merge k sorted lists
- • Palindrome check
- • Clone with random pointers
Stacks & Queues
- • Balanced parentheses
- • Min stack
- • Next greater element
- • Largest rectangle in histogram
- • Sliding-window maximum
- • Queue using stacks
- • Monotonic stack
- • Expression evaluation
Trees & Graphs
- • Height & diameter
- • LCA
- • Serialize & deserialize
- • Build from traversals
- • Root-to-leaf path sum
- • Vertical & boundary traversal
- • BFS & DFS
- • Topological sort
- • Dijkstra
- • DSU
- • Number of islands
- • Word ladder
Dynamic Programming
- • House robber
- • Coin change
- • 0/1 knapsack
- • Longest increasing subsequence
- • Edit distance
- • Stock buy-sell series
- • Grid DP
- • Partition DP
- • Tree DP basics
2. Backend Specialization
Technologies
- • Java / Spring Boot
- • Node.js
- • REST APIs
- • Microservices architecture
Engineering Fundamentals
- • Database indexing
- • Caching (Redis)
- • Messaging (Kafka/RabbitMQ)
- • Resilience & Circuit breakers
- • API design
- • Idempotency
3. Frontend Specialization
Core Web
- • JavaScript Fundamentals
- • TypeScript
- • React / Next.js
- • State management (Redux/Context)
Performance & Rendering
- • Browser rendering pipeline
- • DOM and events
- • Performance optimisation
- • Web Accessibility
- • Frontend testing (Jest/Cypress)
4. Low-Level Design (LLD)
OO Design
- • SOLID principles
- • Design Patterns (Factory, Strategy, Observer, Singleton)
- • Composition vs Inheritance
- • Thread-safe classes
E-commerce Use Cases
- • Shopping cart system
- • Product catalogue with filters
- • Order management service
- • Coupon engine
- • Inventory reservation
- • Notification service
Most Asked Topics
Highest-frequency areas across recent test papers.
Minimum swaps to sort
Use cycle decomposition by mapping original indices after sorting a copy of the array.
Longest consecutive sequence
Requires O(n) approach using a hash set to track sequence starts.
Peak element discovery
Binary search application on unsorted arrays with specific property gradients.
Directed graph cycle detection
Critical for dependency tracking; use DFS with recursion stack or Kahn's algorithm (BFS).
Maximum product subarray
Tricky DP because negative values can flip roles of current min and max.
LRU Cache design
Standard LLD/DSA mix requiring Hash Map and Doubly Linked List for O(1) operations.
Free Resources
Curated practice links per section.
System Design & LLD
Frontend & Backend
50+ DSA Practice Problems
Solve in order — arrays and strings first, then sorting and recursion.
Arrays & Strings (Top 10)
- Smallest missing positive integer
- Longest substring without repetition
- Maximum subarray sum (Kadane)
- Product of array except self
- Group anagrams
- Minimum window substring
- Subarray sum equals K
- Merge intervals
- Minimum swaps to sort
- Longest consecutive sequence
Advanced (Trees, Graphs, DP)
- Lowest Common Ancestor (Binary Tree)
- Serialize and deserialize a binary tree
- Number of islands (Grid BFS/DFS)
- Dijkstra's shortest path algorithm
- Word ladder problem
- House robber / Coin change (DP)
- Edit distance (DP)
- Stock buy-sell series (I, II, III)
- Directed graph cycle detection
- LRU Cache implementation
Previous Year Questions & Patterns
Repeat coding questions with the expected approach.
DSA / Problem Solving
- Find the number of ways to reach a target sum using given numbers (DP).
- Find a peak element in an array using O(log N) approach.
- Find the longest Fibonacci-like subsequence using DP and value-to-index mapping.
- Reverse a linked list in O(1) space and explain the complexity.
- Detect a cycle in a directed graph using DFS colouring.
Low-Level Design (LLD)
- Design a shopping-cart system supporting product variants, coupons, and inventory reservation.
- Design a product catalogue supporting size, colour, and brand filters with efficient pagination.
- Design a notification service with retries, rate limiting, and support for multiple channels (Email/SMS).
- Design a delivery-status tracker that handles eventual consistency and duplicate events.
Technical Fundamentals
- What happens when you enter a URL in a browser? (DNS to Rendering)
- Explain the difference between caching and database indexing.
- How do you handle price changes between a user adding an item to the cart and checking out?
- What is idempotency in an API and why is it important for payment systems?
- Explain the circuit breaker pattern in microservices.
20+ SQL Query Bank
Write these out by hand — joins and subqueries are asked in both the test and the interview.
E-commerce Queries
Second highest distinct price
SELECT MAX(price)
FROM products
WHERE price < (
SELECT MAX(price)
FROM products
);Top products per category (Window Function)
SELECT category, product_id, sales,
RANK() OVER (
PARTITION BY category
ORDER BY sales DESC
) AS rank_in_category
FROM product_sales;Frequent buyers
SELECT user_id
FROM orders
GROUP BY user_id
HAVING COUNT(*) > 3;DBMS & Core Interview Q&A
Short answers you should be able to say out loud.
What are ACID properties?
Atomicity, Consistency, Isolation, and Durability — ensuring reliable database transactions.
Difference between TCP and UDP?
TCP is connection-oriented and reliable; UDP is connectionless and faster but unreliable.
What is database normalization?
Organizing data to reduce redundancy and improve data integrity (1NF, 2NF, 3NF, BCNF).
What is a deadlock?
A situation where two or more processes are blocked forever, each waiting on the other.
OOPs Concepts + 10 Code Snippets
Theory plus the exact snippets asked in the technical round.
SOLID Principles
Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion.
Composition vs Inheritance
Favoring composition allows for more flexible and decoupled code compared to deep inheritance hierarchies.
Design Patterns
Factory (object creation), Strategy (swapping algorithms), Observer (event systems), Singleton (guaranteed single instance).
Thread Safety
Writing code that functions correctly during simultaneous execution by multiple threads.
LRU Cache Skeleton (Hash Map + Doubly Linked List)
class Node {
int key, value;
Node prev, next;
}
class LRUCache {
private Map<Integer, Node> map = new HashMap<>();
private Node head, tail;
private int capacity;
public int get(int key) {
if (map.containsKey(key)) {
Node node = map.get(key);
moveToHead(node);
return node.value;
}
return -1;
}
public void put(int key, int value) {
// implementation of put with eviction logic
}
}Strategy Pattern for Coupon Engine
interface DiscountStrategy {
double apply(double total);
}
class PercentageDiscount implements DiscountStrategy {
private double percent;
public double apply(double total) { return total * (1 - percent/100); }
}
class FlatDiscount implements DiscountStrategy {
private double amount;
public double apply(double total) { return total - amount; }
}Operating System Basics
Scheduling, deadlock and memory management essentials.
Process & Thread
- • Process vs Thread memory sharing
- • Context switching overhead
- • Thread safety mechanisms (Mutex, Semaphores)
- • CPU scheduling algorithms
Networking for SDEs
- • HTTP/HTTPS differences
- • TCP 3-way handshake
- • REST API principles
- • Load balancing strategies
- • DNS resolution process
4-Week Preparation Roadmap
From zero to test-ready in 28 days.
Arrays, Hashing & Complexity
- Solve 10 array problems (Prefix sum, Sliding window)
- Revise Time/Space complexity limits
Goal: Master basic array manipulation and optimization.
Two Pointers & Binary Search
- Peak element, Search in rotated array
- Two sum variations
Goal: Learn to handle sorted and structured data efficiently.
Linked Lists & Stacks/Queues
- Reverse in groups of k
- Largest rectangle in histogram
- Min stack
Goal: Understand pointer manipulation and monotonic structures.
Trees & Recursion
- LCA, Diameter, Tree views
- Serialization/Deserialization
Goal: Get comfortable with tree traversals and recursive thinking.
Graphs & Disjoint Sets
- Number of islands, Dijkstra
- Cycle detection in directed graphs
Goal: Master connectivity and shortest path problems.
Dynamic Programming
- Coin change, Edit distance
- Stock buy-sell problems
Goal: Identify overlapping subproblems and optimal substructure.
OO Design, DBMS & OS
- SOLID principles, Design Patterns
- SQL Window functions, ACID properties
- Process vs Threads
Goal: Strengthen CS fundamentals and design thinking.
Mock Tests & LLD Practice
- Timed online assessments
- Design Shopping Cart / Notification Service
- Project walkthrough
Goal: Simulate real interview conditions and refine communication.
Exam Day Strategy
Score targets and time allocation.
Section targets
- Brute Force First: State the simple solution to clarify understanding before optimizing.
- Constraint Check: Identify N size to choose between O(N), O(N log N), or O(N^2).
- Test Cases: Dry run with empty, single-element, and maximum-size inputs.
- LLD Discussion: Clarify requirements and identify entities before writing class diagrams.
- Ownership (HM Round): Prepare a 2-minute and 10-minute version of your best project.
Coding time split (50 min)
- 45 min: Core DSA logic
- 15 min: Edge case handling
- 15 min: Code cleanup & modularity
- 15 min: Complexity analysis
Interview Process
What follows the online test.
Online Assessment
- • 2-3 coding problems
- • Medium to Hard difficulty
- • Platform: Mettl / HackerRank
DSA Rounds
- • Live coding on shared editor
- • Focus on clean code and logic optimization
- • Constraint-heavy problems
LLD / Machine Coding
- • Design a functional component
- • Focus on extensibility and SOLID principles
- • May involve writing running code
Hiring Manager
- • Cultural fitment
- • Past project deep-dive
- • Product thinking scenarios
Mock Test Plan
Four simulations to run before the real test.
Myntra Pattern Mock 1
- • 1 Easy, 2 Medium DSA
- • 15 SQL MCQs
- • Total 90 mins
LLD Design Mock
- • Design an Inventory Reservation system
- • Handle race conditions
- • Support multi-region filters
Final Checklist
Tick all of these before test day.
Recent Interview Experiences
First-hand write-ups from students who actually sat the Myntra process.
Be the first to share a Myntra interview experience.
Frequently Asked Questions
Is Myntra's process different from mass-recruiters?
Yes, it is product-company focused, prioritizing deep technical skills, LLD, and system design over generic aptitude.
What is the difficulty level of coding problems?
Usually LeetCode Medium, with at least one problem pushing toward Hard difficulty.
Does Myntra ask for frontend-specific DSA?
Frontend roles still involve standard DSA rounds, though problem contexts may lean toward string manipulation or DOM-like tree structures.
Want the full structured prep for Myntra?
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 Myntra 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.
OOPs Essentials for Interviews
The four pillars with the exact code snippets interviewers ask you to explain.
Computer Networks Essentials
OSI vs TCP/IP, HTTP, DNS and the networking questions freshers actually get.
Recommended practice path