How I Cracked 50+ DSA Interviews and Landed at Uber

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.
• 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.

Phase 2: Intermediate (Building Pattern Recognition)

This was the core breakthrough of my preparation.

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.