90-Day Placement Preparation Roadmap

This roadmap is for students preparing for campus placements or off-campus drives for entry-level software roles, usually in the pre-final or final year. It assumes you can already write basic programs in one language (loops, functions, arrays) and can give preparation about two to three hours on most weekdays, with a little more at weekends. If you are starting from zero programming, spend two or three weeks learning a language first; the plan still works, just shifted later.

Selection processes differ between colleges, countries and companies, but many include some combination of the same rounds: an online assessment with aptitude and coding questions, technical interviews on data structures, algorithms, core computer science subjects and your projects, and an HR or behavioural round. The plan covers each of those in an order that builds on itself. Coding comes first because it takes the longest to build, then theory, aptitude, your own story, and finally practice under interview conditions.

1. DSA basics
2. Patterns
3. CS core
4. Aptitude
5. Projects
6. Mocks
7. Revision

If you have less than 90 days, keep the order and shrink each stage rather than skipping stages entirely:

• About 60 days: shorten DSA foundations to one week if you are already comfortable with the basics, cover core patterns in three weeks, and run aptitude alongside DSA for 30 minutes a day instead of as a separate block.
• About 30 days: focus on arrays, strings, hashing, linked lists, trees and basic recursion; revise the core CS subjects from summary notes; do aptitude daily; and keep the last ten days for mock interviews and revision.
• Assessments already scheduled: go straight to the stage your weakest round needs, and use the last-week checklist at the end of this page.

If you have more than 90 days, give the extra time to the core patterns stage. Pattern recognition comes from volume and repetition, so it benefits most from additional weeks.

The 90-day plan

Each stage lists what to do, how to know you are done, and the wins.solutions resources that help. The day ranges are a guide. If you finish a stage early, move on; if you are not done, take a few extra days and trim a later stage rather than moving on with gaps. From stage 3 onwards, keep solving one or two DSA problems a day so your coding does not go cold while you study other subjects.

1. DSA foundations

   Days 1–14

   What to do

   • Pick one language for all your coding rounds and stay with it. C++, Java and Python are the usual choices; pick the one you write fastest, and check which languages your assessment platform allows. Learn its standard library for dynamic arrays, hash maps, sets, sorting, stacks, queues and heaps.
   • Learn Big-O analysis well enough to state the time and space complexity of any code you write.
   • Cover the basics in order: arrays and strings, recursion, sorting (know how merge sort and quicksort work, not only how to call a sort function), binary search, linked lists, stacks and queues.
   • Solve easy problems on each topic. Start with the easy questions in the top array interview questions sheet.

   You're done when

   • You can write binary search without off-by-one errors and reverse a linked list without looking anything up.
   • You can state the complexity of your own solutions and explain why.
   • Most easy problems take you about 20 minutes, not an hour.

2. Core patterns

   Days 15–42

   What to do

   • Start with the array patterns: two pointers, sliding window, prefix sums, hashing, and intervals and sorting. The array interview questions sheet groups 30 problems by exactly these patterns, with answers.
   • Then cover the topics that appear on most interview lists: trees (traversals, BFS and DFS, binary search trees), heaps, graphs (BFS, DFS, topological sort, Dijkstra's algorithm), backtracking, greedy algorithms and dynamic programming. For dynamic programming, start with one-dimensional problems, then knapsack-style and grid problems, then longest increasing subsequence and longest common subsequence.
   • Move from mostly easy to mostly medium problems over these four weeks. One or two hard problems a week is enough to stretch you.
   • Keep a mistakes log: the problem, its pattern, what you missed, and the one-line insight that would have solved it.

   You're done when

   • Given a new medium problem, you can usually name the likely pattern within a few minutes, even if you cannot finish it.
   • You can solve a medium from a familiar pattern in about 30 to 40 minutes while explaining your reasoning.
   • You have re-solved every problem in your mistakes log from scratch at least once.

3. CS fundamentals

   Days 43–56

   Technical interviews for freshers commonly include questions on core subjects. Aim for clear definitions with an example, not textbook depth.

   What to do

   • DBMS: keys, ER modelling, normalisation up to BCNF, transactions and ACID, concurrency control and indexing. Practise SQL with joins, GROUP BY with HAVING, subqueries, and classics such as finding the second-highest salary. Revise with the DBMS quick revision notes.
   • Operating systems: processes and threads, CPU scheduling, synchronisation (mutexes, semaphores, the producer-consumer problem), deadlocks and their four necessary conditions, paging, virtual memory and page replacement. Test yourself with the operating systems important questions.
   • Computer networks: the OSI and TCP/IP models, TCP versus UDP, the three-way handshake, DNS, HTTP and HTTPS, and what happens when you type a URL into a browser.
   • Object-oriented programming: encapsulation, abstraction, inheritance and polymorphism; overloading versus overriding; abstract classes versus interfaces; and a short code example of each in your interview language.

   You're done when

   • You can explain any topic above out loud in about two minutes, with an example.
   • You can write the common SQL queries on paper without running them.

4. Aptitude

   Days 57–66

   Many online assessments open with an aptitude section, and it can be the first filter. If your first assessments come before day 57, start this stage earlier and run it for 30 minutes a day alongside DSA.

   What to do

   • Quantitative: percentages, profit and loss, simple and compound interest, ratio and proportion, averages, time and work, speed, distance and time, permutations and combinations, probability and number systems. Learn the formulas from the quantitative aptitude formula sheet, then practise until you can apply them without looking.
   • Logical reasoning: number and letter series, coding-decoding, blood relations, seating arrangements, syllogisms and data sufficiency.
   • Verbal: reading comprehension, sentence correction and vocabulary in context.
   • Take timed sectional tests. After each one, sort your mistakes into "did not know the method", "calculation error" and "ran out of time". Each needs a different fix.

   You're done when

   • You can finish a timed practice section within its limit.
   • Your remaining mistakes are mostly careless ones you can name, not topics you do not know.

5. Projects and resume

   Days 67–76

   What to do

   • Choose one or two projects you built yourself and can explain in depth. Depth matters more than count: expect questions on why you chose your stack, the hardest bug you fixed, and what you would change.
   • Make each project easy to check: a README that says what it does and how to run it, a live demo or screenshots where possible, and a readable commit history.
   • Write a one-page resume in a simple single-column layout that applicant tracking systems can read: education, skills, projects, and any internships, positions of responsibility or achievements. Start each bullet with what you did, and include numbers only when they are real and you can explain them.
   • Prepare your "tell me about yourself" answer and short stories about teamwork, a mistake and a challenge. The HR interview questions guide covers the common questions and how to structure answers.
   • If applications open before day 67, write a first draft of your resume in week one and polish it here.

   You're done when

   • You can explain each project in two minutes: the problem, your part, the architecture, one hard decision and what you would improve.
   • Someone else, such as a senior, a placement cell member or a friend in industry, has read your resume and you have acted on their feedback.
   • You are comfortable being questioned on every line of your resume.

6. Mock interviews

   Days 77–85

   What to do

   • Practise coding under assessment conditions: two or three problems in 60 to 90 minutes, with no hints and no other tabs open. LeetCode's weekly contests, or virtual runs of past contests, work well for this.
   • Do technical mocks with a friend. One person interviews; the other solves a problem aloud in a plain editor or on paper, then you swap. Add a few CS fundamentals questions and a project deep-dive to each mock.
   • Do at least one HR mock using the HR interview questions. Record it and watch it back once.
   • After every mock, write down what went wrong and work on it before the next one.

   You're done when

   • You have done several full mocks, technical and HR, and the same mistakes have stopped appearing in your notes.
   • You explain your approach before you start coding without being prompted.

7. Final revision

   Days 86–90

   What to do

   • Stop starting new topics. Revise from your own material: the pattern list, your mistakes log and your one-line insights.
   • Re-solve 10 to 15 problems you once found hard, spread across different patterns.
   • Skim the DBMS notes, the operating systems questions and the aptitude formulas.
   • Rehearse your introduction and project explanations aloud.
   • Protect your sleep. One more late-night problem is rarely worth being tired in an interview.

   You're done when

   • You can summarise each pattern and each core subject from memory.
   • Every item in the last-week checklist below is ticked.

The stages run in sequence, but the skills keep overlapping. By the mock interview stage you will be using everything at once: explaining a DSA solution, answering a follow-up on indexing, and describing your project, all in the same conversation. That is why the plan keeps a small amount of daily DSA running through every later stage.

A weekly routine

A plan only works if it fits into an ordinary week of classes, assignments and exams. This template assumes about two to three hours on weekdays and a longer session on Saturday. Scale the blocks to the time you actually have, but keep the shape.

Three habits make the routine hold up:

• Same slot, most days. A fixed time is easier to keep than deciding every day when to study.
• Review before new work. Spend the first ten minutes of each session on yesterday's mistakes. It is the cheapest form of spaced repetition.
• Measure what you can do, not what you did. "Solved four sliding window mediums without hints" tells you more than "studied for three hours".

Keep Sunday light on purpose. A rest day is part of the plan, not a gap in it, and it gives you slack to absorb a busy week without falling behind.

What to do on bad weeks

Every long plan has weeks that go wrong: exams, illness, family commitments, or a stretch where every problem feels impossible. Bad weeks are normal. What matters is how quickly you get back on track.

• Shrink, don't stop. On a bad day, do a minimum version: one problem you have solved before, or fifteen minutes of revision. Keeping the habit alive makes restarting much easier than starting again from nothing.
• Don't catch up by doubling. Squeezing two weeks of work into one usually leads to another bad week. Move the plan instead: shorten a later stage, or drop lower-priority topics such as advanced graph algorithms.
• Step back a level. If a topic feels impossible, return to easier problems from the same pattern, or re-read how the pattern works, before trying mediums again.
• Put a time limit on being stuck. After 20 to 30 minutes without progress, read a hint or the approach, then close it and write the code yourself.
• Talk to someone. A friend preparing alongside you, a senior who has been through placements, or your placement cell. Comparing notes helps; comparing problem counts usually does not.
• Look after the basics. Sleep, food and some movement affect how well you think. If stress stays high for weeks or starts affecting your health, talk to someone you trust or your college's counselling service.

After a bad week, restart with something small you know you can finish, such as re-solving one familiar problem. Then pick up the plan from where it makes sense now, not from where the calendar says you should be.

Last-week checklist

Use this in the seven days before your first assessment or interview.

Preparation

• Re-solved one problem from each pattern without help
• Read through the mistakes log and one-line insights
• Revised DBMS, operating systems, networks and OOP from summary notes
• Practised the SQL queries most likely to come up
• Revised aptitude formulas and completed one timed section
• Rehearsed "tell me about yourself" and each project explanation aloud
• Prepared two or three questions to ask the interviewer

Logistics

• Resume saved as a PDF, matching the version you submitted
• Every link on the resume opens: GitHub, portfolio, LinkedIn
• Laptop, charger, camera, microphone and internet tested for online rounds
• Assessment rules checked: allowed languages, camera requirements, whether switching tabs is allowed
• ID, admit card and joining emails saved where you can find them quickly
• Read up on each company: what it does, what the role involves, and recent news

The day before

• No new topics
• Light revision only
• A full night's sleep

Placements involve timing and factors outside your control, and no plan can promise a particular outcome. What a plan does is make sure that when an opportunity comes, you are ready for it.