Most students don't fail placement interviews because they don't know Data Structures and Algorithms — they fail because they learned it in the wrong order, jumped straight into Dynamic Programming without mastering arrays, or spent three weeks on Segment Trees while never touching Graphs. A DSA roadmap for placements isn't a random list of topics to grind through. It's a sequence, where each topic builds the pattern-recognition you need for the next one. This guide lays out that sequence week by week, tells you which free resources are actually worth your time in 2026, and shows you how to practice so the knowledge sticks under interview pressure.
Why DSA Still Decides Your Placement Outcome
Every major product-based company — Google, Amazon, Microsoft, Flipkart, and the well-paying startups in between — still filters candidates primarily through DSA rounds, regardless of how much the industry talks about AI tools and system design. Here's why it hasn't gone away:
It's the fastest way to test reasoning at scale. A 45-minute coding round tells a recruiter more about how you think under pressure than a resume ever could.
It's the great equalizer. A student from a smaller college who has solved 200 well-understood problems will consistently outperform a student from a top-tier college who solved 50 — DSA doesn't care which campus you're from, only how much pattern recognition you've built.
It compounds into salary. Candidates targeting packages above 10 LPA as freshers are expected to solve Medium-difficulty problems in under 45 minutes; without that bar, most product companies won't even shortlist the resume.
Service companies still test it, just at a lower bar. TCS, Infosys, Wipro, and Cognizant typically ask 1–2 DSA problems in their technical rounds — less intense than product companies, but not skippable.
DSA Roadmap for Placements at a Glance
Phase | Topics | Timeline | Goal |
|---|---|---|---|
1 | Programming basics, complexity analysis | Weeks 1–2 | Think in Big-O before writing code |
2 | Arrays, strings, two pointers, sliding window | Weeks 3–5 | Own the most-tested topic in every interview |
3 | Recursion, linked lists, stacks, queues | Weeks 6–8 | Build the foundation for trees and graphs |
4 | Binary search, sorting, hashing | Weeks 9–10 | Learn the tools used inside almost every other topic |
5 | Trees and binary search trees | Weeks 11–13 | Master traversal patterns |
6 | Graphs (BFS, DFS, shortest paths) | Weeks 14–16 | Handle the topic most students fear |
7 | Dynamic programming | Weeks 17–20 | Crack the topic that decides most FAANG-level interviews |
8 | Greedy and backtracking | Weeks 21–22 | Round out your pattern library |
9 | Mock interviews and revision | Ongoing, final 4–6 weeks | Convert knowledge into interview performance |
Key tip: This 20–22 week (roughly 5-month) plan assumes 1.5–2 hours on weekdays and 3–4 hours on weekends. If you're short on time before placement season, compress phases 1–4 rather than skipping Dynamic Programming or Graphs — those two are non-negotiable for product companies.
Phase 1: Programming Basics and Complexity Analysis
Before touching a single data structure, you need to be able to look at a piece of code and estimate its time and space complexity without hesitation. This phase covers time complexity (Big-O, Big-Theta, Big-Omega), space complexity, and basic recursion — because recursion underpins trees, graphs, and backtracking later on.
What to focus on: Understanding why an O(n²) solution is too slow before you're told it is, and being able to trace a recursive call stack by hand.
Pro Tip: Don't skip writing recursive solutions by hand on paper before you code them. Most students who struggle with trees and backtracking later never built this muscle here.
Phase 2: Arrays, Strings, and the Pattern Trio
Arrays and strings aren't just "the easy topic to get through quickly" — they're where the majority of interview problems live, and where three patterns show up over and over: two pointers, sliding window, and prefix sums. Add Kadane's Algorithm for maximum subarray problems, and basic string-matching techniques like KMP for later rounds at product companies.
What to focus on: Recognizing which of the three patterns a problem needs within the first two minutes of reading it — that recognition speed is what separates a 45-minute interview pass from a timeout.
Pro Tip: After solving a problem, rewrite it from memory the next day without looking at your old solution. This single habit does more for retention than solving five new problems.
Phase 3: Recursion, Linked Lists, Stacks, and Queues
This phase builds the structural foundation for everything that follows. Linked lists teach you the fast-and-slow pointer technique (used for cycle detection and finding the middle element), while stacks and queues are essential for expression evaluation, BFS, and monotonic stack problems that show up constantly in Medium-difficulty interview questions.
What to focus on: Reversing a linked list and detecting a cycle without hints — these are baseline expectations, not advanced tricks, at almost every product company.
Pro Tip: Implement a stack and queue from scratch once, even though your language's standard library already has one. Understanding the internals makes monotonic stack problems click much faster later.
Phase 4: Binary Search, Sorting, and Hashing
Binary search isn't just "search in a sorted array" — modern interviews ask you to binary search on the answer itself, on rotated arrays, and across 2D matrices. Pair this with core sorting algorithms (merge sort, quicksort, heap sort) and hashing, which gives you O(1) lookups essential for frequency-counting and two-sum-style problems.
What to focus on: Hashing shows up as a shortcut inside problems from nearly every other topic — treat it as a tool you reach for by instinct, not a standalone chapter you finish and move on from.
Pro Tip: When you're stuck on a problem for more than 20–30 minutes, ask whether a hash map could remove a nested loop. It's the single most common optimization interviewers expect you to find on your own.
Phase 5: Trees and Binary Search Trees
Trees are the foundation for a huge share of Medium and Hard interview problems: traversals (inorder, preorder, postorder, level-order), BST operations, and problems like Lowest Common Ancestor, diameter, and height. This is also where you get your first real taste of "tree DP" — dynamic programming applied to tree structures.
What to focus on: Being able to write all four traversal types cleanly, both recursively and iteratively, without referring to notes.
Pro Tip: Draw the tree on paper or a whiteboard before coding, every time. Interviewers watch how you reason about tree structure as much as they watch your code.
Phase 6: Graphs — The Topic Most Students Fear
Graphs intimidate students more than any other topic on this roadmap, mostly because there are more algorithms attached to it: BFS, DFS, cycle detection, topological sort, shortest path algorithms (Dijkstra, Bellman-Ford), and minimum spanning tree algorithms (Prim's, Kruskal's). The good news is that most graph interview questions are variations of BFS or DFS with a small twist — not entirely new algorithms.
What to focus on: Get comfortable representing a graph as both an adjacency list and adjacency matrix, and know instantly which representation a given problem calls for.
Pro Tip: Practice explaining out loud why you chose BFS over DFS (or vice versa) for a given problem. Interviewers weigh your reasoning as heavily as your final code.
Phase 7: Dynamic Programming — The Deciding Factor
Dynamic programming is the single most feared topic in DSA interviews, and often the deciding factor in interviews at Google, Amazon, and similarly bar-setting companies. It solves problems with overlapping subproblems by storing previously computed results instead of recomputing them. A practical five-step framework helps: identify overlapping subproblems and optimal substructure, define the state, write the recurrence relation, choose memoization or tabulation, and then optimize space if needed.
Must-practice problems span Fibonacci, Climbing Stairs, House Robber, Coin Change, 0/1 Knapsack, Longest Common Subsequence, Edit Distance, Longest Increasing Subsequence, and Matrix Chain Multiplication — most interview DP questions fall into five or six recurring categories once you've seen enough of them.
What to focus on: Recognizing the category of DP problem (subsequence, knapsack-style, interval, or grid-based) rather than memorizing individual solutions — categories transfer to problems you've never seen before; memorized solutions don't.
Pro Tip: Begin system design preparation only after you've solved 100+ quality DSA problems and feel comfortable with Medium-difficulty questions. For freshers, DSA takes priority over system design almost every time.
Phase 8: Greedy Algorithms and Backtracking
Greedy algorithms (activity selection, fractional knapsack, Huffman coding) and backtracking (N-Queens, Sudoku solver, generating all permutations and subsets) round out your pattern library. These show up less frequently than arrays or DP, but they're common enough — especially at product companies — that skipping them leaves a visible gap.
What to focus on: For backtracking, get comfortable with the "choose, explore, unchoose" template — nearly every backtracking problem follows this same shape.
Pro Tip: If you're preparing for advanced or research-oriented roles, Segment Trees, Fenwick Trees, and Tries are worth adding after this phase. For most fresher placements, they're optional.
The Best Free DSA Sheets and Resources for 2026
You don't need five resources — you need one that you finish completely. The three most recommended options for Indian placement prep in 2026 are:
Striver's A2Z DSA Sheet — comprehensive and free, structured in the same topic order as this roadmap. Best if you want full topic coverage before interviews.
NeetCode 150 — pattern-based and especially strong for product-company and FAANG-style interview prep, since it groups problems by the underlying technique rather than just topic.
Blind 75 — a tighter list of essential problems, useful when you're short on time and need the highest-yield questions only.
Beyond sheets, LeetCode remains the standard for interview-style practice, GeeksforGeeks is strong for learning concepts with worked examples, and CodeChef or Codeforces are worth adding if you also want competitive programming practice, not just interview prep.
Pro Tip: Pick one sheet and finish it thoroughly rather than jumping between multiple resources — sheet-hopping is one of the most common reasons students plateau at 100–150 problems without ever feeling interview-ready.
How to Actually Practice (Not Just Watch Solutions)
Watching a YouTube video solve a problem feels productive. It rarely is. Here's what actually builds interview-ready pattern recognition:
Solve before you look. Give yourself 20–30 minutes on a problem before checking a hint — and even then, look at the approach only, not the full solution.
Time yourself from day one. Roughly 30 minutes for a Medium problem and 45 minutes for a Hard one is a realistic interview constraint to practice against.
Rewrite from memory. Revisit a solved problem a day or two later and rewrite it without your old code open — this is what actually moves a pattern into long-term memory.
Explain your reasoning out loud. Say things like "I'm using a hash map here because the problem needs O(1) lookups" as you code — this is the exact skill interviewers are grading, and it feels awkward until it doesn't.
Start mock interviews 2–3 months before placement season. Platforms like Pramp, Interviewing.io, or simply trading problems with a peer work well. Mock interviews expose blind spots that solo practice never will.
Aim for quality over volume. Solving 150–200 well-understood problems across all major topics is generally enough for most placement interviews — 500 problems solved without understanding the pattern behind them is far less effective.
Need a project to pair with your DSA prep for your resume? Browse student project ideas on Velonx, or check the Velonx job board for internship openings that test exactly these rounds.
Does the Roadmap Change by Company Type?
Yes, and it's worth adjusting your prep accordingly:
Service companies (TCS, Infosys, Wipro, Cognizant, Capgemini, HCL): Expect an online aptitude test (quantitative, logical, verbal reasoning) followed by a technical round with 1–2 DSA problems, usually Easy to Medium difficulty. Phases 1–5 of this roadmap cover you well.
Product companies and well-funded startups (Amazon, Microsoft, Flipkart, and similar): Expect multiple rounds of Medium-to-Hard DSA, often followed by system design for more senior roles. You'll want the full roadmap through Phase 8, plus consistent mock interview practice.
Frequently Asked Questions About the DSA Roadmap for Placements
How long does it actually take to become placement-ready?
Most consistent learners become interview-ready in 3 to 6 months. Students with 1.5–2 hours on weekdays and 3–4 hours on weekends typically land in the 4–5 month range, matching the 20–22 week roadmap above. Rushing through topics without understanding them usually takes longer in the long run, since you end up revisiting the same gaps repeatedly.
How many problems do I actually need to solve?
Somewhere between 150 and 300 well-understood problems across all major topics is generally enough for most placement interviews. Solving 500 problems without recognizing the underlying patterns is far less effective than solving 150 and genuinely understanding why each solution works.
What's the best DSA sheet for placements in India?
Striver's A2Z DSA Sheet, NeetCode 150, and Blind 75 are the three most recommended free options. Pick one and complete it thoroughly rather than switching between them — consistency with one resource beats fragmented coverage across several.
When should I start preparing for system design?
Begin system design only after solving 100+ quality DSA problems and feeling comfortable with Medium-difficulty questions. For freshers, DSA takes clear priority — system design usually matters more for candidates with a few years of experience.
Can I prepare for DSA alongside college coursework and exams?
Yes, and most students do exactly this. Short, focused weekday sessions combined with longer weekend revision blocks work better than occasional long cram sessions — 30 minutes of daily, consistent practice outperforms three hours once a week.
Is DSA alone enough to crack product-company interviews?
DSA covers most technical rounds, but CS fundamentals (OS, DBMS, networks), projects, and communication skills also factor into final selection — especially at the interview stage rather than the coding round. Treat DSA as necessary, not sufficient, for product-company offers.
Conclusion: The Roadmap Only Works If You Follow the Order
The students who crack placements aren't the ones who "know more DSA" in the abstract — they're the ones who built pattern recognition in the right sequence, timed their practice like a real interview, and showed up consistently for months instead of cramming for two intense weeks before the placement drive.
Start this week:
Pick your timeline — 20 weeks if you're starting early, 12–16 if placement season is close.
Choose one sheet (Striver's A2Z, NeetCode 150, or Blind 75) and commit to finishing it before switching resources.
Block 1.5–2 hours on weekdays and 3–4 hours on weekends, and protect that time like a class you can't skip.
Start mock interviews 2–3 months before your placement drive, not the week before.
Bookmark Velonx Events for upcoming hackathons and coding contests that double as free interview practice under real time pressure.
Every problem you can't solve today is just a gap in your current pattern library — not a sign you're not cut out for this. Follow the order, put in the weeks, and the gap closes.