Time management in online tests

Managing time in an online test means deciding before the test how long each question may take, then keeping to it with the countdown on the screen. Divide a section’s seconds by its questions to get the average time per question, and set a cut-off at about twice that. Work in two passes. In the first, mark for review any question that looks long, finish the rest, and leave any question that is still unfinished at the cut-off. In the second, go back to the marked questions with the time left, the one with the least work left first. Write three checkpoints on your rough sheet, such as “past question 12 with 7:30 left”, so that the countdown tells you early when you fall behind. And learn the screen beforehand: which button saves an answer, what each palette state means, and whether a section has its own timer.

This lesson works out the time budgets of seven published patterns, gives you a planner to run with your own numbers, replays one section with and without two passes, and goes through the screen as the National Testing Agency’s procedure describes it.

Turn the pattern into a budget

A time budget starts from three published numbers: how many questions a part has, how many minutes it gets, and whether those minutes belong to that part alone. The average is the part’s seconds divided by its questions. The cut-off, twice the average, is the point at which a question you have not finished has already cost the time of two. The program below works out both for parts of four tests, from AMCAT’s syllabus page, eLitmus’s page for test takers, the Staff Selection Commission’s notice for CGL 2026 and the GATE 2027 brochure:

"""Seconds per question, and a skip cut-off at twice that, from patterns that the test providers publish."""

# (test, part, questions, minutes), as the provider's own page or notice gives them
PATTERNS = [
    ("AMCAT", "English", 18, 18),
    ("AMCAT", "Quantitative Ability (Tech)", 16, 20),
    ("AMCAT", "Logical Ability", 12, 15),
    ("eLitmus pH Test", "the whole test", 60, 120),
    ("SSC CGL Tier-I", "each subject", 25, 15),
    ("SSC CGL Tier-I", "each subject, with a scribe", 25, 20),
    ("GATE", "the whole paper", 65, 180),
]

for test, part, questions, minutes in PATTERNS:
    seconds = minutes * 60 / questions
    print(f"{test}, {part}: {questions} questions in {minutes} minutes")
    print(f"  {seconds:.0f} s a question; cut-off {2 * seconds:.0f} s")

print("GATE has 100 marks in 180 minutes:", 180 / 100, "minutes a mark")

AMCAT, English: 18 questions in 18 minutes
  60 s a question; cut-off 120 s
AMCAT, Quantitative Ability (Tech): 16 questions in 20 minutes
  75 s a question; cut-off 150 s
AMCAT, Logical Ability: 12 questions in 15 minutes
  75 s a question; cut-off 150 s
eLitmus pH Test, the whole test: 60 questions in 120 minutes
  120 s a question; cut-off 240 s
SSC CGL Tier-I, each subject: 25 questions in 15 minutes
  36 s a question; cut-off 72 s
SSC CGL Tier-I, each subject, with a scribe: 25 questions in 20 minutes
  48 s a question; cut-off 96 s
GATE, the whole paper: 65 questions in 180 minutes
  166 s a question; cut-off 332 s
GATE has 100 marks in 180 minutes: 1.8 minutes a mark

The averages differ more than fourfold, and each one asks for a different plan:

• SSC CGL Tier-I has four subjects of 25 questions, each on its own 15-minute timer, so a question gets 36 seconds, and every wrong answer costs 0.5 of the 2 marks a right one earns. Candidates eligible for a scribe get 20 minutes a subject (1 hour 20 minutes in place of 1 hour), which makes the average 48 seconds; if that is you, plan and practise with 48.
• AMCAT gives each module its own questions and minutes: 60 seconds a question in English and 75 in Quantitative Ability (Tech) and Logical Ability. Its FAQ says the test is adaptive, a right answer bringing a harder next question and a wrong one an easier one, and that there is no negative marking. Plan an adaptive module as if there were no coming back to a question: at the cut-off, choose your likeliest option and move on, since a blank earns nothing and a wrong answer costs nothing.
• eLitmus designs its pH Test for two hours, usually three sections of 20 questions, so 120 seconds a question on average. eLitmus writes that it moved away from a time-challenged test to a “content challenged” one, and that its negative marking depends on how many questions you attempt (more about the pH Test). There the cost of a wrong answer, not of a slow one, drives the plan.
• GATE mixes 1- and 2-mark questions in one paper of 65 questions and 100 marks, so budget per mark: 1.8 minutes a mark, about 3.6 minutes for a 2-mark question.

Some providers do not publish these numbers at all: the NQT’s page describes what each area tests, and says there is no negative marking, but gives no question counts or minutes. Then do the division on the instructions screen. In the procedure of the National Testing Agency (NTA), for one, the detailed instructions appear after you log in and before the questions do, and GATE lets candidates log in and read the instructions 20 minutes before the start.

Section timers and one clock

Whether the minutes belong to one section decides what a saved minute is worth. SSC CGL Tier-I runs each subject on its own timer, and CAT gives exactly 40 minutes to each of its three sections and does not let candidates switch from one section to another while answering (CAT 2026 press release). With a section timer, a minute saved in reasoning cannot be spent on quantitative aptitude. Spend it in the section that saved it, on the marked questions and on checking answers. Each section then needs its own plan and its own checkpoints, and finishing a strong section early gains nothing: use its full time.

With one clock for the whole paper, as in GATE’s three hours, time moves freely between parts. That is a strength and a risk, because a hard General Aptitude question can eat into the subject questions and no screen warns you. Give each part its share of the clock yourself, such as about 27 minutes for General Aptitude’s 15 marks at 1.8 minutes a mark, and check it as if it were a section timer.

Checkpoints you can read off the countdown

A cut-off protects you from one slow question; checkpoints protect you from a slow section. A computer-based test shows the time remaining, and NTA’s procedure puts the countdown at the top right of the screen and ends the test by itself when it reaches zero. So write the checkpoints as time left, on your rough sheet, before the first question. Change the three numbers at the top of this planner to your own pattern and run it:

"""A time plan for one timed section. Change the three numbers below to your own test's pattern and run it again."""
QUESTIONS = 25   # questions in the section
MINUTES = 15     # the section's own time limit
CUTOFF = 2       # mark a question for review once it has taken this many times the average

total = MINUTES * 60
average = total / QUESTIONS
print(f"{QUESTIONS} questions in {MINUTES} minutes: {average:.0f} s a question on average")
print(f"Cut-off: mark a question for review after {CUTOFF * average:.0f} s")
print("Checkpoints at the average pace (the screen counts down):")
for quarter in (1, 2, 3):
    left = total - total * quarter // 4
    past = QUESTIONS * quarter // 4
    print(f"  with {left // 60:2d}:{left % 60:02d} left, be past question {past}")
print(f"  with  0:00 left, all {QUESTIONS} questions seen")

25 questions in 15 minutes: 36 s a question on average
Cut-off: mark a question for review after 72 s
Checkpoints at the average pace (the screen counts down):
  with 11:15 left, be past question 6
  with  7:30 left, be past question 12
  with  3:45 left, be past question 18
  with  0:00 left, all 25 questions seen

Being ahead of a checkpoint is normal in the first pass, because you skip what looks long. Being behind means that slow questions are taking the time of quick ones; until you catch up, mark at sight anything that looks long. If the last checkpoint comes and some questions are still unseen, see them before you start the second pass: an unseen question is as likely to be quick as any other, and it may cost you 20 seconds rather than 2 minutes.

Two passes with a skip cut-off

The two-pass method spends the section’s time on its quick questions first. In the first pass, read each question. If it looks long, such as a data set with five parts or a word problem of six lines, mark it for review at once. Work on the rest, and if one is still unfinished at the cut-off, mark it too and move on, leaving your rough work on the sheet. In the second pass, go back to the marked questions with the time that is left, the one with the least work left first.

Here is one section replayed three ways. The candidate is invented and slower than the section’s pace: their 25 questions need 1,150 seconds in all, 250 more than the timer gives. Four questions are slow, and three of those four look long at first reading; question 4 looks short and is not.

question,topic,needs,looks_long,right
1,percentages,25,no,yes
2,ratio,30,no,yes
3,averages,35,no,yes
4,profit and loss,120,no,yes
5,simple interest,25,no,yes
6,time and work,45,no,yes
7,speed and distance,40,no,no
8,number system,20,no,yes
9,mensuration,95,yes,yes
10,algebra,35,no,yes
11,geometry,50,no,yes
12,data interpretation,140,yes,yes
13,percentages,30,no,yes
14,mixtures,40,no,yes
15,trigonometry,105,yes,no
16,ratio,25,no,yes
17,averages,30,no,yes
18,number system,35,no,yes
19,profit and loss,45,no,yes
20,time and work,30,no,yes
21,algebra,40,no,no
22,geometry,30,no,yes
23,statistics,25,no,yes
24,speed and distance,35,no,yes
25,simplification,20,no,yes

"""One timed section replayed three ways: in order, and in two passes with a skip cut-off.

section.csv is an invented candidate's attempt at 25 questions in 15 minutes, with +2 marks for a right answer and
-0.5 for a wrong one. For each question it gives the seconds this candidate needs to finish it, whether it looks long
at first reading, and whether their answer is right once they finish it.
"""
import csv

LIMIT = 15 * 60      # the section's own timer, in seconds
CUTOFF = 72          # twice the average of 36 seconds a question
GLANCE = 10          # seconds to read a question that looks long, and mark it
RIGHT, WRONG = 2, -0.5

with open("section.csv", newline="") as f:
    QUESTIONS = [
        {
            "n": int(row["question"]),
            "needs": int(row["needs"]),
            "looks_long": row["looks_long"] == "yes",
            "right": row["right"] == "yes",
        }
        for row in csv.DictReader(f)
    ]


def in_order(questions):
    """Every question in turn until the clock runs out: the rest stay blank."""
    clock, done = 0, []
    for q in questions:
        if clock + q["needs"] > LIMIT:
            break
        clock += q["needs"]
        done.append(q["n"])
    return done


def two_passes(questions, at_sight):
    """Pass 1: finish what fits within the cut-off and mark the rest (a question that looks long is marked at
    sight when at_sight is True). Pass 2: the marked questions, least work left first; the rough work of pass 1
    stays on the sheet, so a marked question needs only the rest of its time."""
    clock, done, marked = 0, [], []
    for q in questions:
        spend = GLANCE if at_sight and q["looks_long"] else min(q["needs"], CUTOFF)
        if clock + spend > LIMIT:
            return done
        clock += spend
        if spend == q["needs"]:
            done.append(q["n"])
        else:
            marked.append((q["needs"] - spend, q["n"]))
    for rest, n in sorted(marked):
        if clock + rest > LIMIT:
            break
        clock += rest
        done.append(n)
    return done


def report(name, done):
    right = sum(q["right"] for q in QUESTIONS if q["n"] in done)
    wrong = len(done) - right
    blank = [q["n"] for q in QUESTIONS if q["n"] not in done]
    print(name)
    print(f"  {len(done)} answered ({right} right, {wrong} wrong): {right * RIGHT + wrong * WRONG} marks")
    print(f"  blank: {', '.join(map(str, blank))}")


print(f"{len(QUESTIONS)} questions in {LIMIT // 60} minutes; this candidate needs {sum(q['needs'] for q in QUESTIONS)} s for all")
report("In order, no skipping", in_order(QUESTIONS))
report(f"Two passes, cut-off {CUTOFF} s", two_passes(QUESTIONS, at_sight=False))
report("Two passes, long-looking ones marked at sight", two_passes(QUESTIONS, at_sight=True))

25 questions in 15 minutes; this candidate needs 1150 s for all
In order, no skipping
  17 answered (15 right, 2 wrong): 29.0 marks
  blank: 18, 19, 20, 21, 22, 23, 24, 25
Two passes, cut-off 72 s
  18 answered (16 right, 2 wrong): 31.0 marks
  blank: 4, 9, 12, 15, 23, 24, 25
Two passes, long-looking ones marked at sight
  22 answered (20 right, 2 wrong): 39.0 marks
  blank: 9, 12, 15

• In order, the candidate is on question 18 when the clock runs out, so questions 18 to 25 stay blank, and six of those eight need only 20 to 35 seconds each. The four slow questions were paid for with the last eight, most of them quick.
• A cut-off alone helps little here. Each of the four slow questions takes the full 72 seconds before it is marked, 288 seconds in all, so the first pass runs out of time at question 23 and no second pass happens. The gain is one question and 2 marks.
• Marking long-looking questions at sight costs 10 seconds each. The first pass ends with 108 seconds to spare; question 4, which looked short, is stopped at the cut-off and finished in the second pass with 48 more seconds. The candidate answers 22 questions for 39 marks, 10 more than in order. The 60 seconds left are too few for any of the three long questions.

The cut-off still earns its place, as the brake on a question that looks short and is not. It is a ceiling, though, not a target: on a 36-second section, every question abandoned at the cut-off has cost the time of two others. The replay is one invented attempt, and your own gain depends on how many long questions you can spot. To replay yours, time each question of a practice section with a stopwatch’s lap button, write the times into section.csv and run it again.

The last minute of a section is a separate decision. Under negative marking, a guess on a blank question pays only when your chance of being right is above the penalty divided by the sum of the reward and the penalty: 0.5 ÷ 2.5 = 20 % for SSC’s +2 and −0.5. The negative-marking lesson works this out for each scheme.

Know the screen before the test

Many Indian computer-based tests use a screen like the one NTA describes in its procedure for appearing in a CBT (Appendix VII of its UGC-NET bulletin), and the habits that lose marks are the same on all of them:

• The palette has five states. Each question is shown as not visited, not answered (opened and left), answered, marked for review without an answer, or answered and marked for review.
• Only the buttons save. Going to another question by its number in the palette does not save the answer to the question on screen. Save & Next saves it and opens the next question; Clear Response removes an answer.
• An answered question counts even when it is marked; a mark without an answer does not. So when the first pass leaves you with a likely option on a question you mark, decide whether to keep it as an answer: with no negative marking, always; under negative marking, only when it clears the break-even chance.
• The keyboard is switched off. Numbers are entered on an on-screen keypad with the mouse, as are GATE’s numerical answers, so practise typing a decimal answer that way.
• Use only the calculator the test provides. GATE gives an on-screen virtual scientific calculator and bans every other; where a test’s instructions mention none, practise without one.
• Rough work goes on the sheets or the scribble pad that the centre gives you, and you hand it back at the end.
• At zero the test ends by itself, with whatever is saved.

Practise on the screen itself before the day. NTA’s test practice centre runs mock tests of the CBT screen, CAT puts a mock exam on its website, and GATE links mock examinations and its calculator from its own. MySmartCoPilot’s simulator has the same palette, buttons and countdown:

Practice timers and extra time

A time limit is part of the test, but in practice it should help you learn. WCAG 2.2, the standard for accessible web content, requires that a person can turn a time limit off, adjust it to at least ten times its default or extend it before it runs out, unless the limit is essential, among other exceptions (Success Criterion 2.2.1). Practise the same way: untimed first, to fix the method, then at the time your test will give you. If you are eligible for compensatory time, as SSC’s notice gives at 20 minutes per hour of the examination to candidates eligible for a scribe, practise at your own allowance, because your checkpoints differ. MySmartCoPilot’s CBT simulator takes any time from 1 to 240 minutes before you start.

Exercise: two passes in code

def two_passes(needs, limit, cutoff):
    """The questions answered, in the order they are answered, by the two-pass method with a skip cut-off."""
    # Replace this line with your code.
    return None

from passes import two_passes


def test_all_quick():
    """every question fits the cut-off and the time: answered in order"""
    assert two_passes([10, 20, 30], 100, 60) == [1, 2, 3]
    assert two_passes([], 100, 60) == []


def test_mark_and_return():
    """a question over the cut-off is marked after cutoff seconds and finished in pass 2 if the rest fits"""
    assert two_passes([30, 100, 40, 50], 230, 60) == [1, 3, 4, 2]
    assert two_passes([30, 100, 40, 50], 200, 60) == [1, 3, 4]


def test_exactly_at_the_cutoff():
    """a question that needs exactly the cut-off is finished in pass 1"""
    assert two_passes([60, 61], 200, 60) == [1, 2]
    assert two_passes([60, 61], 120, 60) == [1]


def test_time_runs_out_in_pass_one():
    """pass 1 stops at the first question whose next step no longer fits, and there is no pass 2"""
    assert two_passes([50, 50, 50], 120, 60) == [1, 2]
    assert two_passes([30, 100], 80, 60) == [1]
    assert two_passes([40, 40], 80, 60) == [1, 2]


def test_least_work_left_first():
    """pass 2 takes the marked question with the least work left first, then the lower number on a tie"""
    assert two_passes([100, 90, 10], 300, 60) == [3, 2, 1]
    assert two_passes([80, 80], 300, 60) == [1, 2]
    assert two_passes([100, 90, 10], 160, 60) == [3, 2]

Interview questions

How do you set a time budget for one section of an online aptitude test? (warm-up)

Start from the section’s published pattern: its questions, its minutes, and whether it has its own timer. The average is the seconds divided by the questions, so 25 questions in 15 minutes get 36 seconds each. Set a cut-off at about twice the average, 72 seconds here, after which an unfinished question is marked for review and left for the second pass. Then write three checkpoints as time left on the countdown: past question 6 with 11:15 left, 12 with 7:30 and 18 with 3:45. A section with its own timer is planned on its own, because its spare minutes cannot move to another section; with one clock for the whole paper, give each part a share yourself. On a paper that mixes 1- and 2-mark questions, budget per mark.

What do the states of a CBT question palette mean, and which answers count? (warm-up)

On screens that follow NTA’s CBT procedure, the palette shows five states: not visited, not answered (opened and left), answered, marked for review without an answer, and answered and marked for review. An answered question is evaluated whether or not it is also marked; a question marked without an answer is not. Only the buttons save: choosing an option and then clicking another number in the palette leaves that answer unsaved, while Save & Next saves it. Clear Response removes an answer. Screens of other providers differ in their details, so read the instructions screen and sit the provider’s own mock test before the day.

Key takeaways

• Budget from the published pattern: seconds divided by questions, a cut-off at about twice that, and per mark when questions carry different marks. The seven patterns range from 36 seconds a question (an SSC CGL Tier-I subject) to 166 (GATE).
• A section timer keeps saved minutes inside its section; one clock for a paper lets time move, so give each part its own share.
• Write three checkpoints as time left on the countdown before you start, and mark more readily when you fall behind.
• Work in two passes: mark long-looking questions at sight, stop the rest at the cut-off, and finish the marked ones least work first. In the replay that was 22 answers and 39 marks against 17 and 29 in order.
• On the screen, only the buttons save, a mark without an answer does not count, and the test ends by itself at zero. Practise on the provider’s own mock first.