DSA Preparation in 3 Months for Product Company Interviews in India 2026: The Realistic Day-by-Day Plan

You've got 3 months. Maybe you're stuck in TCS doing SQL tickets, maybe you're a final-year student eyeing Flipkart, maybe you just got laid off from a Series B startup. Whatever brought you here — the question is the same: can you actually crack a product company interview in 90 days starting from scratch? Short answer: yes, if you stop binge-watching tutorials and start solving. Here's the real plan.

Let me tell you what nobody says on YouTube: most people who "prepare DSA for 3 months" fail their interviews.

Not because 3 months isn't enough. It is. But because they spend 60 of those days watching Striver and Love Babbar videos at 1.5x, feel smart, and then freeze when a Flipkart interviewer asks them to code a Trie on a Google Doc.

I've mentored over 40 engineers through this journey — from TCS to Razorpay, from Infosys to Zepto, from fresh graduates to Amazon. The ones who crack it all follow a similar pattern. The ones who don't, follow a different one. This post is about the first group.

If you're serious about using the next 90 days to land a 18-35 LPA role at a product company, read every section. No skipping.

Who This Plan Is For (And Who It Isn't)

Let's be honest upfront. This plan works for you if:

• You know at least one programming language well (Java, Python, C++, or JavaScript). You can write a for-loop, use a HashMap, and understand recursion basics without panicking.
• You can commit 3-4 hours daily on weekdays and 6-8 hours on weekends. Non-negotiable. If you have a full-time job, this means your evenings and Sundays belong to DSA.
• You're targeting mid-tier to top-tier product companies — think Flipkart, Swiggy, PhonePe, Razorpay, Zepto, Atlassian, Walmart Labs, Adobe. Not FAANG where you need 6-8 months typically.

This plan is NOT for you if:

• You've never written code before. Go spend 6 weeks learning Python first.
• You want to crack Google/Meta in 3 months starting from zero. Be realistic.
• You can only give 1 hour a day. You'll need 6 months instead.

Fair? Let's go.

The 3-Month Breakdown: What Actually Happens Each Month

Here's the high-level map. We'll break each month down in detail after.

| Month | Focus | Problems Solved | Hours/Week | |-------|-------|-----------------|------------| | Month 1 | Foundations + patterns | ~120 problems | 25-30 | | Month 2 | Medium-hard patterns + core topics | ~150 problems | 30-35 | | Month 3 | System Design basics + mocks + revision | ~80 problems + 15 mocks | 30-35 |

Total target: 350-400 problems — not 1000, not 500. Quality over quantity. The person who solves 400 problems with full understanding will out-perform the person who grinds 800 problems on autopilot. Every time.

Why 350-400 problems is the sweet spot

Striver's SDE Sheet has around 190 questions. NeetCode 150 has, well, 150. Blind 75 has 75. If you master any of these and then add 100-150 company-tagged problems from the last 6 months on LeetCode, you cover 85% of what Indian product companies actually ask.

Month 1: Foundations and Pattern Recognition (Days 1-30)

Month 1 is where everyone screws up. They either go too slow (one topic per week, no urgency) or too fast (trying arrays, strings, linked lists, and trees in week one).

Here's the actual week-by-week.

Week 1-2: Arrays, Strings, Hashing, Two Pointers

Spend 12-14 days on these four topics combined. This is the foundation layer. Half of all interview questions touch at least one of these.

Daily routine:

• Morning (1 hour): Learn one new concept. Example: sliding window technique. Watch ONE video (Aditya Verma or Striver), not three.
• Evening (2-3 hours): Solve 3-4 problems on that concept. Start with easy, graduate to medium.

Target by end of Week 2: 60 problems solved, with pattern recognition starting to click.

Topics checklist:

• Array manipulation (prefix sums, Kadane's algo, Dutch national flag)
• String problems (anagrams, palindromes, pattern matching basics)
• Hashing (HashMaps for frequency counting, HashSets for lookups)
• Two pointers (opposite ends, same direction, fast-slow)
• Sliding window (fixed size and variable size)

Week 3: Recursion, Backtracking, Linked Lists

This week is where many beginners break down. Recursion feels like black magic until it suddenly doesn't.

Spend first 3 days on recursion basics — print all subsets, permutations, N-queens starter. Next 2 days on linked list patterns — reverse, detect cycle, merge sorted lists. Last 2 days on backtracking classics — Sudoku solver, word search, rat in a maze.

Target: 30 problems. Don't move on until recursion feels natural. If you can't trace a recursive call stack on paper by end of week 3, repeat week 3. Yes, delay the plan. The alternative is failing interviews.

Week 4: Stacks, Queues, Binary Search

Stacks and queues are easier than they look. Monotonic stacks (next greater element pattern) show up in Flipkart, Amazon, Microsoft interviews constantly.

Binary search is deceptively deep. "Finding an element in a sorted array" is kindergarten. "Binary search on answer space" (like Koko eating bananas, split array largest sum) is what gets asked.

Target: 30 problems. End of Month 1: you should have ~120 problems done and feel confident on 5-6 fundamental topic areas.

Month 2: Trees, Graphs, DP, and Serious Problem Solving (Days 31-60)

This is the hardest month. It's also the most important. If you survive month 2, you'll pass most product company technical rounds.

Week 5-6: Trees and Binary Search Trees

Trees are huge in Indian product interviews. Expect 1-2 tree questions in almost every Round 1.

Topics to cover:

• Tree traversals (inorder, preorder, postorder — iterative and recursive)
• Level order and all its variants (zigzag, right view, boundary traversal)
• LCA (Lowest Common Ancestor) — multiple approaches
• Tree construction from traversals
• Diameter, max path sum, serialize/deserialize
• BST operations and validation

Target: 40 problems across trees. Pay special attention to the pattern of "recursion returning multiple values" — it unlocks half of tree problems.

Week 7: Graphs

Graphs scare people. They shouldn't. Once you internalize BFS and DFS templates, 70% of graph problems become variations of the same thing.

Must-cover topics:

• BFS and DFS (adjacency list representation)
• Cycle detection (directed and undirected)
• Topological sort (Kahn's algorithm)
• Shortest path (Dijkstra for weighted, BFS for unweighted)
• Union-Find / Disjoint Set Union
• Grid-based problems (number of islands, rotten oranges — these appear in Zepto, Swiggy interviews a lot)

Target: 30 problems. You don't need Bellman-Ford or Floyd-Warshall unless you're targeting Google or Meta.

Week 8: Dynamic Programming — The Beast

DP deserves its own week. Honestly, it deserves more, but we don't have time.

The secret with DP: don't try to solve problems by thinking "what's the DP formula?" Instead, master recursion + memoization first, then convert to tabulation.

Order of DP topics to cover:

1. 1D DP (Fibonacci, climbing stairs, house robber)
2. 2D DP on grids (unique paths, minimum path sum)
3. Subsequence DP (longest increasing subsequence, longest common subsequence)
4. Knapsack patterns (0/1 knapsack, unbounded knapsack, subset sum)
5. String DP (edit distance, palindrome partitioning)
6. DP on trees (if time permits)

Target: 40 problems. If you only get through 25 solid DP problems with full understanding, that's better than 60 half-understood ones.

By end of Month 2 you'll have around 270 problems solved. You'll also be exhausted. That's normal. Take Sunday off at the end of week 8. Actually off. No LeetCode.

Month 3: System Design, Mocks, and Interview Readiness (Days 61-90)

Month 3 is not about learning new topics. It's about becoming interview-ready. Big difference.

Week 9: Advanced Topics + Low-Level Design Basics

Cover the remaining topics quickly:

• Tries (needed for autocomplete-style questions)
• Segment trees (only for top-tier target companies)
• Bit manipulation (basics only — XOR tricks, bit counting)
• Greedy algorithms (interval scheduling, Jump game variants)

Target: 25 problems.

Then start Low-Level Design (LLD). For 3+ YOE candidates, LLD rounds are standard at Flipkart, Swiggy, Razorpay, PhonePe. Learn:

• SOLID principles (actually understand them, not just name them)
• Common patterns: Factory, Singleton, Observer, Strategy
• Classic LLD problems: Parking lot, Splitwise, BookMyShow, Elevator system

Watch Arpit Bhayani or Udit Agarwal's LLD content on YouTube. One problem per day for 4-5 days is enough.

For mid-level engineers looking at design rounds, this system design interview questions resource covers both HLD and LLD angles that Indian product companies ask.

Week 10: Mock Interviews Phase 1

Start doing mock interviews. 3-4 per week, minimum.

Where to get mocks:

• Pramp or Interviewing.io — free peer mocks (variable quality)
• Topmate — paid mocks with current SDE-2/3 from product companies (₹500-₹2000 per session, worth it)
• AI mock interviews — practice with AI mock interviews is excellent for low-pressure daily practice, especially if explaining your thought process out loud is new to you
• Friends in product companies — ask for 30-min DSA mocks. They'll usually say yes.

In mocks, focus on:

1. Clarifying questions before coding
2. Explaining approach before writing code
3. Walking through examples
4. Writing clean code (variable names matter)
5. Discussing time/space complexity unprompted

Target: 8-10 mocks this week.

Week 11: Company-Specific Preparation

Pick your target companies (3-5 of them) and solve their last 6 months of tagged problems on LeetCode. Use the premium filter if you can — it's worth ₹2500/year during job search.

Also study each company's interview structure:

• Flipkart: 2 DSA + 1 LLD + 1 HLD + 1 HM round
• Amazon: 2-3 DSA + LLD + leadership principles
• Razorpay: 2 DSA + 1 LLD + 1 HLD + culture
• Zepto: 1 DSA (often harder) + 1 LLD + system design + bar raiser

Reference material: our detailed breakdown of how to crack Zepto, Blinkit, Meesho interviews and company-specific playbooks are gold here.

Target: 40 company-tagged problems this week.

Week 12: Revision, Mocks, and Confidence Building

Final week. Do NOT learn anything new. Repeat.

Daily routine:

• Morning: revise 10 problems you previously struggled with. Just read your notes/solutions.
• Afternoon: 1 full mock interview (60-90 min).
• Evening: solve 2 fresh medium problems to keep edge sharp.

Also: fix your resume and check your ATS score on CareerLens, update LinkedIn, start applying aggressively. Don't wait until "prep is done" — it never feels done.

By end of Week 12, you've solved 350-400 problems, done 15+ mocks, and understand your core patterns cold. You are interview-ready.

The Daily Problem-Solving Framework That Actually Works

Here's the exact framework successful candidates use for each problem. Follow this, not "watch solution first":

1. Read the problem twice. Don't start coding yet.
2. Walk through 2 examples by hand. On paper. Yes, actual paper.
3. Think for 20 minutes. Timer on. Try at least one brute force approach.
4. If stuck after 20 min, read ONLY the hints (not the full solution).
5. Think for another 15 minutes.
6. If still stuck, read the editorial, understand deeply, close it, re-implement from scratch. This step is critical. Reading ≠ learning.
7. Write down the pattern in a notion/notebook: "This was a sliding window variable size problem. Trigger: longest substring with condition X."

This takes 40-60 minutes per medium problem. In 3-4 hours daily, you'll do 4-6 problems with real learning. Not 15 problems you'll forget by next week.

The common mistake: solving without reflecting

Most people solve a problem, mark it green on LeetCode, and move on. Three weeks later, they can't solve the same problem. Why? Because they solved the specific problem but didn't extract the pattern.

Spend 5 minutes after every problem writing down: What was the pattern? What was the trigger? What similar problems does it connect to? This habit alone separates the engineers who crack interviews from those who grind forever.

Resources: What to Actually Use (And What to Skip)

Too much content causes paralysis. Here's my ruthless shortlist.

Primary resources (pick ONE sheet, don't jump between)

• Striver's A2Z DSA Sheet — most comprehensive, Indian context, free on takeuforward.org
• NeetCode 150 — cleaner progression, better for product company focus
• Love Babbar 450 — longer, decent but outdated in parts

Pick one. Stick with it. Switching sheets mid-plan = death.

Video content (optional, use sparingly)

• Aditya Verma for recursion and DP (gold standard)
• Striver for everything else
• Abdul Bari for algorithm theory (only if curious)

Practice platforms

• LeetCode — primary platform, essential
• GeeksforGeeks Practice — good for Indian company tagged questions
• Codeforces — only if you want to go beyond interview prep

Skip: paid courses promising "guaranteed placement" for ₹50,000. The content is on YouTube for free.

Common Mistakes That Waste Your 3 Months

I've seen these over and over. Avoid them.

1. Tutorial purgatory

Watching 8 hours of video a day feels productive. It isn't. If you're not writing code, you're not preparing. Minimum 70% of your time should be spent solving, not watching.

2. Ignoring weak topics

You hate DP, so you skip it. Great — now Flipkart's second round will have a DP question and you'll freeze. Lean into weak topics. Spend extra time there, not less.

3. No mock interviews until "I'm ready"

You'll never feel ready. Start mocks from week 8-9 even if you suck. Being bad in a mock is free. Being bad in a real interview costs you a job.

4. Not applying while preparing

Start applying by Week 8. Interview cycles take 3-6 weeks. If you wait until "prep is done," you'll add another 2 months to your timeline. Browse matched jobs on CareerLens to start building a pipeline early.

5. Comparing yourself to Twitter

Someone on Twitter solved 1500 problems in 2 months. Someone else cracked Google in 45 days. Ignore them. Your journey is yours. Compare today-you to yesterday-you.

Expected Outcomes: What's Realistic After 90 Days

Let's be honest about what 3 months of serious prep gets you.

| Target Companies | Realistic Outcome After 90 Days | |------------------|--------------------------------| | Tier 3 product (Zoho, Freshworks, Nagarro) | High chance of cracking 1-2 offers | | Tier 2 product (Flipkart, Swiggy, PhonePe, Razorpay) | Moderate chance, 2-3 companies deep | | Tier 1 product (Amazon, Microsoft, Atlassian) | Possible but requires exceptional execution | | FAANG (Google, Meta) | Very unlikely in 3 months from scratch |

Salary expectations after cracking Tier 2 product companies with 2-4 YOE: 22-38 LPA fixed + stocks. For specifics, benchmark your salary on CareerLens based on your current experience and target role.

FAQ

How many LeetCode problems should I solve for product company interviews in India in 2026?

For mid-tier product companies (Flipkart, Swiggy, PhonePe, Razorpay), 300-400 well-understood problems are sufficient if they cover all major patterns — arrays, strings, trees, graphs, DP, two pointers, sliding window, backtracking. For top-tier (Amazon, Microsoft), aim for 400-500. For FAANG (Google, Meta), 500-700 problems with heavy focus on medium-hard tagged problems. The number matters less than depth. Someone who solves 300 problems and can explain patterns beats someone who grinds 800 and forgets half.

Can I crack Amazon or Flipkart with just 3 months of DSA preparation?

Yes, if you already have a programming background and can dedicate 4-6 hours daily. Many engineers from TCS, Infosys, Wipro have cracked Flipkart, Amazon, and PhonePe within 3-4 months of focused prep. The key factors are: consistent daily practice, pattern recognition over rote solving, at least 15 mock interviews before real ones, and strong communication skills during problem solving. Fresh graduates might need 4-5 months, while 2-4 YOE engineers with existing coding fundamentals can realistically do it in 90 days.

Is Striver's SDE sheet or NeetCode 150 better for Indian product company interviews?

Both work. Striver's A2Z Sheet is more comprehensive and has strong Indian context — many problems are tagged with Indian company interview history. NeetCode 150 is more compact, better organized by pattern, and ideal if you have less time. For 3-month prep, NeetCode 150 followed by 100 company-tagged problems from LeetCode is efficient. For 6-month prep, Striver's full sheet gives better coverage. Don't do both — pick one and commit. Switching between sheets causes gaps and wastes time.

Do I need to prepare system design in 3 months of DSA prep for Indian product companies?

For freshers and up to 1 YOE, no — only basic LLD knowledge is tested. For 2-4 YOE candidates targeting product companies, yes, basic LLD and some HLD are required. Allocate the last 2-3 weeks of your 3-month plan for system design. Cover SOLID principles, 4-5 common design patterns, and solve 5-7 classic LLD problems (parking lot, Splitwise, BookMyShow). For HLD, understand basics like load balancing, caching, databases, and solve 3-4 common systems (URL shortener, chat app, Instagram feed). Deep system design mastery takes months — focus on basics first.

How do I prepare DSA while working full-time at a service company like TCS or Infosys?

Treat prep like a second job. Realistic schedule: 1.5 hours before office (6:00-7:30 AM) for new concepts, 2.5 hours after office (8:30-11:00 PM) for problem solving, 6-8 hours each Saturday and Sunday. That's 25-30 hours a week — enough for 3-month timeline. Minimize office overtime politely. Avoid weekend plans for 90 days. Communicate with family about the sacrifice. Use office commute time for revising problem patterns on your phone. The engineers who make this transition successfully treat these 90 days as non-negotiable, like preparing for an exam.

Bottom Line

• Commit to 350-400 problems with deep understanding, not 1000 solved on autopilot. Quality compounds, quantity doesn't.
• Follow the month-by-month structure: foundations in Month 1, hard topics (trees, graphs, DP) in Month 2, mocks and company-specific prep in Month 3.
• Pick ONE DSA sheet — Striver's A2Z or NeetCode 150 — and stick with it for the full 90 days. Switching sheets kills momentum.
• Start mock interviews by Week 8 at the latest. Peer mocks on Pramp, paid mocks on Topmate, or AI mock interviews daily. You'll never feel ready — do them anyway.
• Apply from Week 8 onwards, not after prep is "complete." Interview cycles take 3-6 weeks, so parallel applications save you 2 months.
• 70% of your time should be solving problems, 30% learning concepts. Tutorial purgatory kills more careers than any other mistake.
• Realistic outcome: 2-3 offers from Tier 2-3 product companies at 22-38 LPA range. Top-tier and FAANG possible but require either prior background or more time.

Three months is enough. Not easy, but enough. The engineers who crack it aren't smarter — they're just more consistent. Start today.