Roadmaps › Placement
Placement Preparation Roadmap
Everything campus placements test — DSA, CS fundamentals, aptitude, projects, resume and interviews — in the order to learn it.
Level: All levels · Duration: 6 months
Step 1: Pick one language
Interviewers let you use C++, Java or Python. Choose one and stick with it.
Campus coding rounds let you choose C++, Java or Python, and you should use the same one for every round. Pick the one you already know best — switching languages in the middle of preparation wastes weeks.
- Choose C++ (fast, common in CP), Java (common in Indian companies) or Python (quick to write)
- Stick to the same language for DSA, OA and interviews
- Be able to write any loop, function or collection without searching
Resources: C++ roadmap · Java roadmap
Syntax & built-in collections
You should write loops, functions and use maps/sets without looking things up.
You should be fluent in the basics and in the built-in data structures — dynamic arrays, hash maps, sets, stacks, queues and priority queues — because every DSA solution uses them.
- Variables, types, loops, functions and integer limits
- Dynamic arrays and strings
- Hash map / hash set / priority queue in your language
- Sorting with a custom comparator
Resources: C++ documentation · Java documentation · Python documentation
Basic problems
Warm up with number and pattern problems.
Warm up with number and pattern problems to build speed and confidence before real DSA. Many service-company tests still include questions like these.
- Digits, primes, GCD/LCM, factorial, palindromes
- Star and number patterns
- Simple array tasks: max, second max, reverse, rotate
Resources: Practice: Basics problems
Step 2: DSA foundations (months 1–2)
Arrays, strings, hashing, searching and recursion.
The first two months build the patterns that appear in most coding rounds. Solve problems topic by topic, write down the pattern each one used, and aim for around 2–3 problems a day.
- Big-O analysis of every solution you write
- Arrays, strings and hashing patterns
- Binary search including "search on the answer"
- Recursion and backtracking basics
Resources: Full DSA roadmap · Notes: Big-O · ▶ Striver's A2Z DSA Course
Arrays & strings
Two pointers, sliding window, prefix sums.
Arrays and strings are the most asked topics in online assessments. Master two pointers, sliding window and prefix sums so you can turn O(n²) ideas into O(n).
- Two pointers and sliding window
- Prefix sums and Kadane's algorithm
- Rotations, rearrangements and in-place tricks
- Anagrams, palindromes and frequency counting
Resources: Practice: Arrays problems · Practice: Strings problems
Hashing
Counting and lookups.
Hash maps answer "have I seen this?" and "how many?" in O(1), which is the key step in many medium problems.
- Frequency counting and duplicates
- Two Sum and complement lookups
- Subarray sum with prefix sums + map
Resources: Practice: Hashing & Two Pointers problems
Binary search
On arrays and on answers.
Binary search is asked in almost every company test, often hidden as "find the minimum X such that…".
- Lower/upper bound and first/last occurrence
- Rotated sorted array
- Binary search on the answer (allocation, cows, bananas)
Resources: Practice: Binary Search problems
Recursion & backtracking
Subsets, permutations, N-Queens.
Recursion is the base for trees, graphs and DP, and backtracking questions (subsets, permutations, N-Queens) are common in product-company rounds.
- Writing base and recursive cases
- Subsets and permutations
- Backtracking with pruning
Resources: Practice: Recursion & Backtracking problems
Step 3: DSA advanced (months 3–4)
Linked lists, stacks, trees, graphs and dynamic programming.
Months three and four cover the data structures and techniques that decide product-company interviews: linked lists, stacks, trees, graphs and dynamic programming.
- Pointer problems on linked lists
- Stack and queue patterns
- Tree recursion and BSTs
- Graph traversal and shortest paths
- Dynamic programming patterns
Resources: ▶ Graph Series · ▶ Dynamic Programming Series
Linked list, stack & queue
Pointer tricks and monotonic stacks.
Linked lists test careful pointer handling; stacks and queues appear in bracket matching, next-greater-element and BFS problems.
- Reverse, find middle, detect cycle
- Valid parentheses and min stack
- Monotonic stack (next greater, histogram)
Resources: Practice: Linked List problems · Practice: Stack & Queue problems
Trees & BST
Traversals and recursion on trees.
Tree questions are mostly recursion: compute something for the left and right subtrees and combine. BST questions add ordering.
- Traversals and level order
- Height, diameter, balanced tree, LCA
- Validate BST and kth smallest
Resources: Practice: Trees problems
Graphs
BFS, DFS, topological sort, Dijkstra.
Graphs appear in most product-company interviews. Be comfortable building an adjacency list and running BFS/DFS on graphs and grids.
- BFS, DFS and connected components
- Cycle detection and topological sort
- Dijkstra and DSU
Resources: Practice: Graphs problems
Dynamic programming
Knapsack, LCS, LIS, grid DP.
DP is the most feared topic, but most interview DP questions follow a few templates. Practise defining the state in words before coding.
- 1D DP and grid DP
- Knapsack and coin change
- LCS, edit distance and LIS
Resources: Practice: Dynamic Programming problems
Greedy & bits (optional)
Intervals and XOR tricks.
Greedy and bit manipulation questions are shorter but come up regularly, especially in online assessments.
- Interval scheduling and jump game
- Minimum platforms and assign cookies
- XOR tricks and counting set bits
Resources: Practice: Greedy problems · Practice: Bit Manipulation problems
Step 4: OOP
Asked in almost every technical interview.
Object-oriented programming is asked in nearly every technical interview, especially at service companies. Be ready to define each concept, give a real-life example and write a small code example.
- Classes, objects, constructors
- Encapsulation, abstraction, inheritance, polymorphism
- Overloading vs overriding
- Abstract class vs interface
Resources: Interview questions: OOP
Four pillars
With a real-life example for each.
Interviewers expect a definition, a real-world example and a code snippet for each pillar — for example a BankAccount class for encapsulation.
- Encapsulation with private fields and getters/setters
- Abstraction with abstract classes/interfaces
- Inheritance and the "is-a" relationship
- Compile-time vs runtime polymorphism
Resources: Notes: Four Pillars of OOP
Abstract class vs interface
A favourite interview question.
A favourite interview question: both define behaviour without full implementation, but they differ in state, constructors, multiple inheritance and intent.
- Differences in fields, constructors and method types
- Multiple inheritance through interfaces
- When to choose each, with an example
Resources: Notes: Abstract Class vs Interface
SOLID & design patterns (optional)
For product companies.
Product companies sometimes go deeper into design: SOLID principles and a few common patterns show you can write maintainable code.
- Single responsibility and open/closed principles
- Dependency inversion
- Singleton, factory and observer patterns
Resources: Notes: SOLID Principles
Step 5: Operating Systems
Processes, scheduling, deadlocks and memory.
OS questions check whether you understand what happens beneath your code: how processes run, share the CPU and memory, and avoid getting stuck.
- Processes, threads and context switching
- CPU scheduling algorithms
- Synchronization and deadlocks
- Paging and virtual memory
Resources: ▶ Operating System · Interview questions: Operating Systems
Process vs thread
Context switching, multithreading.
A process is a running program with its own memory; threads are lighter units inside a process that share its memory. Expect to explain the difference and the trade-offs.
- Process states and the PCB
- Threads vs processes: memory, cost, communication
- Context switching
- Multithreading vs multiprocessing
Resources: Notes: Process vs Thread
CPU scheduling
FCFS, SJF, Round Robin.
The scheduler decides which process runs next. You may be asked to compute waiting and turnaround times by hand.
- FCFS, SJF, SRTF, priority and round robin
- Preemptive vs non-preemptive
- Waiting time and turnaround time calculations
- Starvation and aging
Resources: Notes: CPU Scheduling Algorithms
Deadlocks
Conditions, prevention, Banker's algorithm.
A deadlock happens when processes wait on each other forever. Know the four necessary conditions and how systems prevent, avoid or recover from deadlock.
- The four Coffman conditions
- Prevention vs avoidance vs detection
- Banker's algorithm
- Mutex and semaphore basics
Resources: Notes: Deadlocks
Memory management
Paging, segmentation, virtual memory.
The OS gives every process the illusion of its own large memory. Paging, virtual memory and page replacement are classic interview topics.
- Paging and segmentation
- Virtual memory and page faults
- Page replacement: FIFO, LRU, Optimal
- Thrashing
Resources: Notes: Memory Management
Step 6: DBMS & SQL
Every service company asks SQL queries.
Almost every placement interview includes DBMS questions and at least one SQL query. Focus on keys, normalization, transactions, indexing and writing joins confidently.
- Keys and normalization
- SQL queries with joins and GROUP BY
- ACID and transactions
- Indexing basics
Resources: ▶ DBMS Complete Playlist · Interview questions: DBMS · SQL documentation · ▶ SQL Complete Course (MySQL)
Keys & normalization
1NF → BCNF.
Keys identify rows and connect tables; normalization removes duplicated data so updates do not cause anomalies.
- Primary, candidate, super, foreign keys
- 1NF, 2NF, 3NF and BCNF with examples
- Update, insert and delete anomalies
Resources: Notes: Keys and Normalization
SQL queries & joins
Second highest salary, GROUP BY, joins.
Expect to write queries on paper: the Nth highest salary, employees per department, customers with no orders. Joins and GROUP BY appear in most of them.
- SELECT, WHERE, ORDER BY, LIMIT
- INNER, LEFT, RIGHT and self joins
- GROUP BY with HAVING
- Subqueries and the Nth highest salary query
Resources: SQL practice (live database) · Second highest salary · Notes: SQL Essentials and Joins
Transactions & ACID
Isolation levels, locking.
A transaction is a group of operations that must succeed or fail together. ACID properties and isolation levels explain how databases stay correct with many users.
- Atomicity, consistency, isolation, durability
- Commit and rollback
- Isolation levels and dirty/phantom reads
- Locks basics
Resources: Notes: Transactions and ACID
Indexing
B+ trees, SQL vs NoSQL.
Indexes make lookups fast at the cost of extra storage and slower writes. Interviewers often ask how an index works and when not to use one.
- What an index is and how B+ trees help
- Clustered vs non-clustered indexes
- SQL vs NoSQL in one or two sentences
Resources: Notes: Indexing and B+ Trees
Step 7: Computer Networks
The layers of the internet and the classic "type a URL" question.
Networking questions test how data travels across the internet. The layered models and "what happens when you type a URL" are asked very often.
- OSI and TCP/IP layers
- TCP vs UDP
- DNS, HTTP/HTTPS and the URL journey
- IP addressing basics
Resources: ▶ Computer Networks · Interview questions: Computer Networks
OSI & TCP/IP models
What each layer does.
The OSI model splits networking into seven layers; the practical TCP/IP model uses four. Know what each layer does and one protocol at each.
- The seven OSI layers in order
- Mapping OSI to TCP/IP
- Protocols per layer (HTTP, TCP, IP, Ethernet)
Resources: Notes: OSI and TCP/IP Models
TCP vs UDP
Reliability vs speed; the 3-way handshake.
TCP is reliable and ordered (web, email); UDP is fast with no guarantees (video calls, games). The three-way handshake is a frequent follow-up.
- Connection-oriented vs connectionless
- The three-way handshake
- Use cases for each
Resources: Notes: TCP vs UDP
What happens when you type a URL
DNS → TCP → TLS → HTTP → render.
A classic question that touches everything: DNS lookup, TCP and TLS handshakes, the HTTP request, the server response and the browser rendering the page.
- DNS resolution
- TCP + TLS handshakes
- HTTP request and response
- Rendering in the browser
Resources: Notes: Type a URL
IP addressing & subnetting (optional)
Common in network-heavy roles.
Some companies (especially networking roles) ask about IP classes, subnet masks and CIDR notation.
- IPv4 vs IPv6
- Subnet masks and CIDR
- Public vs private IP addresses
Resources: Notes: IP Addressing and Subnetting
Step 8: Aptitude & reasoning
The first round of most campus drives.
Most mass-recruitment drives (TCS, Infosys, Wipro, Accenture…) start with an aptitude test that eliminates many candidates. It is mostly speed and practice, so start early alongside DSA.
- Quantitative aptitude basics
- Logical reasoning patterns
- Verbal ability
- Speed through timed practice
Resources: Aptitude practice · Aptitude mock test
Quantitative aptitude
Percentages, ratios, time & work, probability.
Arithmetic topics repeat in every test. Learn the shortcuts and practise daily for speed.
- Percentages, profit & loss, ratios
- Time & work, time speed & distance
- Simple and compound interest
- Permutations, combinations and probability
Resources: Percentages · Time & Work · Probability
Logical reasoning
Series, puzzles, seating arrangements, blood relations.
Reasoning questions test pattern spotting and careful reading. A few question types cover most tests.
- Number and letter series
- Seating arrangements and puzzles
- Blood relations, directions and coding–decoding
- Syllogisms
Resources: Number series · Blood relations · Syllogisms
Verbal ability
Reading comprehension, grammar, sentence correction.
Verbal sections check reading comprehension and basic grammar — straightforward if you read regularly.
- Reading comprehension
- Sentence correction and grammar
- Synonyms, antonyms and fill in the blanks
Resources: Sentence correction · Reading comprehension
Timed mock tests (optional)
Practise speed — most tests give ~1 minute per question.
Tests give about a minute per question, so practise full mocks with a timer and learn when to skip a question.
- Full-length timed mocks
- Skipping and returning strategy
- Reviewing every wrong answer
Resources: Aptitude mock test
Step 9: Projects & GitHub
Two solid projects you can explain end to end.
Interviewers spend real time on your projects. Two solid projects that you built yourself — and can explain end to end — matter more than five copied ones.
- One full stack project, deployed
- One project that shows problem solving
- Clean code and a clear README
Resources: MERN roadmap · Git documentation · ▶ Complete Git and GitHub Tutorial
One full stack project
Auth, database, deployed with a live link.
A deployed web app with login, a database and a real use case shows you can build complete software. Be ready to explain every design decision.
- Authentication and authorisation
- Database design and APIs
- Deployment with a live link
- Explaining challenges you faced and how you solved them
One problem-solving project
Something that uses data structures or an API in an interesting way.
A second project that uses algorithms or an interesting API (a pathfinding visualiser, a scheduler, a chess engine) stands out.
- Pick something that uses data structures meaningfully
- Measure and mention performance
- Keep the scope small enough to finish
Clean GitHub profile
README with screenshots and setup steps.
Recruiters do open your GitHub. Pinned repositories with good READMEs and screenshots make a strong impression.
- Pinned repositories
- README: what it does, screenshots, how to run it
- Meaningful commit history
Step 10: Resume & profiles
Get shortlisted.
Your resume decides whether you get shortlisted. Keep it to one page, focused on projects, skills and achievements with numbers.
- One-page resume structure
- LinkedIn profile
- Coding profiles as proof of practice
One-page resume
Projects with impact numbers, skills, education, links.
Keep it simple, clean and ATS-friendly. Lead with education and projects; describe impact with numbers ("reduced load time by 40%").
- Sections: education, skills, projects, achievements, links
- Action verbs and measurable impact
- No spelling mistakes, no fancy layouts that confuse ATS
Headline, about, featured projects, certificates.
Recruiters search LinkedIn. A clear headline, an about section and your projects and certificates make you easy to find.
- Headline, photo and about section
- Featured projects and certificates
- Connecting with seniors and recruiters
Resources: Your certificates
Coding profiles (optional)
LeetCode / Codeforces / CodeChef ratings help for product companies.
Ratings on LeetCode, Codeforces or CodeChef show consistent practice and help with product-company shortlists.
- Solving regularly on one platform
- Participating in contests
- Adding profile links to your resume
Step 11: Interview rounds
Practise exactly what you will face.
A typical campus process is: online assessment → technical interview(s) → HR interview. Prepare for each round specifically.
- Online assessment format
- Technical interview structure
- HR interview questions
Resources: Interview questions: DSA · Weekly contests
Online assessment
Timed coding tests — practise with contests.
Online assessments usually have aptitude MCQs and 2–3 coding problems in 60–90 minutes. Speed and accuracy matter most.
- Reading problems quickly and checking constraints
- Handling edge cases and large inputs
- Practising with timed contests
Resources: Contests
Technical interview
Explain approach first, then code, then test with examples.
In the technical round you solve a problem while explaining your thinking, then answer questions on CS fundamentals and your projects.
- Clarify → brute force → optimise → code → test
- Thinking out loud
- CS fundamentals and project questions
- Asking good questions at the end
Resources: Company sheets
HR interview
Tell me about yourself, strengths, why this company.
The HR round checks communication, attitude and fit. Prepare honest, structured answers to the common questions.
- "Tell me about yourself" in under two minutes
- Strengths, weaknesses and why this company
- Relocation, shifts and bond questions
- STAR method for behavioural answers
System design basics (optional)
For product companies and higher packages.
Product companies and higher packages may include a basic design discussion — how you would build a URL shortener or a chat app.
- Clients, servers, databases and caches
- Scaling with load balancers
- Walking through a simple design end to end
Resources: Interview questions: System Design