IB Computer Science Paper 1 is the 90-minute, 40-question multiple-choice paper that every candidate — Standard Level and Higher Level — sits in the same examination hall. It is the part of the assessment most candidates underestimate, because the questions look short. The marking is unforgiving: one mark per item, no partial credit, and the weighting is heavy enough that a slip rate of 25% can quietly pull a 7 down to a 5. This article is a hands-on triage plan for the paper, written for IB candidates who already know the syllabus and need a sharper exam-day decision frame.
What Paper 1 actually tests, beyond the syllabus checklist
The syllabus document lists four topics: Topic 1 (System fundamentals), Topic 2 (Computer organisation), Topic 3 (Networks), and Topic 4 (Computational thinking, problem-solving and programming). On Paper 1, those topics are not sampled equally. Topic 4 dominates, because the assessment objective weighted most heavily is "demonstrate knowledge and understanding of facts, ideas and concepts across the syllabus" combined with "apply this knowledge to solve problems." The 40 items are roughly distributed with about 10–12 items on computational thinking and code reading, 8–10 on system fundamentals and organisation, and the remainder across networks and the SL-only topics.
Three skill layers show up in the question stems, and most candidates only train the first two:
- Recall of a discrete fact — the storage size of a 32-bit integer, the layer of the TCP/IP model that handles routing, the function of a particular CPU register.
- Code reading in an unfamiliar language — short pseudocode or Java-like snippets, often with a deliberate off-by-one, a missing base case, or a swapped comparison operator.
- Applied reasoning across two concepts — for example, choosing a data structure based on a stated constraint, then justifying its time complexity in a follow-up stem.
For most candidates, the third layer is where marks evaporate, because the surface of the question looks like a recall item when the answer is actually a reasoning step. Train for that explicitly.
The 90-minute budget, broken into decision blocks
Forty items in 90 minutes is 2.25 minutes per question on average. Do not, however, treat that as your working pace. The real distribution is bimodal: recall items should take 30–45 seconds, and applied-reasoning items should take up to 3.5 minutes. A flat 2.25-minute target produces a queue of unfinished hard items at minute 80, which is the worst possible state to be in.
Use a three-pass structure. The first pass sweeps through the paper answering any item you can solve in under 60 seconds. The second pass tackles the applied-reasoning items and code-reading items in the order of the syllabus topic you find most comfortable — usually Topic 4 first, because the marks per minute are higher when you are fluent in pseudocode. The third pass returns to any flag you marked and to the SL-only items you might be tempted to skip.
A flag system that survives the clock
Most candidates mark uncertain answers by circling the question number, which is invisible 25 minutes later under stress. Use a hard mark: a small vertical bar in the margin means "I want to come back," a question mark means "I am guessing, do not waste time." At minute 70, only the bars go back into your second pass. The question marks are left as they are, because additional reading time on a stem you did not understand rarely changes the answer.
Four algorithmic thinking traps that quietly cost marks
These are the patterns I see most often when candidates debrief a missed Paper 1. They are not "you did not know the content" failures — they are decision failures on items the candidate actually had the knowledge to solve.
- The swapped comparison operator. A loop condition written as i ≤ n instead of i < n (or vice versa) is the single most common code-reading trap. Practice scanning every loop condition and counting iterations on a one-line scratch tally.
- The recursive call that does not terminate. Items about recursion often show a function missing its base case. The candidate reads the first call and assumes it works, then picks the option that shows the function "running forever" — which is correct, but the stem may ask for the output, in which case the answer is the error, not the value.
- The trace table run backwards. Some items give you the final state of variables and ask what input produced it. Candidates trained only on forward traces freeze. Practise three reverse traces per week in the final month.
- The off-by-one in array indexing. A stem that says "the array has 10 elements" and then references index 10 in the loop is testing whether you noticed the violation, not whether you noticed the array length.
Common pitfalls and how to avoid them
- Pitfall: Reading the stem once and locking in an answer. Fix: Read the stem, cover the options, predict the answer, then reveal. Mismatches between your prediction and the options are where the marks hide.
- Pitfall: Treating "All of the above" and "None of the above" as rare. Fix: On first pass, eliminate options until only one remains. The compound options are a faster path to certainty when you have a strong elimination.
- Pitfall: Running out of time on the final 8 items because hard items blocked the easy ones. Fix: Strict 60-second cap on first pass. If a recall item is not answered in 60 seconds, flag it and move.
- Pitfall: Changing correct answers on review. Fix: Only change an answer on review if you have a concrete reason (you re-read the stem, not because a later question made you doubt).
Code-reading items: a 90-second decision frame
For pseudocode or Java-like items, the question is almost always one of four things: what is the output, what is the value of variable X at line N, how many times does the loop run, or which line contains the error. Decide which of those four the stem is asking before you trace. If you cannot tell, the item is a flag.
A working trace takes longer than candidates expect. For a 10-line snippet, allocate 90 seconds: 20 to read, 50 to trace, 20 to verify against the options. The verification step is non-negotiable. Roughly 20% of missed items are not traced wrongly — the trace is correct and the candidate picks the distractor that matches an intermediate state.
How Paper 1 weighting interacts with your overall grade
Paper 1 is worth 45 raw marks out of the 100 available across the external assessment. The other external marks come from Paper 2 (which has its own case study component) and the Internal Assessment. Because Paper 1 is the only section where every item carries equal weight, it is also the section where consistent execution pays off the most. A candidate who scores 32/40 on Paper 1 has given themselves a 7-grade buffer before Paper 2 even starts.
| Paper 1 score (out of 40) | Buffer it creates for Paper 2 | Tactical implication |
|---|---|---|
| 36–40 | Very large; can absorb Paper 2 misses | Protect with a calm, flag-heavy first pass |
| 30–35 | Healthy; a 7 is still in reach | Push hard on second-pass applied items |
| 24–29 | Thin; Paper 2 must score well | Re-evaluate time budget before IA submission |
| Below 24 | Minimal; grade ceiling is now visible | Focus future revision on Topic 4 weakness |
For most candidates I have worked with, a target of 30+ on Paper 1 is realistic with 6–8 weeks of focused, time-pressured practice. Below 24, the problem is almost always one of two things: insufficient pseudocode fluency, or panic on the code-reading items. Both are fixable with a daily 25-minute drill routine.
Frequently-asked questions outside this article
Students also ask whether guessing is worthwhile on the final five items when time is short. The marking model for Paper 1 does not penalise wrong answers, so yes — a guess is strictly better than a blank. Students also ask whether the same Paper 1 is given to SL and HL candidates. Yes, the paper is shared. The HL candidates then sit Paper 2, which extends the same syllabus into deeper problem-solving territory and carries the case study component.
Another common question is how the Internal Assessment interacts with Paper 1 in the final grade. The IA contributes 30% of the final mark, Paper 1 contributes 30%, and Paper 2 contributes 40%. A weak Paper 1 cannot be rescued by a strong IA, but a strong Paper 1 gives the IA room to be a learning experience rather than a panic project.
Conclusion and next steps
Triage is the skill that separates a 5 from a 7 on IB Computer Science Paper 1. The syllabus content is learnable; the decision frame is what most candidates never practise. Build the 60-second first pass, the 90-second code-reading trace, and the three-pass structure into your next four timed practice papers, and the marks will follow. TestPrep İstanbul's diagnostic assessment is a natural starting point for candidates looking to benchmark their current Paper 1 pacing and flag the algorithmic thinking trap that is costing them the most marks.