Every Computer Science teacher knows this moment.
You hand back the exam papers.
A student looks at their score, looks at you, and says:
“Miss… I swear I knew this.”
And the annoying thing is… they probably did.
They understood the topic.
They answered confidently.
They left the exam hall feeling fine.
Then the mark scheme arrived and quietly removed half their marks.
Computer Science exams are full of tiny traps. Not evil traps. Just small, sneaky ones that catch students who actually know the content.
Here are the most common ones.
Once you see them, you start spotting them everywhere.
Trap 1: The “this is easy” question
Students see a question like:
State one advantage of using a list.
They think, great, free marks.
They write:
“It stores values.”
And move on happily.
Meanwhile the examiner is sitting there thinking:
Yes… but that is not what I asked.
The mark scheme might want something like:
“Stores multiple values under one variable name.”
Same idea. Slightly clearer. Completely different number of marks.
Students rush the easy questions and accidentally make them harder.
Trap 2: The command word nobody noticed
Students often read the topic of the question and completely ignore the command word.
For example:
Explain why encryption is used.
Student answer:
“It protects data.”
That sounds correct.
But “explain” means something very specific in exams. It usually means give a reason.
So a better answer would be something like:
“Encryption protects data by converting it into an unreadable format so only authorised users can access it.”
Same idea, just actually explained.
A surprising number of lost marks come down to one tiny word at the start of the question.
Trap 3: The Python confidence collapse
Students can write code perfectly well in class.
Then the exam starts and suddenly their brain behaves like it has never seen Python before.
Example question:
Count how many times the number 7 appears in a list.
In class the solution might look like this:
count = 0
for num in numbers:
if num == 7:
count = count + 1
In the exam hall, something strange happens and students start writing things like:
loop numbers
count = maybe
print 7
At this point the code is less Python and more emotional expression.
The student knows the logic. The pressure just scrambles it slightly.
Trap 4: The one-word answer that feels brilliant
Computer Science exams like sentences.
Students like short answers.
Example question:
Why is encryption used?
Student answer:
“Security.”
The student feels confident.
The mark scheme does not feel confident.
What the examiner really wants is something like:
“Encryption protects data by converting it into an unreadable form so only authorised users can access it.”
Students often know the idea perfectly. They just write the shortest possible version of it.
Trap 5: The diagram everyone ignores
Exams often include diagrams. Flowcharts. Logic gates. Memory layouts.
Students glance at them and think:
Nice picture.
Then they answer the question without really looking at the diagram at all.
Which is slightly unfortunate because the diagram is usually there to help.
It is a bit like trying to assemble IKEA furniture while refusing to look at the instructions because you “have a feeling you understand the concept”.
Confidence is high. Success rate is low.
Trap 6: The “that’s probably enough” answer
Students often stop writing too early.
Example question:
Give two advantages of cloud storage.
Student writes:
“You can access files anywhere.”
Then stops.
Technically correct.
Unfortunately the question asked for two advantages.
The second one could have been:
Automatic backups
No need for local storage devices
Files can be shared easily
Many marks disappear simply because students stop writing one sentence too soon.
Trap 7: The two-mark time trap
This one happens in almost every exam.
A student gets stuck on a small question.
They stare at it.
Rewrite their answer.
Cross it out.
Rewrite it again.
Seven minutes later they are still on a two-mark question.
Meanwhile a six-mark question later in the paper that they actually know is waiting patiently to be answered.
Exams quietly reward students who keep moving.
If a question refuses to cooperate, it is usually better to leave it and come back later.
The thing teachers eventually realise is that Computer Science exams are not just testing knowledge.
They are testing whether students understand how exams behave.
The students who improve the fastest often do three simple things.
They read the command words carefully.
They explain answers clearly instead of briefly.
They move on quickly if a question starts eating their time.
None of this is dramatic.
But it makes a surprising difference.
This is also why many classrooms have visual reminders of key Computer Science ideas around the room. Algorithms, logic gates, data structures, or common exam mistakes that students see every day.
Over time those ideas become familiar, which helps when students face them again in an exam.
Final thought
Most students do not lose marks because they are not clever.
They lose marks because exams reward careful thinking, slightly longer explanations, and a bit of strategy.
Once students realise that, Computer Science exams suddenly start feeling a lot more manageable.