My Meesho SDE 2 Interview Experience (2025)

Software Development Engineer 2 (SDE2) role interview at Meesho was both challenging and rewarding. I’m sharing my full interview experience each round, the questions asked, my approach and key takeaways to help you prepare better and avoid common mistakes.

My Meesho Software Development Engineer 2(SDE 2) interview process consists of 5 rounds spread across technical and behavioral assessments. Each round tested a different dimension of software engineering from core DSA to real-world design thinking and finally communication and team mindset.

Round 1: Online Coding Assessment

Mode: Remote
Duration: 60 minutes
Difficulty: Medium
Number of Questions: 2

This was the first challenge and probably the most stressful part since it set the tone for the entire interview process. The online test included two algorithmic coding problems designed to evaluate both your problem-solving skills and speed.

Problem 1: Kth Largest Element in an Unsorted Array

Given an unsorted array and an integer k, find the kth largest element.

My Approach

At first, I thought of sorting the array and returning the kth element from the end. That approach is O(n log n) and not optimal for large n.
I used a Min Heap (Priority Queue) of size k, a standard, interview-friendly solution.

Steps I Followed

1. Create a min-heap.
2. Iterate through every element in the array.
3. Add elements to the heap until size becomes k.
4. If size exceeds k, poll (remove) the smallest element.
5. After processing all elements, the heap root (peek) is the kth largest.

Complexity

• Time: O(n log k)
• Space: O(k)

Key Learning Explain the choice (heap vs QuickSelect) and discuss real-world scenarios (e.g. streaming large data where you only keep top-k).

Sample Implementations

Java (Min-Heap)

import java.util.PriorityQueue;
public class KthLargest {
    public static int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> pq = new PriorityQueue<>(); // min-heap
        for (int num : nums) {
            pq.offer(num);
            if (pq.size() > k) {
                pq.poll();
            }
        }
        return pq.peek(); // kth largest
    }
}

Problem 2: Longest Substring Without Repeating Characters

Find the length of the longest substring without repeating characters.

My Approach

Classic sliding window + hashmap/index map technique.

Solution Steps

• Use two pointers: left and right (window boundaries).

• Use a hash map (or fixed-size array for ASCII) to store last seen index of each character.

• Expand the right pointer while characters are unique.

• If a duplicate is found, move left to max(left, lastIndex[char] + 1).

• Track the maximum window length seen.

Complexity

• Time: O(n)

• Space: O(256) for ASCII (or O(min(n, charset))).

Key Learning

Walk through the pointer moves and index updates while explaining correctness and edge cases (empty string, all unique, all same).

Sample Implementations

Java (sliding window with lastIndex array)

public class LongestUniqueSubstring {
    public static int lengthOfLongestSubstring(String s) {
        int[] lastIndex = new int[256]; // store last index + 1 (0 means unseen)
        for (int i = 0; i < 256; i++) lastIndex[i] = -1;
        
        int maxLen = 0, left = 0;
        for (int right = 0; right < s.length(); right++) {
            char ch = s.charAt(right);
            if (lastIndex[ch] >= left) {
                left = lastIndex[ch] + 1;
            }
            lastIndex[ch] = right;
            maxLen = Math.max(maxLen, right - left + 1);
        }
        return maxLen;
    }
}

Read all Approaches of Longest Substring Without Repeating Characters in depth

Round 2: Technical Phone Screen

Mode: Remote
Duration: 45 minutes
Difficulty: Medium

This round felt more conversational. The interviewer started by asking me to introduce myself, followed by questions about past projects and then moved into a mix of coding and conceptual discussions.

Question 1: Implement a Basic Cache with Get and Set Functions

Design a simple in-memory cache supporting two operations:

• get(key) : returns value if exists
• set(key, value) : stores key-value pair

My Approach

I implemented a dictionary (hash map) to store key-value pairs.After that, I extended the discussion to the LRU (Least Recently Used) Cache, explaining how we can use a combination of HashMap + Doubly Linked List to achieve O(1) get and set operations.

Simple Implementation

import java.util.HashMap;
class SimpleCache {
    private HashMap<String, String> cache;
    public SimpleCache() {
        cache = new HashMap<>();
    }
    public String get(String key) {
        return cache.getOrDefault(key, null);
    }
    public void set(String key, String value) {
        cache.put(key, value);
    }
}

Extended Discussion: LRU Cache Design

To handle the eviction policy (when the cache reaches its capacity), I discussed implementing an LRU (Least Recently Used) Cache using the following data structures:

• HashMap : stores key–node mappings for O(1) lookups
• Doubly Linked List : maintains the order of usage (most recent to least recent)

How It Works

1. Access (get)

   • When a key is accessed, move the corresponding node to the head of the linked list, marking it as most recently used.

2. Insert/Update (set)

   • When inserting a new key:
     • If the cache is full, remove the tail node (least recently used).
     • Add the new node at the head of the list.
   • Update the HashMap to reflect these changes.

Why This Design Works This design ensures both operations are constant-time:

Java Implementation

import java.util.*;
class LRUCache {
    private class Node {
        int key, value;
        Node prev, next;
        Node(int k, int v) { key = k; value = v; }
    }
    private final int capacity;
    private final Map<Integer, Node> cache;
    private final Node head, tail;
    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.cache = new HashMap<>();
        head = new Node(0, 0);
        tail = new Node(0, 0);
        head.next = tail;
        tail.prev = head;
    }
    private void set(Node node) {
        node.next = head.next;
        node.prev = head;
        head.next.prev = node;
        head.next = node;
    }
    public int get(int key) {
        if (!cache.containsKey(key)) return -1;
        Node node = cache.get(key);
        remove(node);
        add(node);
        return node.value;
    }
}

RESTful API Basics

After the coding discussion, we shifted to a brief talk about REST API principles.

Key Concepts Covered

• Statelessness — each request from a client must contain all necessary information.
• Use of HTTP verbs — GET, POST, PUT, DELETE, PATCH.
• Resource naming — use plural nouns and logical structure such as:
  • /api/users
  • /api/products
• Response codes
  • 200 — Success
  • 404 — Not Found
  • 500 — Internal Server Error

Example Question

“How would you design APIs for a simple Notes app?”

Example Endpoints

• GET /notes — Fetch all notes
• POST /notes — Create a new note
• GET /notes/:id — Fetch a specific note
• DELETE /notes/:id — Delete a specific note

This part was about clarity of thought, not memorization.

Round 3: Coding and Problem-Solving Round

Mode: On-site
Duration: 60 minutes
Difficulty: Medium

By this stage, the questions got deeper. The interviewer focused on logic optimization, complexity trade-offs and problem-solving mindset.

Question: Find Two Numbers That Add Up to a Target

Given an array and a target, return indices of the two numbers that add up to it.

My Approach

Brute Force:
Checked all pairs — O(n²).
I first explained this naive approach to show thought progression.

Optimized Solution:
Used a HashMap to store the complement of each number (target - num).

Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
    int complement = target - nums[i];
    if (map.containsKey(complement))
        return new int[]{map.get(complement), i};
    map.put(nums[i], i);
}

Complexity

• Time Complexity: O(n)
• Space Complexity: O(n)

Follow-up Question:

“How would you handle extremely large datasets that cannot fit in memory?”

My Answer: I explained chunk-based processing, streaming data handling and the use of external memory algorithms for example, reading data in batches or using distributed systems like Apache Spark.

Round 4: System Design (Basic)

Mode: On-site
Duration: 45 minutes
Difficulty: Easy

This was my favorite round. The interviewer asked me to design a URL Shortener Service similar to TinyURL or Bitly.

Problem Statement

Design a system that converts a long URL into a short one and retrieves it when needed.

My Approach

1. Clarified Requirements

• Input: Long URL
• Output: Short unique key
• The short link should redirect to the original long URL.

High-Level Design

API Layer:

• POST /shorten : to create a short URL
• GET /expand : to retrieve the original URL

Database Schema:

3. Short Key Generation

I used Base62 encoding of an auto-increment ID to generate short keys efficiently.

4. Scalability Considerations

• Added caching (Redis) for frequent lookups.
• Discussed load balancing and replication for reliability.
• Mentioned rate limiting to prevent abuse of the API.

I think for basic design rounds, don’t overcomplicate. Focus on clarity, scalability and trade-offs.

Round 5: Frontend and Behavioral Round

Mode: Remote
Duration: 60 minutes
Difficulty: Medium

This round was a combination of frontend coding and behavioral discussion.

Frontend Task: Build a Simple Product Listing Page

The interviewer asked me to create a product listing page with:

• Filter functionality (by category or price)
• Responsive layout
• Clean code and proper state management

Tech Stack I Used

• React.js for component-based structure
• CSS Flexbox/Grid for layout
• useState and useEffect hooks for data handling

I structured the components cleanly ProductList, FilterPanel and ProductCard and explained performance considerations like memoization and lazy rendering. this impressed the interviewer.

Behavioral Questions

After the coding task, the interviewer asked behavioral questions to assess my collaboration and mindset.

Some of the Actual Questions

• Tell me about a time you disagreed with a teammate. How did you handle it?

• How do you stay updated with the latest technologies?

• How do you handle bugs in production?

Behavioral rounds measure attitude, communication and problem ownership. Honesty matters more than perfection.

Overall Experience and Learnings

Interviewing at Meesho was a great learning experience. Each round was well-planned and focused on testing my understanding of concepts, coding skills and real-world problem-solving ability.

Key Takeaways

• Think aloud: Interviewers value your reasoning as much as the solution.
• Simplicity wins: Clear code with edge cases handled gracefully always impresses.
• Don’t panic when stuck: Ask clarifying questions and discuss trade-offs.

Overall, it was a valuable experience that helped me to improve both my technical knowledge and communication skills.