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