Building your placement preparation timetable
30 min · Beginner
Need help? Ask a tutor on WhatsApp (opens in a new tab)The placement season is eight weeks away and you have classes, labs and a list of topics that keeps growing. Without a plan you study what feels comfortable and discover the weak areas in the real test.
Mapping weeks to topics
A preparation timetable is a week-by-week plan that says what you study, when, and how you will know it is working. It gives every area a slot each week and moves from basics to timed practice.
An 8-week plan covers coding, core CS, career tasks and self-study. The example below lays one out from this course plus the self-study slots.
Example 1 · An 8-week plan from the course and self-study
coding = ["arrays, strings", "hashing", "sorting, two pointers", "prefix sums, sliding window", "recursion, greedy", "stacks, queues, lists", "trees, graph basics", "timed mixed problems"]core_cs = ["OOP revision", "DBMS and SQL", "OS: processes, scheduling", "OS: memory", "computer networks", "DBMS: transactions", "OS + CN revision", "full revision"]other = ["resume draft", "resume review", "LinkedIn and GitHub", "mock test 1", "HR answers (STAR)", "mock test 2", "group discussion", "mock interviews"]
for week, (c, cs, o) in enumerate(zip(coding, core_cs, other), start=1): print(f"Week {week}: {c} | {cs} | {o} | aptitude self-study")Week 1: arrays, strings | OOP revision | resume draft | aptitude self-study Week 2: hashing | DBMS and SQL | resume review | aptitude self-study Week 3: sorting, two pointers | OS: processes, scheduling | LinkedIn and GitHub | aptitude self-study Week 4: prefix sums, sliding window | OS: memory | mock test 1 | aptitude self-study Week 5: recursion, greedy | computer networks | HR answers (STAR) | aptitude self-study Week 6: stacks, queues, lists | DBMS: transactions | mock test 2 | aptitude self-study Week 7: trees, graph basics | OS + CN revision | group discussion | aptitude self-study Week 8: timed mixed problems | full revision | mock interviews | aptitude self-study
What this code does
- Each week has one coding topic, one core CS topic and one career task, all taught in this course, plus a fixed aptitude self-study slot from your own book or practice source.
- The first mock comes in week 4, early enough to change the second half of the plan based on what it shows.
This course covers Python, coding patterns and DSA, core CS for placements, resume and online profiles, HR and group discussion. It does not teach quantitative, logical or verbal aptitude, so those are self-study slots with one good book or free practice tests. Career tasks use your ShopLite project: a resume bullet, a STAR story (opens in a new tab) and your Tell me about yourself (opens in a new tab) answer.
A daily routine around classes
A study block is a fixed, focused session of 60 to 90 minutes on one area, with your phone away. Students with classes usually manage one block on weekdays and longer sessions at the weekend.
Use the weekend for a full mock test on Saturday and its review on Sunday. The example below adds up the minutes of such a week and splits them between areas.
Example 2 · Minutes in a week, split by area
def hm(minutes): return f"{minutes // 60} h {minutes % 60} min"
weekdays = 5 * 90 # one 90-minute block, Monday to Fridaysaturday_mock = 150sunday_review = 120total = weekdays + saturday_mock + sunday_reviewprint("Total:", hm(total))
areas = ["Coding and DSA", "Core CS", "Aptitude (self-study)", "Resume, HR, GD"]percent = [40, 20, 25, 15]for area, pct in zip(areas, percent): print(f"{area}: {hm(total * pct // 100)}")Total: 12 h 0 min Coding and DSA: 4 h 48 min Core CS: 2 h 24 min Aptitude (self-study): 3 h 0 min Resume, HR, GD: 1 h 48 min
What this code does
- One weekday block plus a weekend mock and review add up to 12 hours a week, which most students with classes can keep up for eight weeks.
- The split is a starting point. After the first mock, the percentages change toward the weak areas.
Reviewing the mistakes of a mock teaches more than taking another test. Put the block at a fixed time, in the morning before college or after dinner, so it becomes a habit and not a decision.
Tracking accuracy and time per topic
Accuracy is correct answers divided by questions attempted, written as a percentage. Time per question is minutes spent × 60 divided by questions attempted.
Track both for every topic in a simple sheet: date, topic, attempted, correct, minutes. The block below shows three rows of such a sheet.
Date Topic Attempted Correct Minutes2026-07-06 Python output MCQs 25 21 202026-07-06 OS MCQs 20 12 152026-07-07 Coding: hashing 4 3 100Example 3 · Accuracy and time per topic
from dataclasses import dataclass
@dataclassclass Attempt: topic: str attempted: int correct: int minutes: int
log = [ Attempt("DBMS MCQs", 20, 17, 22), Attempt("Networks MCQs", 15, 9, 24), Attempt("Python output MCQs", 25, 21, 20), Attempt("OS MCQs", 20, 12, 15), Attempt("Coding: hashing", 4, 3, 100),]
for a in log: accuracy = a.correct * 100 // a.attempted seconds_each = a.minutes * 60 // a.attempted flag = " <- weak, relearn" if accuracy < 70 else "" print(f"{a.topic:<18} {accuracy:>3}% {seconds_each:>4} s each{flag}")DBMS MCQs 85% 66 s each Networks MCQs 60% 96 s each <- weak, relearn Python output MCQs 84% 48 s each OS MCQs 60% 45 s each <- weak, relearn Coding: hashing 75% 1500 s each
What this code does
- Networks MCQs are both inaccurate and slow: go back to the method. OS MCQs are fast but only 60% right: speed is not the problem, understanding is.
- For coding, "seconds each" is per problem: 1500 seconds is 25 minutes, about the time a fresher round allows for one problem.
Accuracy shows whether you understand a topic; time shows whether you can do it under test pressure. A topic under about 70% accuracy needs more learning. A topic with good accuracy but slow time needs more timed practice.
Choosing practice resources without overbuying
A practice resource is anything you practise from: this course, a book, a practice website or a mock test series. More resources do not mean more preparation; finishing one well beats starting five.
A lean set for most students has one source per need. Before paying for anything, check whether your placement cell already gives it free.
Use this course for Python, coding, DSA, core CS, resume, HR and GD. For aptitude, reasoning and verbal use one book or one free practice source. For mock tests use college or free mocks first, and at most one paid series. Avoid buying several overlapping courses or question banks.
Adjusting the plan after each mock
A mock test is a practice test in the real format and time. Its main use is to find weak areas, not to give you a score.
After each mock, compare section scores with your target and with the previous mock. The example below moves hours toward the sections furthest below target.
Example 4 · Moving hours after two mocks
sections = ["Section A", "Section B", "Section C", "Technical"]mock1 = [12, 9, 15, 11]mock2 = [14, 10, 16, 15]target = 15extra_hours = 6
gap = [max(0, target - score) for score in mock2]total_gap = sum(gap)for name, before, after, g in zip(sections, mock1, mock2, gap): hours = extra_hours * g // total_gap if total_gap else 0 print(f"{name:<9} {before:>2} -> {after:>2} of 20, gap {g}, extra {hours} h")Section A 12 -> 14 of 20, gap 1, extra 1 h Section B 9 -> 10 of 20, gap 5, extra 5 h Section C 15 -> 16 of 20, gap 0, extra 0 h Technical 11 -> 15 of 20, gap 0, extra 0 h
What this code does
- Technical improved by 4 marks and reached the target, so it moves to maintenance. Section B improved by only 1 and is 5 marks short, so it gets most of the 6 extra hours.
- The hours follow the gap to the target, not your favourite subject. That is how a sectional cut-off stops being a risk.
Then move hours: give the next week's extra time to the sections furthest below target, and keep only short maintenance practice for sections already above it. The plan should change every week; a plan that never changes is not being checked.
Next step
Check your understanding
12 quick questions