A 40-minute plan for each CAT section

A CAT section gives you exactly 40 minutes and then closes for good: a QA question that holds you for 9 minutes leaves 31 for every other question, and no later section can give those minutes back. A section plansection plan: A time budget for one section, set in advance from practice data: a scan, a first pass, a second pass and a check. decides, before the clock starts, how the 40 minutes will be spent.

The plan in this lesson has four phases: a short scan, a first pass, a second pass and a check. You will build it with a program you can change, set the minute at which to leave a question from your own practice log, and scale the whole plan for the 53 minutes 20 seconds a section that PwBD candidates have. A plan is a budget you set in advance and carry into practice on your own clock, not a race against one.

Plan each 40-minute section in four phases

Kavya, an invented candidate, sits a QA practice section in printed order. Question 4 looks short and takes her 7 minutes, and when the 40 minutes run out five questions are still unseen, two of which would have taken her a minute each. No single question went badly. The order did: the section’s minutes went to questions in the order they were printed, not in the order they pay.

CAT’s rules make the section the unit of any plan. The CAT 2026 press release gives each section exactly 40 minutes and does not let candidates switch to another section while answering the questions of one, and the FAQs fix the order of the sections, the same for everyone. So CAT has no plan for 120 minutes, only three plans of 40 minutes, one for each section.

The plan this track uses has four phases. It is a MySmartCoPilot recommendation; the IIMs prescribe no plan:

1. Scan. Read the opening of every question and mark each one on the scribble pad as sure, maybe or leave. Solve nothing.
2. First pass. Answer the sure questions in the order they come.
3. Second pass. Work on the maybe questions, best first, and leave each one at its cut-off.
4. Check. Keep the last minutes for the answers most likely to hold a slip: typed answers first, then the choices you marked as close calls.

Walk through Kavya’s plan for her next practice section, one phase at a time:

The order is the point of the plan. The first pass banks the marks that are nearly certain before anything can go wrong, the second pass spends what is left on questions that may or may not pay, and the check is planned in, because a section has no later in which to do it. Only the scan changes from section to section:

The DILR scan is the set scan of the lesson on choosing DILR sets, which ranks the sets before any of them is started; the rest of the plan is the same in all three sections.

Checkpoints you read off the section clock

In the middle of a section there is no time to add minutes up. The CAT 2026 FAQs say that the timer on the screen shows the time remaining in the current section, so write the plan as the readings at which you change phase. In Kavya’s plan the first pass starts at 38:00, the second pass at 26:00 and the check at 4:00. Note the three readings at the top of the scribble pad’s first page before the first question; rough work belongs on the pad, and these are rough work.

The program below builds a plan from five numbers: the section’s minutes, the scan, the check, and what the scan found, the sure and the maybe questions, each with your median minutes from practice papers. It prints every phase with the clock readings at which it starts and ends:

"""A time plan for one CAT section: a scan, a first pass, a second pass and a check.

The CAT screen's timer shows the time left in the section you are in, so every checkpoint is
printed as that reading. Put your own numbers under "Your section" and run it again.
"""
from fractions import Fraction

# Your section
SECTION = Fraction(40)       # minutes: CAT 2026 gives each section exactly 40
SCAN = Fraction(2)           # look at every question once and mark it; solve nothing
CHECK = Fraction(4)          # kept back to check typed answers and marked choices
SURE = (8, Fraction(3, 2))   # questions the scan marks "sure", and your median minutes for one
MAYBE = (6, Fraction(3))     # questions it marks "maybe", and your median minutes for one
# Every other question is marked "leave": it gets minutes only if the plan has some to spare.

PWBD = Fraction(160, 120)    # PwBD time: 20 extra minutes an hour, 160 minutes in place of 120


def clock(minutes):
    """Minutes as the section timer shows them, mm:ss."""
    seconds = minutes * 60
    assert seconds.denominator == 1, "a plan in whole seconds"
    return f"{int(seconds) // 60}:{int(seconds) % 60:02d}"


def plan(section, scan, check, sure, maybe):
    """Print the plan and return its four phases as (name, minutes)."""
    first = sure[0] * sure[1]
    second = section - scan - first - check
    if second < 0:
        raise ValueError("the sure questions alone do not fit: lower the count or the minutes")
    fit = min(maybe[0], int(second // maybe[1]))
    spare = second - fit * maybe[1]
    phases = [
        ("scan", scan, "mark every question sure, maybe or leave"),
        ("first pass", first, f"{sure[0]} sure questions, {clock(sure[1])} each"),
        ("second pass", second, f"{fit} of {maybe[0]} maybe questions, {clock(maybe[1])} each; {clock(spare)} to spare"),
        ("check", check, "typed answers first, then marked choices"),
    ]
    print(f"A plan for a {clock(section)} section")
    print("  phase         minutes  clock shows       what it holds")
    left = section
    for name, minutes, holds in phases:
        print(f"  {name:<12} {clock(minutes):>7}  {clock(left):>5} to {clock(left - minutes):<5}   {holds}")
        left -= minutes
    assert left == 0, "the phases fill the section exactly"
    print(f"  Checkpoints: first pass from {clock(section - scan)}, second pass from {clock(section - scan - first)},"
          f" check from {clock(check)}")
    return phases


phases = plan(SECTION, SCAN, CHECK, SURE, MAYBE)
print()
scaled = plan(SECTION * PWBD, SCAN * PWBD, CHECK * PWBD, (SURE[0], SURE[1] * PWBD), (MAYBE[0], MAYBE[1] * PWBD))
assert all(b[1] == a[1] * PWBD for a, b in zip(phases, scaled)), "every phase scales by the same factor"
print(f"  Every phase of the PwBD plan is {PWBD.numerator}/{PWBD.denominator} of the 40-minute one.")

A plan for a 40:00 section
  phase         minutes  clock shows       what it holds
  scan            2:00  40:00 to 38:00   mark every question sure, maybe or leave
  first pass     12:00  38:00 to 26:00   8 sure questions, 1:30 each
  second pass    22:00  26:00 to 4:00    6 of 6 maybe questions, 3:00 each; 4:00 to spare
  check           4:00   4:00 to 0:00    typed answers first, then marked choices
  Checkpoints: first pass from 38:00, second pass from 26:00, check from 4:00

A plan for a 53:20 section
  phase         minutes  clock shows       what it holds
  scan            2:40  53:20 to 50:40   mark every question sure, maybe or leave
  first pass     16:00  50:40 to 34:40   8 sure questions, 2:00 each
  second pass    29:20  34:40 to 5:20    6 of 6 maybe questions, 4:00 each; 5:20 to spare
  check           5:20   5:20 to 0:00    typed answers first, then marked choices
  Checkpoints: first pass from 50:40, second pass from 34:40, check from 5:20
  Every phase of the PwBD plan is 4/3 of the 40-minute one.

The first plan is Kavya’s. Eight sure questions at 1:30 take 12 minutes, so the second pass gets 22, of which her six maybe questions at 3:00 need 18. The 4 minutes to spare are not idle. A median is the middle of her practice times, so half her questions run longer than it; the spare minutes absorb those overruns first, and whatever is still spare when the maybe questions are done goes to the most promising leave question. The second plan belongs to the last section of this lesson.

A checkpoint is a switch, not a target. At 26:00 the second pass starts even if a sure question is still open: that question has outrun its plan, so it joins the maybe list. At 4:00 the check starts whatever is unfinished, because a mistyped answer can be caught only before the section closes.

Leave a question at the minute your own practice gives

Every plan needs a rule for the question that will not finish. Kavya kept a log of 30 maybe questions from four practice sections in which she stayed with every question until she answered it or 8 minutes had passed: the minutes each one took and how it ended, right, wrong, or left blank at 8 minutes. For each possible cut-off, the program asks what those 30 questions would have earned had she left every one of them at that minute, keeping only the answers she had given by then:

"""When to leave a question: the cut-off that earns the most marks a minute, from your own practice log.

Each row of LOG is one "maybe" MCQ from practice sections sat without a cut-off: the minutes it took
and how it ended, R (right), W (wrong) or L (left blank when you gave up, at 8 minutes here). For
every cut-off the program asks: had you left each question at that minute, keeping only the answers
given by then, how many marks would these questions have earned for each minute they took?
Put your own rows in LOG and run it again.
"""
from fractions import Fraction
from statistics import median

RIGHT, WRONG = 3, -1  # CAT 2026 marks for an MCQ (a blank scores 0)

LOG = [
    ("1.4", "R"), ("1.6", "R"), ("1.8", "R"), ("1.9", "R"), ("2.0", "R"), ("2.2", "W"),
    ("2.3", "R"), ("2.4", "R"), ("2.5", "R"), ("2.6", "R"), ("2.7", "R"), ("2.8", "R"),
    ("2.9", "R"), ("3.1", "W"), ("3.3", "R"), ("3.5", "R"), ("3.6", "R"), ("3.8", "W"),
    ("3.9", "R"), ("4.0", "R"), ("4.5", "W"), ("5.0", "R"), ("5.6", "W"), ("6.2", "W"),
    ("6.9", "R"), ("7.5", "W"), ("8.0", "L"), ("8.0", "L"), ("8.0", "L"), ("8.0", "L"),
]
rows = [(Fraction(t), outcome) for t, outcome in LOG]


def with_cutoff(c):
    """Marks and minutes of the logged questions had each been left at c minutes."""
    marks = sum(RIGHT if o == "R" else WRONG for t, o in rows if o != "L" and t <= c)
    minutes = sum(min(t, c) for t, _ in rows)
    return marks, minutes


print(f"{len(rows)} maybe questions: {sum(o == 'R' for _, o in rows)} right, "
      f"{sum(o == 'W' for _, o in rows)} wrong, {sum(o == 'L' for _, o in rows)} left")
print("cut-off  marks  minutes  marks a minute")
best = None
for c in range(1, 9):
    marks, minutes = with_cutoff(c)
    rate = marks / minutes
    print(f"{c:>4} min {marks:>6} {float(minutes):>8.1f} {float(rate):>10.2f}")
    if best is None or rate > best[1]:
        best = (c, rate)
c, rate = best
print(f"Best cut-off: {c} minutes, {float(rate):.2f} marks a minute")

# Why it is the best: what one more minute earns on the questions still open at the cut-off
open_rows = [(t, o) for t, o in rows if t > c]
gained = sum(RIGHT if o == "R" else WRONG for t, o in open_rows if o != "L" and t <= c + 1)
spent = sum(min(t, c + 1) - c for t, _ in open_rows)
print(f"Minute {c} to {c + 1}: {len(open_rows)} questions still open, {gained} marks for "
      f"{float(spent):.1f} minutes, {float(gained / spent):.2f} a minute")

answered = [t for t, o in rows if o != "L"]
rule = 2 * median(answered)
marks, minutes = with_cutoff(rule)
print(f"Twice the median answer time, {float(rule):.1f} minutes, would earn {float(marks / minutes):.2f} a minute")

30 maybe questions: 19 right, 7 wrong, 4 left
cut-off  marks  minutes  marks a minute
   1 min      0     30.0       0.00
   2 min     15     58.7       0.26
   3 min     35     80.1       0.44
   4 min     48     94.3       0.51
   5 min     50    103.8       0.48
   6 min     49    111.4       0.44
   7 min     51    117.5       0.43
   8 min     50    122.0       0.41
Best cut-off: 4 minutes, 0.51 marks a minute
Minute 4 to 5: 10 questions still open, 2 marks for 9.5 minutes, 0.21 a minute
Twice the median answer time, 6.0 minutes, would earn 0.44 a minute

With a 4-minute cut-off the 30 questions earn 48 marks in 94.3 minutes, 0.51 marks a minute. Staying with every question until 8 minutes earns 50 marks, but in 122 minutes, 0.41 a minute. The two extra marks cost 27.7 minutes, and at her rate of 0.51 those minutes would have earned about 14 marks on maybe questions she never reached.

The line under the table shows why 4 minutes wins. Ten questions were still open at minute 4, and the minute after it earned 2 marks for 9.5 minutes of work, 0.21 a minute, under half of what a fresh maybe question earns. That is the cut-offcut-off (for a question): The minute, set from your own practice log for one kind of question, after which one more minute on an open question earns fewer marks than a fresh question would, so you leave it there.: the minute after which one more minute on an open question earns less than a fresh question would. A rule of thumb would have missed it: a cut-off at twice her median answer time, 6 minutes, earns 0.44 a minute.

Three notes keep the rule honest. A cut-off belongs to one kind of question, so sure and maybe QA questions, VARC passages and DILR sets each get their own, from their own rows; for a set it is the leave point of the DILR lesson. The log needs enough rows to mean something, about 30 of a kind, because with fewer one lucky answer moves the table, and it is worth redoing as your speed changes. And leaving does not have to mean a blank: if the options you have ruled out leave you a chance above 25 %, the break-even accuracybreak-even accuracy: The chance of being right at which answering a question has the same expected marks as skipping it: the penalty divided by the sum of the marks for a right answer and the penalty. More in “Negative marking in CAT and other MBA tests” of a CAT MCQ, mark your best option before you move on, and a typed answer, which costs nothing when wrong, can take your best estimate.

PwBD time: the same plan, a third longer

The CAT 2026 FAQs give PwBDPwBD: Person with Benchmark Disability: under the Rights of Persons with Disabilities Act, 2016, a person with not less than 40 % of a specified disability, as assessed by the certifying authority. More in “CAT eligibility, registration and scorecards” candidates 20 extra minutes for every hour of the test, with or without a scribe: 40 minutes for the 120-minute test, shared equally by the three sections. Each section therefore lasts 53 minutes 20 seconds, which is 40 × 4/3. Every section is a third longer, and so is every phase of its plan.

The second half of the program’s output is Kavya’s plan with every number multiplied by 4/3:

Scaling is the right start, but the minutes per question should come from your own practice at your own allowance. A candidate who works with a scribe may find that some kinds of question take more than a third longer and others less. Sit practice sections at 53:20, log your minutes as Kavya did, and put them into SURE and MAYBE in place of the scaled ones; the cut-off comes from the same log.

Practise: plan a section

Ten untimed questions on the four phases, the checkpoints, the cut-off and PwBD time. They start where your answers so far are weakest, and a question you miss returns once at the end:

Interview questions

Warm-up: why does each CAT section need a time plan of its own?

Because CAT gives each section exactly 40 minutes and does not let you switch sections while one is open, so no section can lend minutes to another, and a plan for the whole 120 minutes, such as more time for QA, has nothing to act on. Each section needs its own budget, set before it starts: a scan that marks every question sure, maybe or leave, a first pass on the sure questions, a second pass on the maybe ones with a cut-off for each, and a few minutes kept back to check typed answers. The checkpoints are written as readings of the section timer, which shows the time left in the current section. For PwBD candidates the same plan applies with every phase a third longer, since each section lasts 53 minutes 20 seconds.

Key takeaways

• CAT 2026 gives each section exactly 40 minutes with no switching, so each section gets its own plan: a scan, a first pass on sure questions, a second pass on maybe ones and a check.
• Write the plan as readings of the section timer, which shows the time left, and change phase at each reading whether or not the current question is finished: 38:00, 26:00 and 4:00 in Kavya’s plan.
• Set each kind of question’s cut-off from your own log, at the minute after which one more minute earns less than a fresh question: 4 minutes and 0.51 marks a minute in Kavya’s log.
• PwBD candidates have 53 minutes 20 seconds a section, so every phase is a third longer, with the minutes per question measured at that allowance.