How I Cracked 50+ DSA Interviews and Landed at Uber
Mentoxis·August 23, 2026·10 min read
If you look at my early career, I was the farthest thing from a competitive programming prodigy. I graduated with my full-time M.Tech in 2015, focusing entirely on research papers and theoretical computer science. I didn't touch a single coding platform. The only code I wrote back then was just enough to scrape by and clear my college exams.
I didn't start grinding DSA until four years after joining my first company.
Starting that late is terrifying. When you're four years into your career and realize you need to learn data structures and algorithms from scratch, you feel like you've missed the train. You watch college freshers effortlessly solve Hard Dynamic Programming problems on LeetCode in 10 minutes, and you wonder if you can ever catch up.
Here is the raw truth: it is never too late to start.
Fast forward to today: I have over 10 years of software engineering experience, I currently work at Uber, and I have cleared more than 50 DSA interview rounds across FAANG, Big Tech, and top unicorn startups.
I didn't achieve this by memorizing 800 random LeetCode solutions. I built a structured, scalable preparation framework that I call the BFS Strategy (Breadth-First Search Preparation). Below is my complete roadmap, including every single pattern, problem list, resource, and strategy I used to crack Big Tech.
Phase 1: The Basics (Laying the Foundation)
When you haven't touched data structures in years, jumping straight into LeetCode Mediums is a recipe for instant burnout. You will get stuck, feel incompetent, and quit.
Instead, I started with a zero-ego approach:
Understand core mechanics first. I used GeeksforGeeks (GFG) to read about basic data structures — how memory is allocated for arrays, how pointer manipulation works in linked lists, and how tree traversals execute under the hood.
Solve easy problems on GFG. I solved basic implementation problems just to get comfortable writing clean syntax without relying on an IDE.
Ready to put this into practice?
Book a 1:1 mock interview with a FAANG engineer, or work through free interview questions with a live code editor.
Bridge the gap to LeetCode. Once I understood a specific data structure, I moved to LeetCode and solved 5 to 10 "Easy" rated problems on that exact same topic.
Repeat sequentially. I followed this exact loop for Arrays, Strings, Linked Lists, Stacks, Queues, Binary Trees, and Graphs before moving to complex algorithms.
FAANG interviewers rarely ask standard textbook questions anymore. However, almost every question they ask is built on a foundational pattern. If you recognize the underlying pattern within the first three minutes of reading a problem statement, the interview becomes significantly easier.
Instead of solving random problems, I solved 3 to 5 questions per pattern. Here is the exact list of patterns and high-frequency problems I mastered.
1. Two Pointers
Two Sum II — Input Array Is Sorted
3Sum
Container With Most Water
Remove Duplicates from Sorted Array
Trapping Rain Water
Valid Palindrome
2. Sliding Window
Longest Substring Without Repeating Characters
Minimum Window Substring
Longest Repeating Character Replacement
Max Consecutive Ones III
Fruit Into Baskets
3. Fast & Slow Pointers
Linked List Cycle
Linked List Cycle II
Middle of the Linked List
Happy Number
Find the Duplicate Number
4. Merge Intervals
Merge Intervals
Insert Interval
Meeting Rooms II (Premium)
Non-overlapping Intervals
Employee Free Time (Premium)
5. Cyclic Sort
Find All Numbers Disappeared in an Array
Find the Duplicate Number
Find All Duplicates in an Array
First Missing Positive
Missing Number
6. In-place Reversal of a Linked List
Reverse Linked List
Reverse Linked List II
Reverse Nodes in k-Group
Swap Nodes in Pairs
Palindrome Linked List
7. Tree BFS (Level Order Traversal)
Binary Tree Level Order Traversal
Binary Tree Zigzag Level Order Traversal
Average of Levels in Binary Tree
Binary Tree Right Side View
Minimum Depth of Binary Tree
8. Tree DFS
Maximum Depth of Binary Tree
Path Sum
Path Sum II
Path Sum III
Diameter of Binary Tree
Binary Tree Maximum Path Sum
Validate Binary Search Tree
Lowest Common Ancestor of a Binary Tree
9. Two Heaps
Find Median from Data Stream
Sliding Window Median
IPO
10. Subsets & Backtracking
Subsets
Subsets II
Permutations
Permutations II
Combination Sum
Combination Sum II
Letter Combinations of a Phone Number
Generate Parentheses
11. Modified Binary Search
Search in Rotated Sorted Array
Find Minimum in Rotated Sorted Array
Search a 2D Matrix
Find Peak Element
Koko Eating Bananas
Capacity To Ship Packages Within D Days
12. Top K Elements (Heap)
Kth Largest Element in an Array
Top K Frequent Elements
K Closest Points to Origin
Sort Characters By Frequency
Task Scheduler
13. K-way Merge
Merge k Sorted Lists
Kth Smallest Element in a Sorted Matrix
Smallest Range Covering Elements from K Lists
14. Topological Sort
Course Schedule
Course Schedule II
Alien Dictionary (Premium)
Minimum Height Trees
15. Dynamic Programming
Climbing Stairs
House Robber
House Robber II
Coin Change
Coin Change II
Partition Equal Subset Sum
Longest Increasing Subsequence
Longest Common Subsequence
Edit Distance
Unique Paths
Minimum Path Sum
16. Graph Traversal
Number of Islands
Clone Graph
Pacific Atlantic Water Flow
Surrounded Regions
Word Ladder
Rotting Oranges
17. Advanced Graphs & Union-Find (Crucial for Google & Amazon)
Number of Connected Components in an Undirected Graph (Premium)
Redundant Connection
Network Delay Time (Dijkstra's Algorithm)
18. Prefix Sum + HashMap
Subarray Sum Equals K
Continuous Subarray Sum
Contiguous Array
19. Monotonic Stack
Next Greater Element I
Daily Temperatures
Largest Rectangle in Histogram
Trapping Rain Water
Sliding Window Maximum
20. Bit Manipulation
Single Number
Number of 1 Bits
Counting Bits
Reverse Bits
Power of Two
21. Trie
Implement Trie (Prefix Tree)
Word Search II
Design Add and Search Words Data Structure
22. Data Structure Design (Critical for Senior Roles)
LRU Cache
LFU Cache
Min Stack
Serialize and Deserialize Binary Tree
My Unbreakable Rule When Getting Stuck
When working through Phase 2, I followed a strict 30-minute rule:
0–30 minutes: pen and paper only. I tried to brute-force the logic, write pseudocode, and trace edge cases.
At 30 minutes: if I was completely stuck, I opened the LeetCode Discuss/Editorial tab to understand the high-level intuition — not to copy code.
If intuition was still unclear: I watched a visual video explanation on YouTube.
The retest: I closed the solution completely, waited a day, and forced myself to re-solve the problem from scratch on a blank editor.
Phase 3: Advanced Prep (Interview Readiness)
Once I had the patterns down, I shifted gears to simulate real interview conditions.
Randomized practice. I stopped solving questions by category. I used LeetCode's "Pick One" button to train my brain to identify patterns cold, without context clues.
LeetCode Daily Challenge. I did the Question of the Day to stay consistent and force myself out of my comfort zone.
Weekend contests. I participated in at least one LeetCode contest every weekend. Contests build time management and teach you how to stay calm when the clock is ticking down.
Targeted revision. I maintained a spreadsheet tagging every problem I failed during contests, then revisited those specific patterns during the week.
The Secret Sauce: Mock Interviews at Every Stage
Solving a problem silently in your bedroom is vastly different from writing code on a shared whiteboard while explaining your trade-offs out loud to a Senior Principal Engineer.
Early on, I did informal mock interviews with friends. But as I targeted senior roles at Uber and FAANG, I needed structured feedback from people who actually sit on hiring committees.
That struggle is exactly why I ended up building Mentoxis. It is a platform where engineers can book 1:1 mock interviews, resume reviews, and career strategy sessions directly with mentors working at FAANG, Uber, and top Big Tech companies. Doing real mock interviews completely eliminated my live-interview anxiety.
1 Week Before the Interview: The Final Polish
Seven days out, I completely stopped learning new algorithms. Trying to learn complex topics like Segment Trees or Tarjan's algorithm in the final week only creates panic.
Instead, my final week looked like this:
Company-tagged questions. I filtered LeetCode by company tag (e.g., Uber or Meta) and sorted by frequency over the last 6 months.
Weak pattern review. I re-read my notes and re-solved 5 to 10 medium problems from my weakest patterns.
Interview experiences. I spent hours reading recent interview reports on LeetCode Discuss and GeeksforGeeks to understand common question variations and interview formats.
Final warmup mock. I did one last mock interview to ensure my verbal communication was sharp.
My Complete Resource Stack
If I had to reboot my preparation today, these are the exact materials I would use.
YouTube Channels
Striver (takeUforward): the ultimate resource for Dynamic Programming, Graphs, and structured A-to-Z DSA roadmaps.
NeetCode: exceptional visual explanations for the Blind 75 and NeetCode 150.
Abdul Bari: the undisputed king of core algorithm theory, time complexity analysis, and whiteboard explanations.
Aditya Verma: if you struggle with Dynamic Programming or Recursion, his visual tree-diagram method makes DP remarkably intuitive.
Back To Back SWE (Benyam Ephrem): deep-dive whiteboard breakdowns for complex LeetCode Hard problems.
mycodeschool: timeless explanations of C/C++ memory management, pointers, and linked list fundamentals.
WilliamFiset: phenomenal visual animations for advanced graph theory and data structures.
Books
Cracking the Coding Interview (Gayle Laakmann McDowell): the classic starting guide for understanding FAANG interview expectations.
Elements of Programming Interviews (EPI): my personal favorite for mid-to-senior engineers. The problems are tougher, more realistic, and well-organized for Java, C++, and Python.
Grokking Algorithms (Aditya Bhargava): fully illustrated, beginner-friendly book that visualizes algorithms before diving into code.
Introduction to Algorithms (CLRS): the academic bible. Use it strictly as a reference manual for rigorous theoretical proofs.
Coding Platforms
LeetCode & NeetCode.io: the core daily drivers for problem-solving and pattern mastery.
GeeksforGeeks (GFG): best for initial topic articles, syntax refreshers, and basic practice.
Mentoxis.com: a curated set of selected coding questions asked across many companies, plus 1:1 mock interviews with FAANG mentors.
Codeforces / AtCoder: optional, but useful if you want to push your logic skills to competitive programming standards.
Bonus: System Design (For Engineers with 4+ Years Experience)
Since I had experience, DSA was only 50% of the evaluation. For System Design, I relied on:
ByteByteGo (Alex Xu): System Design Interview Volume 1 & 2 are non-negotiable reads.
Gaurav Sen: excellent YouTube channel breaking down core distributed systems components (Load Balancers, Distributed Caching, Database Sharding).
Designing Data-Intensive Applications (Martin Kleppmann): the absolute bible for deep database internals, consistency models, and distributed architecture.
Hello Interview: I like the structure and tutorial. The text content took me less time to get through.
Final Thoughts
Cracking Big Tech is not about being born a genius. It is about consistency, pattern recognition, and structured practice.
I started DSA four years late, felt overwhelmed, failed plenty of mock interviews, and eventually built a system that worked. If I could do it after a 4-year gap, you can too.
What is the single biggest bottleneck in your DSA prep right now — is it pattern identification, speed, or communication during mock interviews? Drop your thoughts in the comments below.
If you want structured, real feedback from engineers who actually sit on hiring committees, book a 1:1 mock interview on Mentoxis. Follow me here for my upcoming complete System Design roadmap and company-specific interview breakdown guides.