A CAT study plan from your test date

Twenty-six weeks at 12 hours a week sounds like 312 hours of CAT preparation. Take out two busy weeks and a lighter test week and it is 290, and how those hours divide, by phase and by section, decides more than their number.

This lesson builds the plan backwards from the test day with a planner you can run on your own dates, hours and diagnostic scores, and the planner checks its own plan. The planning rules are MySmartCoPilot’s; where research on studying supports one, the study is named.

Plan backwards from the test day

CAT 2026 is on the last Sunday of November. Count back from it, and a start on the first Monday of June gives 26 weeks, week 1 to the test week. A plan fixes its last weeks first, because they are the ones you cannot move:

• Week 26, the test week, carries half the hours and nothing new.
• Weeks 22 to 25, the final stretch, alternate a practice paper of all three sections with a repair weekrepair week: A week of a study plan with no new topics: its hours go to the causes a practice paper's analysis found, the lessons that fix them and fresh attempts at the questions lost. that works on what the paper’s analysis found.
• Weeks 2 to 5, the foundation, give any section the diagnostic shows weak to the aptitude track’s basics first.
• Weeks 6 to 21, the test level, take this track’s section modules in order, and week 1 is this module.

Walk through the same plan phase by phase:

Fixing the end first stops the commonest failure of a long plan: topics that run on until the last month, leaving no time for papers or for repairs. A later start shortens the foundation and the test level, never the final stretch.

Your hours set the size of the plan; your diagnostic sets the split

Take Riya, whose diagnostic gave VARC 55 %, DILR 30 % and QA 45 %. Each week she keeps 1 hour for re-attempts from her error logerror log: A record of every question answered wrongly or skipped, with its cause, the lesson that fixes it and a later day to re-attempt it. More in “Start with a diagnostic and an error log”, which leaves 11 hours for the sections. The planner shares them in proportion to what each section got wrong, its gap below 100 %: 45, 70 and 55 points, 170 in all. VARC gets 45 ÷ 170 = 26.5 % of the 11 hours, DILR 41.2 % and QA 32.4 %; rounded to half-hours, that is 3, 4.5 and 3.5 hours. A section scored so high that its share would fall below a fifth is raised to a fifth, so no section is ever dropped.

The planner applies those rules week by week, then checks its own plan. Press Edit, put in your own test day, start, hours, diagnostic scores and busy weeks, and run it again:

"""A CAT study plan built backwards from the test day, with MySmartCoPilot's planning rules.

Change the inputs at the top (your test day, start, hours, diagnostic and busy weeks) and run it again.
The program checks its own plan: hours within budget every week, every section every week, a practice
paper or a repair week in every week of the final stretch, and every module of the track placed once.
"""
from datetime import date

TEST_DAY = date(2026, 11, 29)  # CAT 2026; use the date in your own test's notice
START = date(2026, 6, 1)  # the Monday you start
HOURS = 12  # the hours you can really give in a normal week
DIAGNOSTIC = {"VARC": 55, "DILR": 30, "QA": 45}  # per cent right in your diagnostic
BUSY = {9: 4, 10: 4}  # week number: hours, for weeks with less time (exams, a deadline at work)

LOG_HOURS = 1  # every week: re-attempts of the questions in your error log
FLOOR = 0.2  # every section keeps at least a fifth of the section hours
WEAK = 50  # below this diagnostic score a section starts with the aptitude basics
FINAL = 4  # weeks of practice papers and repair before the test week

# The track's modules, in its own order.
MODULES = ["start-here", "varc", "dilr", "quant-arithmetic", "quant-algebra-and-numbers",
           "quant-geometry-and-counting", "test-strategy", "practice-papers", "other-mba-tests",
           "admissions-and-interviews"]
SECTIONS = ["VARC", "DILR", "QA"]


def split(hours):
    """Section hours in half-hours: shares follow each section's gap below 100 %, with a floor."""
    gaps = {s: 100 - DIAGNOSTIC[s] for s in SECTIONS}
    share = {s: g / sum(gaps.values()) for s, g in gaps.items()}
    for s in SECTIONS:  # raise a section to the floor and take the difference from the others
        if share[s] < FLOOR:
            rest = [t for t in SECTIONS if t != s]
            spare = sum(share[t] for t in rest)
            for t in rest:
                share[t] *= (1 - FLOOR) / spare
            share[s] = FLOOR
    units = round((hours - LOG_HOURS) * 2)
    exact = {s: share[s] * units for s in SECTIONS}
    got = {s: int(exact[s]) for s in SECTIONS}
    for s in sorted(SECTIONS, key=lambda s: exact[s] - got[s], reverse=True)[: units - sum(got.values())]:
        got[s] += 1
    return {s: got[s] / 2 for s in SECTIONS}


def span(first, last):
    """Weeks of the plan as the module list prints them; a module whose weeks a late start used up says so."""
    if first > last:
        return "no week left: practise it in the papers"
    return f"week {first}" if first == last else f"weeks {first}-{last}"


def build(start, hours, busy):
    weeks = (TEST_DAY - start).days // 7 + 1
    last_level = weeks - FINAL - 1
    # A late start shortens the foundation and the test level, never the final stretch.
    found = min(max(2, round(weeks * 0.15)), max(0, last_level - 2))
    plan = []
    for w in range(1, weeks + 1):
        h = busy.get(w, hours if w < weeks else hours / 2)
        if w == 1:
            phase, task = "Start here", "pattern, plan, diagnostic"
        elif w <= 1 + found:
            phase, task = "Foundation", "aptitude basics first"
        elif w <= last_level:
            phase, task = "Test level", "section modules"
        elif w < weeks:
            phase = "Final"
            task = "practice paper + analysis" if (w - last_level) % 2 else "repair: top causes"
        else:
            phase, task = "Test week", "rules, re-attempts"
        plan.append({"week": w, "phase": phase, "hours": h, "task": task, **split(h), "log": LOG_HOURS})
    starts = {s: 2 if DIAGNOSTIC[s] >= WEAK else found + 2 for s in SECTIONS}
    q = starts["QA"]
    third = (last_level - q + 1) // 3
    if third:  # QA's three modules one after another
        quant = [span(q, q + third - 1), span(q + third, q + 2 * third - 1), span(q + 2 * third, last_level)]
    else:  # fewer than three weeks of test level: the three modules share them
        quant = [span(q, last_level)] * 3
    placed = {
        "start-here": "week 1",
        "varc": span(starts["VARC"], last_level),
        "dilr": span(starts["DILR"], last_level),
        "quant-arithmetic": quant[0],
        "quant-algebra-and-numbers": quant[1],
        "quant-geometry-and-counting": quant[2],
        "test-strategy": span(max(2, last_level - 3), last_level),
        "practice-papers": span(max(2, last_level + 1), weeks - 1),
        "other-mba-tests": span(max(2, weeks - 3), weeks - 1),
        "admissions-and-interviews": "after the test",
    }
    checks = {
        "hours within budget every week": all(sum(p[s] for s in SECTIONS) + p["log"] <= p["hours"] for p in plan),
        "every section every week": all(min(p[s] for s in SECTIONS) >= 0.5 for p in plan),
        "practice paper or repair in each final week": all(
            "practice paper" in p["task"] or "repair" in p["task"] for p in plan if p["phase"] == "Final"),
        "every module of the track placed once": sorted(placed) == sorted(MODULES),
    }
    return weeks, found, last_level, plan, placed, checks


weeks, found, last_level, plan, placed, checks = build(START, HOURS, BUSY)
print(f"{weeks} week{'' if weeks == 1 else 's'} to test day, {HOURS} hours in a normal week")
print("Diagnostic: " + ", ".join(f"{s} {DIAGNOSTIC[s]} %" for s in SECTIONS))
print()
print("Weeks Phase      Hours  VARC  DILR    QA  Log  For")
rows = []
for p in plan:  # consecutive weeks with the same hours and task share a row
    key = tuple(p[k] for k in ("phase", "hours", "VARC", "DILR", "QA", "log", "task"))
    if rows and rows[-1][0] == key:
        rows[-1][2] = p["week"]
    else:
        rows.append([key, p["week"], p["week"]])
for (phase, h, varc, dilr, qa, log, task), first, last in rows:
    weeks_shown = f"{first}" if first == last else f"{first}-{last}"
    print(f"{weeks_shown:<6}{phase:<11}{h:>5g}{varc:>6g}{dilr:>6g}{qa:>6g}{log:>5g}  {task}")
total = {s: sum(p[s] for p in plan) for s in SECTIONS}
print(f"{'Total':<17}{sum(p['hours'] for p in plan):>5g}" + "".join(f"{total[s]:>6g}" for s in SECTIONS)
      + f"{sum(p['log'] for p in plan):>5g}")
print()
print("Modules of the track, each placed once:")
for m in MODULES:
    print(f"  {m:<29}{placed[m]}")
print()
for name, ok in checks.items():
    print(f"Check: {name}: {'yes' if ok else 'NO'}")
assert all(checks.values())

print()
job = build(date(2026, 7, 13), 9, {8: 4, 9: 4})
w2, f2, l2, p2, _, c2 = job
normal = split(9)
print(f"The same rules for a job: {w2} weeks, 9 hours a week, weeks 8 and 9 at 4")
print("  A normal week: " + ", ".join(f"{s} {normal[s]:g} h" for s in SECTIONS) + f", log {LOG_HOURS} h")
print(f"  Foundation weeks 2-{1 + f2}, test level {2 + f2}-{l2}, final {l2 + 1}-{w2 - 1}, test week {w2}")
print(f"  All four checks pass: {'yes' if all(c2.values()) else 'NO'}")

26 weeks to test day, 12 hours in a normal week
Diagnostic: VARC 55 %, DILR 30 %, QA 45 %

Weeks Phase      Hours  VARC  DILR    QA  Log  For
1     Start here    12     3   4.5   3.5    1  pattern, plan, diagnostic
2-5   Foundation    12     3   4.5   3.5    1  aptitude basics first
6-8   Test level    12     3   4.5   3.5    1  section modules
9-10  Test level     4     1     1     1    1  section modules
11-21 Test level    12     3   4.5   3.5    1  section modules
22    Final         12     3   4.5   3.5    1  practice paper + analysis
23    Final         12     3   4.5   3.5    1  repair: top causes
24    Final         12     3   4.5   3.5    1  practice paper + analysis
25    Final         12     3   4.5   3.5    1  repair: top causes
26    Test week      6   1.5     2   1.5    1  rules, re-attempts
Total              290  72.5 107.5    84   26

Modules of the track, each placed once:
  start-here                   week 1
  varc                         weeks 2-21
  dilr                         weeks 6-21
  quant-arithmetic             weeks 6-10
  quant-algebra-and-numbers    weeks 11-15
  quant-geometry-and-counting  weeks 16-21
  test-strategy                weeks 18-21
  practice-papers              weeks 22-25
  other-mba-tests              weeks 23-25
  admissions-and-interviews    after the test

Check: hours within budget every week: yes
Check: every section every week: yes
Check: practice paper or repair in each final week: yes
Check: every module of the track placed once: yes

The same rules for a job: 20 weeks, 9 hours a week, weeks 8 and 9 at 4
  A normal week: VARC 2 h, DILR 3.5 h, QA 2.5 h, log 1 h
  Foundation weeks 2-4, test level 5-15, final 16-19, test week 20
  All four checks pass: yes

Riya’s plan comes to 290 hours: 72.5 for VARC, 107.5 for DILR, 84 for QA and 26 for the error log. Weeks 9 and 10 are her college exams, set to 4 hours each, and even then every section keeps an hour.

The module list under the table is the plan’s map of this track: VARC from week 2, because her VARC score is above 50 %, and DILR and QA from week 6, after their foundation weeks. The four checks at the end are the planner’s own test, and the program stops with an error if any of them fails.

Every section every week, and each error again after a gap

A plan could also give DILR the whole of September and VARC the whole of October. CAT rules that out on its own terms: one sitting tests all three sections, each with its 40 minutes, so a section left untouched for two months is weaker on the day. Research on studying points the same way. Dunlosky and colleagues rated ten common study techniques and gave practice testing and distributed practicedistributed practice: Practice of the same material spread over several sessions with gaps between them, instead of massed into one sitting., spreading practice over time, their highest rating; interleaved practiceinterleaved practice: Practice that mixes different kinds of problems, or different sections, within one session or week, instead of finishing one kind before starting the next., mixing kinds of problems, got a moderate one. Cepeda and colleagues, pooling 839 assessments from 317 experiments, found that the best gap between study sessions grows with the time you need to remember for. Roediger and Karpicke found that students who took recall tests on prose passages remembered more two days and a week later than students who reread them, although rereading did better after five minutes.

For a CAT plan that comes to three habits: every section in every week, practice by solving questions rather than rereading, and each question you got wrong solved again days later, not the same evening. Here is one way to lay out the 9-hour week the planner gives a working professional, VARC 2, DILR 3.5 and QA 2.5 hours with 1 for the log:

Practice papers and repair weeks come before the test week

A practice paper is only as useful as what follows it. In Riya’s plan, week 22 opens with a paper of all three sections, sat on her own clock with 40 minutes a section and no switching, then analysed question by question into her error log. Week 23 is a repair week: no new topics, only the causes that paper found, the lessons that fix them and fresh attempts at the questions it cost. Weeks 24 and 25 repeat the pair, so the second paper shows whether the repairs worked. The last five weeks of the planner’s table, week by week:

Two more things belong in this stretch. In the 2026–27 cycle NMAT’s testing window opens four weeks before CAT, SNAP’s test days fall two to four weeks after it and XAT comes five weeks after it, so the planner places the other tests’ pattern lessons in weeks 23 to 25, inside the hours already planned. And the test week gets half the hours: the exam-day rules, light re-attempts and sleep, because a lesson learnt in the last three days has no time to be practised again.

Change the plan for a job, college or a break

The phases stay; the inputs change. The last lines of the planner’s output run the same rules for a working professional who starts six weeks later, on the second Monday of July, with 9 hours a week: 20 weeks in all, a foundation in weeks 2 to 4, test level to week 15, the final stretch in weeks 16 to 19 and the test in week 20. Three situations, and what changes in each:

The weekday-and-weekend shape for a job is MySmartCoPilot’s recommendation: short weekday slots keep every section in touch, and the weekend blocks hold the work that needs time, such as a full DILR set or the week’s errors. When weeks are lost, run the planner again from the current week with the weeks that remain; the final stretch keeps its four weeks, and the test level is what gets shorter.

Practise: your own plan

Ten questions, two for each part of the plan: its phases, the split, the weekly habits, the final stretch and the changes for your situation. The session opens on the part you know least and asks again what you miss:

Interview questions

Warm-up: why interleave the sections within a week instead of finishing one section first?

Because CAT tests all three sections in one sitting, each with its own 40 minutes, so a section finished in August and left alone until November is out of practice on the day. Spreading each section across every week keeps all three in use and spaces the practice of each, which Dunlosky and colleagues rate among the most useful study techniques, and mixing sections and question types makes you choose the method each time, as the test does. The habit that goes with it is to solve each question you got wrong again a few days later rather than the same evening. Finishing one section first feels efficient, but it leaves two sections cold for the longest stretch of the plan.

Key takeaways

• Count the weeks back from the test day and fix the end first: a lighter test week, a final stretch of practice papers and repair weeks, then foundation and test-level weeks.
• Keep an hour a week for the error log and share the rest by each section’s gap below 100 %, with at least a fifth for every section: 3, 4.5 and 3.5 hours for Riya’s 55, 30 and 45 %.
• Every section every week, practice by solving rather than rereading, and each error solved again days later.
• A practice paper is followed by a repair week with no new topics, so the next paper shows whether the repairs worked; the other tests’ patterns fit into the same weeks.
• A job, college or a break changes the hours and the busy weeks, not the shape: run the planner again and let the test level, not the final stretch, absorb lost weeks.