Karan Saxena

The difference between a 3 LPA and a 20 LPA package is 1–1.5 years of focused preparation.

If I were preparing for placements again in 2025, this is the roadmap I would follow (the same principles that got me from PhonePe to Google)

2024 is ending in about 45 days, and I still see many students and aspirants looking to be placed…

Let me help you guys.

Phase 1: Build Strong Foundations
1/ Data Structures & Algorithms (DSA)
↬ Spend 4–5 months mastering DSA with consistent daily practice.
↬ Study topic-wise: Arrays, Strings, Trees, Graphs, Dynamic Programming.
↬ Platforms: LeetCode, CodeForces, CodeChef.

Key Milestone:
- Solve 200+ problems across easy, medium, and hard levels.
- Practice mock contests to improve speed and accuracy under time constraints.

Phase 2: Development Skills
1/ Full-Stack Development
↬ Learn Frontend: HTML, CSS, JavaScript, React.
↬ Learn Backend: Node.js, Express.js, Django, or Flask.
↬ Learn Databases: SQL and MongoDB for relational and NoSQL perspectives.

2/ Build Portfolio Projects
↬ Create 2-3 full-stack projects with frontend, backend, and database integration.
↬ Focus on real-world projects like e-commerce apps, chat apps, or booking systems.

Key Milestone:
- Deploy projects on platforms like Vercel or Heroku.
- Showcase these projects on your resume and GitHub.

Phase 3: Master Theory Concepts
1/ Core Computer Science Subjects
↬ Learn OOPS, DBMS, Operating Systems, and Computer Networking.
↬ Focus on concepts like normalization, threading, memory management, and protocols.

2/ Practical Application
↬ Relate theory to development and DSA (e.g., databases in backend projects).

Key Milestone:
- Have a clear understanding of fundamental CS concepts to explain in interviews.
Phase 4: Resume Building
1/ Create an ATS-Friendly Resume
↬ Use a clean format with no graphics or fancy fonts.
↬ Highlight projects, internships, and DSA achievements at the top.

2/ Avoid Common Mistakes
↬ Skip irrelevant extracurriculars and focus on technical achievements.
↬ Proofread thoroughly to eliminate errors.

Key Milestone:
- Your resume should convey your technical skills and stand out in 6 seconds.

Phase 5: Communication Skills
1/ Improve Spoken English
↬ Start speaking in English daily to build confidence for interviews.
↬ Practice explaining your projects and solving problems out loud.

Key Milestone:
- Be able to confidently articulate your thoughts in technical and HR interviews.

Continued here: https://lnkd.in/eUKPK3RV

--

P.S: I’ve been getting 10+ queries regarding DSA, HLD, and LLD daily

So, to answer all, I’ve launched my One Stop Resource guide for aspiring software engineers.

This guide help you with:
- full roadmap of DSA, HLD, and LLD for interviews
- good resources that I used included to save you time
- lots of problems and case studies for DSA and system design

Here’s the link: https://lnkd.in/e-detVTg (220+ students are already using it)

Here’s a DSA patterns identification cheatsheet that will help you identify which questions will be solved by which pattern based on keywords.

I wish I had this when I was grinding Leetcode and preparing for coding interviews because cracking Leetcode problems fast during coding interviews = Knowing & recognizing the patterns.

Look out for the below keywords, these indicate the type of the pattern the problem is based on.

∟ Binary Search
◄ sorted
◄ search
◄ left/right
◄ log(n)
◄ upper/lower bound
◄ first/last occurrence

∟ Depth-First Search (DFS)
◄ recursion
◄ backtrack
◄ stack
◄ tree/graph
◄ path
◄ explore deeply

∟ Sliding Window
◄ subarray
◄ contiguous
◄ window size
◄ sum/max/min in range
◄ fixed/variable window
◄ consecutive elements

∟ Two Pointers
◄ left and right
◄ sorted array
◄ move inward
◄ reverse in-place
◄ pair sum
◄ meet in middle

∟ Fast & Slow Pointers
◄ cycle detection
◄ loop
◄ find middle
◄ linked list
◄ tortoise hare
◄ detect loop start

∟ Breadth-First Search (BFS)
◄ queue
◄ shortest path
◄ level order
◄ tree/graph
◄ traverse layers
◄ neighbors

∟ Backtracking
◄ combinations
◄ permutations
◄ all solutions
◄ recursive
◄ choices/decisions
◄ undo move

∟ Dynamic Programming
◄ subproblem
◄ overlapping
◄ memoization
◄ optimal
◄ cache
◄ state transition

∟ Greedy
◄ always best choice
◄ locally optimal
◄ sorting
◄ intervals
◄ maximize/minimize
◄ no future change

∟ Hashing/Hash Table
◄ hashmap
◄ lookup
◄ frequency
◄ set
◄ collisions
◄ constant time

∟ Union Find (Disjoint Set)
◄ connected components
◄ group
◄ parent/leader
◄ path compression
◄ merge sets
◄ cycle detection

∟ Topological Sort
◄ directed acyclic graph
◄ course schedule
◄ dependency
◄ in-degree
◄ order
◄ build sequence

∟ Trie
◄ prefix
◄ autocomplete
◄ startsWith
◄ dictionary
◄ string search
◄ character node

∟ Heap / Priority Queue
◄ top k
◄ min/max
◄ extract
◄ insert
◄ dynamic median
◄ scheduling

—
P.S: If you’re currently preparing for DSA, HLD, and LLD.

Check out my one-stop resource guide on Topmate:
→ https://lnkd.in/eYHSjbys ( 700+ students are already using it)

This guide will help you with:
- DSA, HLD, and LLD for interviews
- good resources that I used personally
- lots of problems and case studies for DSA and system design

In 2025, solving problems fast on Leetcode = Knowing & recognizing the patterns.
I wish I knew this when I solved 1000+ DSA problems on Leetcode & got a rating of 2021 on Codeforces and 2195 on CodeChef.

Here’s a DSA problem-solving cheat sheet that will help you solve 90-95% of questions that come your way.

♦ If the Input is an Array or String:
- Is the array sorted?
- Yes: Use Binary Search or Two Pointers.
- No: Move to the next checks.

- What is the question asking?
- Number of ways to do something / Max-Min of something:
- If decisions are dependent on each other, use Dynamic Programming.
- If decisions are independent, use Greedy.
- Is something possible?:
- Try Backtracking.

- Does it involve string manipulation?
- Prefix matching: Use Trie.
- Building strings or finding distances: Use Stack or Monotonic Stack.

- Is it about finding a specific element?
- Use a Hash Map or Set.

- Does it involve elements being added/removed in a sliding window fashion?
- Use a Sliding Window or Counting Hash Map.

- Is the problem about continuously finding the max/min element or removing them?
- Use a Heap or Monotonic Queue.

---

♦ If the Input is a Graph:
- Does the question involve finding the shortest path or the fewest steps?
- Yes: Use Breadth-First Search (BFS).
- No: Use Depth-First Search (DFS).

---

♦ If the Input is a Tree (probably binary):
- Does the question involve specific depths/levels?
- Yes: Use Breadth-First Search (BFS).
- No: Use Depth-First Search (DFS).

---

♦ If the Input is a Linked List:
- Does it involve detecting cycles?
- Use Fast and Slow Pointers.
- Does it involve reversing or modifications?
- Use a “prev” pointer for reversing.
- Use a “dummy” pointer for maintaining the original head.

This flow will help you quickly identify the optimal approach for most DSA problems. Save it for your next grind!
–

P.S: If you’re currently preparing for DSA, HLD, and LLD.

Check out my one-stop resource guide on Topmate:
→ https://lnkd.in/eYHSjbys ( 600+ students are already using it)

This guide will help you with:
- DSA, HLD, and LLD for interviews
- good resources that I used personally
- lots of problems and case studies for DSA and system design

System design cheat sheet for interviews and revision of basics I wish I had when I was preparing for my interviews.

• Key Fundamentals: 
1. Scalability: https://lnkd.in/gpge_z76
2. Latency vs Throughput: https://lnkd.in/g_amhAtN
3. CAP Theorem: https://lnkd.in/g3hmVamx
4. ACID Transactions: https://lnkd.in/gMe2JqaF
5. Rate Limiting: https://lnkd.in/gWsTDR3m
6. API Design: https://lnkd.in/ghYzrr8q
7. Strong vs Eventual Consistency: https://lnkd.in/gJ-uXQXZ
8. Distributed Tracing: https://lnkd.in/d6r5RdXG
9. Synchronous vs. asynchronous communications: https://lnkd.in/gC3F2nvr
10. Batch Processing vs Stream Processing: https://lnkd.in/g4_MzM4s
11. Databases: https://lnkd.in/gti8gjpz
12. Horizontal vs Vertical Scaling: https://lnkd.in/gAH2e9du
13. Caching: https://lnkd.in/gC9piQbJ
14. Distributed Caching: https://lnkd.in/g7WKydNg
15. Load Balancing: https://lnkd.in/gQaa8sXK
16. SQL vs NoSQL: https://lnkd.in/g3WC_yxn
17. Database Scaling: https://lnkd.in/gAXpSyWQ
18. Data Replication: https://lnkd.in/gVAJxTpS
19. Data Redundancy: https://lnkd.in/gNN7TF7n
20. Database Sharding: https://lnkd.in/gMqqc6x9
21. Database Index's: https://lnkd.in/gCeshYVt
23. WebSocket: https://lnkd.in/g76Gv2KQ
24. API Gateway: https://lnkd.in/gnsJGJaM
25. Message Queues: https://lnkd.in/gTzY6uk8

• Design Patterns:

1. https://lnkd.in/g5xXEsyb
2. https://lnkd.in/gPBKWucA
3. https://lnkd.in/gBmu2Z7h
4. https://lnkd.in/gHtg_wZ6
5. https://lnkd.in/gVVSCYvN
6. https://lnkd.in/gQ3ZCNgX
7. https://lnkd.in/gFbuxsQZ
8. https://lnkd.in/gF-tRnQR
9. https://lnkd.in/gJBUrcgm
10. https://lnkd.in/gCkgTjQh
11. https://lnkd.in/gPJCscbj
12. https://lnkd.in/gzJDEMt9
13. https://lnkd.in/g6Ma6VyB
14. https://lnkd.in/gPwejHqP
15. https://lnkd.in/gxqrdgBw
16. https://lnkd.in/gp7neH2D
17. https://lnkd.in/gXYHNniN
18. https://lnkd.in/gm6qqNPc
19. https://lnkd.in/gqjWa9tw
20. https://lnkd.in/g2MBCiE3
21. https://lnkd.in/gKjhZ8cK
22. https://lnkd.in/gRB_kBZS
23. https://lnkd.in/g7k9wJkX
24. https://lnkd.in/gYz9Nsvi
25. https://lnkd.in/gKd_zK-N
26. https://lnkd.in/ggZJR3a3
27. https://lnkd.in/g3E_rGrA
28. https://lnkd.in/gsbetRE3
29. https://lnkd.in/gczTCFNp
30. https://lnkd.in/gh7b4bDt

• Architecture Patterns
1. Event-Driven Architecture: https://lnkd.in/dp8CPvey
2. Client-Server Architecture: https://lnkd.in/dAARQYzq
3. Serverless Architecture: https://lnkd.in/gQNAXKkb
4. Microservices Architecture: https://lnkd.in/gFXUrz_T
--
P.S: Note that I haven't created these resources, only curated them. Rights belong to respective parties.

--
P.P.S: If you’re currently preparing for DSA, HLD, and LLD.

Check out my one-stop resource guide on Topmate:
→ https://lnkd.in/eYHSjbys ( 400+ students are already using it)

This guide will help you with:
- DSA, HLD, and LLD for interviews
- good resources that I used personally
- lots of problems and case studies for DSA and system design

Cracking Leetcode problems fast during coding interviews = Knowing & recognizing the patterns.

Here’s a DSA patterns cheatsheet that will help you solve 90-95% questions that will come your way.

For Graph questions:  
↳ Apply DFS/BFS to traverse the graph.  
↳ Use adjacency lists for efficient representation.  
↳ Focus on detecting cycles/shortest paths depending on the problem.

For Sliding Window problems:  
↳ Adjust the window size dynamically based on constraints.  
↳ Use two pointers to track the current window.  
↳ Track sums or counts within the window to optimize results.

For Linked Lists:  
↳ Use Two Pointers to detect cycles & find the middle node.  
↳ Reverse the list in-place by pointer manipulation. 

For Maximum/Minimum Subarrays:  
↳ Use Dynamic Programming to track the optimal subarray.  
↳ Maintain a running sum and compare with current maxi/mini.
↳ Divide the problem into subproblems to simplify calculations.

For In-Place operations:  
↳ Swap corresponding values to reorder the array.  
↳ Modify the array without using extra space by storing values cleverly.  
↳ Carefully manage index positions during swapping to avoid overwriting.

For Top/Least K elements:  
↳ Use Heaps to keep track of the top/least K elements efficiently.  
↳ QuickSelect can help when sorting isn’t necessary.  
↳ Maintain a limited window of values for optimal memory usage.

For Permutations/Subsets:  
↳ Apply Backtracking to explore all possible combinations.  
↳ Prune paths that won’t lead to valid solutions early.  
↳ Track the current state and revert changes after each recursive call.

For Common Strings problems:  
↳ Use a Map/Trie to store and search for prefixes or entire strings.  
↳ Count frequencies to detect patterns or duplicates. 

For Recursion-Banned problems:  
↳ Use Stack to simulate recursive calls iteratively.  
↳ Track the state manually to mimic the recursive behavior.  
↳ Push and pop values carefully to ensure you’re following the intended logic.

For Sorted Arrays:  
↳ Use Binary Search to quickly narrow down the target range.  
↳ Use sorted properties to optimize space/time complexity.
↳ Use Two Pointers for sums or pairs. 

For Tree problems:  
↳ Traverse using DFS for deep exploration or BFS for level-wise traversal.  
↳ Keep track of visited nodes to avoid infinite loops.  
↳ Handle edge cases like unbalanced trees or missing nodes.

Else:  
↳ Use Maps/Sets for O(1) lookups and efficient space management.  
↳ Sorting can simplify problems to O(nlogn) time. 

--
Btw, recently, I’ve been getting a lot of queries regarding DSA, HLD, and LLD.

I’ve just launched my One Stop Resource guide to help all aspiring software engineers.

What will this guide help you with:
- full roadmap of DSA, HLD and LLD for interviews
- good resources that I used included to save you time
- lots of problems and case studies for DSA and system design.

I’m running a 35% offer for the first 100 people, here’s the link: https://lnkd.in/e-detVTg

7 years ago, I joined a Tier-3 college after failing my JEE attempt. My rank was 2.5 lakh. I knew I had no other options.

My college had no coding culture, yet I work at Google today.

This is my story:

Back in school, I had no idea about JEE, and when I finally appeared, I was disappointed.

My rank was 6 figures, and I couldn’t make the cut-off for good colleges.

I even considered taking a drop year but wasn’t sure I would get NIT or IIT.

And so my journey began pursuing B.Tech 2017.

1st sem, I was very excited, but it all went away soon.

The subjects used to bore me until I rediscovered my old passion for computers again.

I have always enjoyed solving problems, and that got me into CP.

From there, I was never bored again. In the next 3 years:

- I competed in the ICPC Gwalior Regions
- started with CP on Codeforces & CodeChef
- convinced my dept. Head to help me go all in with my coding skills

By the 6th sem, I had reached the Candidate Master level on Codeforces, with a rating of 2021.

C.P helped me a lot in building my basics, and from there:

In 2021, I got my first internship and then joined PhonePe full-time. 
In 2022, I got a call from a Google recruiter that changed my life. 
In 2023, I moved to Google in London.

Your background doesn’t determine how far you can go.

You do.

No matter what you have or where you are, if you work hard, you can make it.


P.S: If you’re currently preparing for DSA, HLD, and LLD.

Check out my one-stop resource guide on Topmate:
→ https://lnkd.in/eYHSjbys ( 750+ students are already using it)

This guide will help you with:
- DSA, HLD, and LLD for interviews
- good resources that I used personally
- lots of problems and case studies for DSA and system design