Students preparing for TCS NQT and Flipkart need COMPLETELY different preparation. This program targets the product company pipeline specifically — DSA depth, system design, and interview communication that service company prep doesn't cover.
C++ / Java / Python — write clean, optimised code under interview pressure
C++: STL (vectors, maps, sets, priority_queue, algorithms), pointers, memory management, templates. Java: Collections framework, Streams, lambdas, generics, concurrency basics. Python: built-in data structures (dict, set, defaultdict, Counter, heapq), itertools, functools. Master ONE language deeply — interviewers test depth, not breadth.
Write clean code under pressure: meaningful variable names, helper functions for readability, handle edge cases first, communicate approach before coding. Time management: 5 min understand → 10 min approach → 15 min code → 5 min test. The coding style that makes interviewers say "this person writes production-quality code."
Arrays to graphs to segment trees — know WHEN to use each, not just HOW
Arrays (prefix sums, kadane's, sliding window, two pointers), Strings (pattern matching, KMP, Z-algorithm), Linked Lists (reversal, cycle detection, merge), Stacks (monotonic stack, next greater element), Queues (deque, BFS), Hash Maps (frequency counting, two-sum pattern, grouping). Each with 20+ problems at medium difficulty — the EXACT level product companies test.
Trees: BST operations, tree traversals (inorder/preorder/postorder/level-order), LCA, diameter, balanced BST. Heaps: priority queue, top-K problems, median maintenance. Tries: prefix search, autocomplete. Graphs: BFS, DFS, topological sort, shortest path (Dijkstra, Bellman-Ford), MST (Kruskal, Prim), union-find. Advanced: Segment trees, Fenwick trees (for competitive coding rounds).
DP, greedy, backtracking, graph algorithms — the patterns that solve 80% of interview problems
Sorting (merge sort, quick sort internals — "implement quicksort" is a real interview question). Binary Search (on answer space, rotated arrays). Recursion & Backtracking (permutations, combinations, N-Queens, sudoku solver). Greedy (activity selection, interval scheduling, Huffman). Divide & Conquer. Bit Manipulation (XOR tricks, power of 2, single number). Each pattern taught with the recognition trigger: "When you see X in the problem, think Y pattern."
DP approach: identify subproblems → define recurrence → base cases → memoisation → tabulation → space optimisation. Classic DP: 0/1 knapsack, longest common subsequence, edit distance, coin change, longest increasing subsequence, matrix chain multiplication. DP on strings, DP on trees, DP on grids. 50+ DP problems from easy to hard. "DP is the topic that separates ₹10L offers from ₹25L+ offers" — it's that important.
Design classes. Design architectures. The round tested at ₹20L+ roles.
OOP principles: SOLID (Single Responsibility, Open-Closed, Liskov, Interface Segregation, Dependency Inversion). Design patterns: Strategy, Observer, Factory, Singleton, Builder, Adapter, Decorator. LLD exercises: design a parking lot, design an elevator system, design a chess game, design an LRU cache. Class diagrams, interfaces, and clean architecture. "Design X using OOP" — the round that tests engineering quality, not just problem-solving ability.
System design framework: requirements → capacity estimation → API design → database schema → high-level architecture → deep dive into components → bottlenecks → scaling. Core concepts: load balancing, caching (Redis, CDN), database sharding, message queues (Kafka, SQS), microservices, CAP theorem, consistent hashing, rate limiting. Practice problems: design URL shortener, design Twitter/Instagram feed, design WhatsApp chat, design notification system, design payment gateway.
OS, DBMS, CN, OOP — at the depth product companies probe, not MCQ level
Product companies don't ask MCQs — they ask follow-ups. "What is indexing?" → "B+ tree vs hash index?" → "When would you NOT index?" → "How does the query planner decide?" Three levels deep on each topic. OS: process scheduling + virtual memory + concurrency (mutex vs semaphore — with code). DBMS: indexing internals + transaction isolation levels + MVCC. CN: "What happens when you type google.com?" (end-to-end). OOP: SOLID with code examples showing violation → fix.
Speed coding, contest strategies, and OA-specific preparation
Online Assessment format: 2–3 problems in 60–90 minutes on HackerRank, CodeSignal, or company platforms. Strategy: read ALL problems first → solve easiest → partial solutions for hard ones (partial credit matters). Speed techniques: prewritten templates for common patterns (BFS, DFS, binary search, segment tree). Time allocation: 20 min easy, 25 min medium, 25 min hard attempt. Weekly timed OA simulations matching real company formats.
Weekly contests on Codeforces/LeetCode: build speed and pressure tolerance. Virtual contests: simulate real OA environment (timer, no external help). Post-contest analysis: review editorial, learn new patterns, upsolve problems you couldn't solve during contest. Rating tracking: measure improvement over weeks. The competitive coding skills that clear OA rounds at Amazon, Google, Microsoft, DE Shaw, Uber.
The technical profile that gets past resume screening
2–3 projects showing engineering depth (not tutorial projects): a full-stack application with auth + database + deployment, a system/tool that solves a real problem, or a data/ML project with evaluation. Each project: clean GitHub repo, comprehensive README (problem, architecture, setup, screenshots), deployed demo, meaningful commit history. "Tell me about a project you've built" → 5-minute walkthrough covering architecture decisions, challenges faced, and what you'd improve. Product companies evaluate projects harder than service companies.
Think aloud, communicate solutions, and answer Amazon LPs — the skills that convert interviews into offers
Think aloud: explain reasoning while solving. "I'm considering two approaches: brute force O(n²) using nested loops, or optimal O(n) using a hash map. Let me go with the hash map." Ask clarifying questions: "Can the array have negative numbers?" "Should I handle empty input?" When stuck: "I'm not sure about the optimal approach, but here's a working solution I can optimise from." Interviewers evaluate PROCESS, not just the answer. 10+ mock DSA interviews with structured feedback.
Amazon Leadership Principles: Customer Obsession, Ownership, Bias for Action, Disagree and Commit — prepare 2 stories per LP. STAR method for every behavioural question. Google: "Googleyness" — intellectual humility, collaboration, doing the right thing. Common questions: "Tell me about a conflict with a teammate," "Tell me about a time you failed," "Tell me about your biggest technical challenge." 5 prepared STAR stories that cover 15+ question types. 5+ mock behavioural interviews with LP-specific feedback.
OA (2 DSA) → 4 interviews: 2 DSA + 1 LLD/HLD + 1 Behavioural (Leadership Principles are CRITICAL — prepare 14 LP stories)
Phone screen → 4–5 onsite: 3 DSA (hard) + 1 System Design + 1 Googleyness. DSA is the hardest; system design expected even for new grads
OA → 3–4 rounds: DSA + LLD (OOP design emphasis) + HLD + HR. LLD is heavier than at other companies — SOLID + design patterns depth
OA → Machine coding (build a mini-app in 90 min) → DSA + System Design. Machine coding round is unique — tests practical implementation speed
OA → DSA (medium-hard) + System Design (payment-specific: design payment gateway, handle idempotency) + Behavioural. Domain knowledge is bonus
Quant + DSA (hard, competitive-coding style) + System Design + CS fundamentals (OS depth). Math/probability questions alongside DSA — strongest companies test hardest
The OA format at Amazon, Google, Flipkart. Arrays, trees, graphs, DP — not easy problems, not competitive-programming impossible. The sweet spot that product companies test. 500+ problems practised at this level.
Walk through: requirements → estimation → API → schema → architecture → scaling → trade-offs. 10+ system design problems practised. "Design a URL shortener" answered in 35 minutes with load balancing, caching, and database sharding.
Explain approach before coding, consider alternatives, analyse complexity, handle edge cases, test with examples. The communication that makes interviewers say "strong hire" even when the solution isn't perfect.
2 prepared STAR stories per LP. "Tell me about a time you disagreed with your team" → structured 2-minute answer with Situation, Task, Action, Result. Behavioural rounds are pass/fail — preparation is the difference.
E-305, Industrial Area, Sahibzada Ajit Singh Nagar, Punjab 160055, IN
