GCSE Computer Science revision covers both theory and programming. You need to understand how computers work (hardware, networks, data representation), how to write and trace algorithms, and how to apply computational thinking to solve problems. It's the only GCSE where you need to write actual code in the exam, making it unique among all subjects.
AQA GCSE Computer Science (8525) has two papers. Paper 1 is Computational Thinking and Programming Skills (1 hour 30 minutes, on-screen exam where you write and trace code). Paper 2 is Computing Concepts (1 hour 45 minutes, written exam covering theory). Paper 1 requires you to write Python code, trace algorithms, and debug programs. Paper 2 covers data representation, networks, cybersecurity, and ethical issues.
The biggest challenge in GCSE Computer Science revision is that it combines a theoretical subject (how computers work) with a practical skill (programming). Students who are good at programming sometimes struggle with the binary and networking theory, while students who learn the theory well may struggle to write code under exam conditions. Both skills need regular practice.
- Learn a topic once — don't re-read it endlessly.
- Test yourself on it straight away with quizzes.
- Space it out with flashcards over the following days.
- Practise exam questions against the mark scheme.
Four things that win marks in Computer Science
GCSE Computer Science rewards precise recall and clear application. Re-reading notes barely moves either. These four habits target exactly where Computer Science marks are won and lost.
Write code by hand — every week
Every CS exam — AQA and OCR — asks your child to write, read, or correct code without an IDE, autocomplete, or a red squiggly line to catch mistakes. The exam page is blank paper. If your child only ever codes at a keyboard, they have been practising a different skill entirely. The fix is simple and uncomfortable: ten short programs a week, written on paper. Not typed, not run. Written. A function that takes two numbers and returns the larger one. A while loop that counts down from a number until it reaches zero. A selection statement that categorises a score as pass, merit, or distinction. Then — and this is the part most students skip — they trace their own code by hand, writing out the value of each variable at each step, to check it would actually run correctly. This catches the errors that matter in the exam: off-by-one loop conditions, forgetting to return a value, using = when they mean ==. An IDE hides all of those. Paper does not.
Master the trace table — it is a guaranteed mark source
Trace table questions appear on both AQA Paper 1 and OCR Paper 1, almost every year. They are worth marks that are simply waiting to be collected — if your child knows the technique. Many do not. A trace table is a structured way of tracking what happens inside an algorithm as it runs. Each column is a variable (or an output); each row is one pass through the loop or one step of the algorithm. Your child fills it in by hand, following the code line by line. The algorithms that appear most often are bubble sort (comparing adjacent values, tracking swaps), binary sort (tracking the left pointer, right pointer, and midpoint), and merge sort (tracking how sub-lists are divided and recombined). The reason trace tables lose marks is not that students do not understand the algorithm — it is that they rush, skip rows, or stop halfway through. A complete trace table with one arithmetic error in the middle still earns partial marks. An incomplete one earns nothing. Teach your child to finish it, even if they are not confident, and to label their columns clearly so the examiner can follow their reasoning.
Drill data representation to automaticity
Data representation questions are high-frequency, predictable, and — once practised — among the quickest marks on the paper. They reward students who have done the conversions so many times that the method is automatic under exam pressure. The specific types that appear most often: converting between binary and denary (e.g. 10110101 = 181), binary and hexadecimal (group into nibbles: 1011 0101 = B5), performing binary addition with carry, and identifying overflow. Beyond number bases: ASCII character encoding (knowing that 'A' is 65, that lowercase letters sit above uppercase, and that each character is 7 or 8 bits); image file size calculation (width in pixels × height in pixels × colour depth in bits, then convert to bytes or kilobytes); and sound file size (sample rate in Hz × bit depth × duration in seconds). These are not conceptually hard — they are procedural. The risk is hesitating on the method under exam pressure and making a slip. The fix is repetition: a set of ten conversion drills, three times a week, until the method runs on autopilot. PrepWise has these as timed flashcard sets.
Use technical vocabulary — vagueness costs marks
CS mark schemes are written by people who know exactly what the right answer looks like, and they do not award marks for answers that gesture at the idea without naming the component, process, or relationship correctly. The difference between a zero-mark answer and a full-mark answer is often a single technical term. "The CPU processes data" — zero marks. "The ALU performs arithmetic and logical operations on operands fetched from registers or main memory, using instructions decoded by the control unit" — full marks. "The internet is a network of computers" — zero marks. "The internet is a global network of interconnected networks using TCP/IP protocols to route packets between devices" — full marks. The practical habit to build: after every theory topic, your child should write three model answers, mark-scheme style — one to two sentences, every technical term included. Then read it back. If they can swap out a technical term for a vague substitute without losing meaning, the vague version will cost them a mark. This matters most for the "explain" and "describe" questions on Paper 2: networks, cybersecurity, systems architecture, and ethical/legal issues.
Try it on a real topic
Notes, quizzes and flashcards in one place — free during alpha.
How to revise Computer Science
Consistency beats cramming. A realistic routine — even 20–30 minutes a day — will take you much further than an all-nighter the week before.
Write code by hand every day
Whether your exam is on-screen or on paper, you need to write code without syntax highlighting or error messages. Practise writing short programs on paper: a function that validates an email address, a loop that finds the largest number in a list, a program that reads a CSV file. Then desk-check your code by hand to find bugs.
Master binary and hexadecimal conversions
Data representation questions appear on every GCSE Computer Science paper. Practise converting between binary, denary, and hexadecimal until it's automatic. Also practise binary addition (including overflow), binary shifts, and calculating image file sizes from resolution and colour depth. These are procedural skills — pure practice makes them reliable marks.
Learn algorithms by tracing, not just reading
Don't just memorise what bubble sort does — trace through it with a specific list of numbers, step by step, using a trace table. The exam will ask you to trace an algorithm, show the state of variables at each step, or predict the output. If you've only read about the algorithm, you'll struggle. If you've traced it 10 times, you'll be fine.
Use past paper mark schemes for theory topics
Theory answers in GCSE Computer Science need precise technical language. 'The CPU processes stuff' gets zero marks. 'The ALU (Arithmetic Logic Unit) performs calculations and logical comparisons on data' gets full marks. Mark schemes show you the exact wording examiners expect. Read them before attempting your own answers.
20 minutes a day beats a weekend of cramming
Streaks, XP and a daily plan turn revision into a routine you'll actually keep — the kind that shows up on results day.
Start your streakMistakes to avoid
Most lost revision time comes down to a handful of habits. Steer clear of these and you'll get far more out of every session.
- Writing pseudocode in a real programming language syntax, or writing code when pseudocode is asked for. Read the question: 'Write an algorithm' usually means pseudocode, 'Write a program' means actual code.
- Forgetting to include data types in trace tables — the examiner wants to see whether a variable holds a string, integer, float, or boolean.
- In binary questions, not showing working. Write out the place values (128, 64, 32, 16, 8, 4, 2, 1) every time — it prevents errors and shows method for marks.
- In network questions, confusing protocols with hardware. TCP/IP is a protocol (rules), a router is hardware (physical device). Mixing these up loses marks.
- Writing vague answers about ethical issues — 'it could be bad for privacy' gets nothing. 'Facial recognition systems collect biometric data without consent, which violates GDPR Article 6 and could enable mass surveillance' gets full marks.
Revising by year group
Good revision looks different depending on where you are. Pick your year to see exactly where to start and how to build up from there.
Build the programming foundations that everything else sits on
Most schools introduce CS in Year 9 — or earlier. The concepts that feel abstract now (variables, loops, functions) become the language your child uses to think about algorithms in Year 10 and beyond. Getting solid here means Year 10 is consolidation, not catch-up.
Start with sequence, selection, and iteration — the three building blocks of all programming. If your child can write a working Python or pseudocode program that uses all three (a loop containing an if statement, for example), they have the foundation. If not, that is the first thing to fix.
- 1
Secure the three constructs
Variables and assignment; if/elif/else selection; for loops and while loops. Your child should be able to write each from memory, not copy them from notes.
- 2
Learn to write and call functions
A function with parameters that returns a value. This is tested directly on both AQA and OCR papers and trips up students who have only seen functions demonstrated, not written them independently.
- 3
Introduce basic data structures
One-dimensional arrays (or lists in Python): how to declare them, access an element by index, loop through them. Two-dimensional arrays are Year 10 territory — do not rush there.
- 4
First look at algorithms
Linear search and bubble sort. Not the theory — the code. Your child should be able to write a bubble sort in pseudocode from memory by the end of Year 9. It will reappear constantly.
- 5
Binary and denary conversion
Denary to binary, binary to denary, simple binary addition. Ten minutes of conversion drills a week is enough — do not leave this until Year 11.
Put your plan into practice
Track your topics, build a streak and revise free — free during alpha, no card needed.
Your Computer Science revision journey
The full path from the start of the course to exam day — what to focus on at each stage, and a tip for parents along the way.
Year 10
September — JulyGCSE Computer Science revision starts with getting comfortable with programming. Write code every week — even simple programs. Practise converting between binary, hexadecimal, and denary until it's automatic. Learn the key data representation concepts: binary addition, binary shifts, character encoding (ASCII/Unicode), and image representation (pixels, colour depth, resolution). These are fundamental and come up on every exam. Parents: if your child has a computer at home, encourage them to code outside class. Free platforms like Replit let them practise Python without installing anything.
ParentsAsk your child to explain one CS topic to you each week — in plain English, no jargon. If they can explain what a router does, or why binary is used instead of denary inside a computer, in terms you can follow, they have genuinely understood it. If they retreat to copying sentences from their notes, the understanding is not there yet. You do not need to know whether they are right — just whether they can explain it without the notes.
Year 11 — Autumn term
September — DecemberYear 11 covers networks, cybersecurity, algorithms, and more advanced programming. Start practising tracing algorithms by hand — follow the code line by line, tracking variable values in a trace table. This skill is worth significant marks in the exam. Learn the common sorting algorithms (bubble sort, merge sort, insertion sort) and searching algorithms (linear search, binary search) well enough to trace them, write them, and compare their efficiency.
ParentsOCR families: ask your child when their Component 3 project deadline is and write it in the family calendar now. The project is worth 20 per cent of the final grade and is completed during school time — but it requires your child to manage their own progress across weeks. Schools vary in how closely they monitor this. If your child is on OCR, check in fortnightly: 'What stage is the project at?' is enough. AQA families: no project, but the on-screen programming exam is new — ask the school how they are preparing students for it.
6 months before exams
December — JanuaryAudit your GCSE Computer Science knowledge across both papers. For Paper 1, can you write Python code for: input validation, string manipulation, file handling, arrays/lists, and functions? For Paper 2, can you convert between number bases, explain network protocols, describe cybersecurity threats, and discuss ethical issues? Any gaps here need focused revision. Practise SQL queries — SELECT, FROM, WHERE — as these commonly appear and are free marks if you know the syntax.
ParentsAsk your child to write you a short program — on paper, not at a keyboard — that asks for a number and tells you whether it is odd or even. It does not need to be long: five lines in pseudocode is fine. If they hesitate on the structure, cannot remember how to use a modulo operator, or need to look up the syntax, they need more coding practice before the exam. This is a much earlier warning signal than a mock result.
Mock exams
January — FebruaryYour Computer Science mock will reveal whether you can code under pressure. If you froze on programming questions, you need more practice writing code by hand (or on-screen under timed conditions). If you lost marks on theory, identify which topics — data representation and networks are usually the weakest areas. After mocks, spend time on Boolean logic (AND, OR, NOT truth tables and logic gates) — it's a topic students often skip but it appears on every Paper 2.
ParentsAfter the mocks, look at the mark scheme with your child for any question where they lost more than half the available marks. CS mark schemes are public on the AQA and OCR websites and are written in plain English. For theory questions, the pattern is usually: they knew the general idea but did not use the specific technical term. For algorithm questions, they often stopped their trace table early. Both are fixable with targeted practice — but only if you identify which category the errors fall into.
3 months before exams
March — AprilDo full GCSE Computer Science past papers. For Paper 1, practise writing programs on paper — in the exam you may need to write code without running it, so you need to desk-check your own work. For Paper 2, focus on the topics worth the most marks: data representation (binary, hex, ASCII, image/sound representation), network hardware and protocols, and cybersecurity (types of attack, prevention methods). Make sure you can explain the fetch-decode-execute cycle and the purpose of each CPU component.
ParentsCheck that your child is doing at least one full past paper per week under timed conditions — not reading through it, but writing answers on paper, then marking with the mark scheme. The two CS papers are each one and a half hours. If your child has not sat a full ninety-minute paper in one go before the real exam, the time pressure will feel unfamiliar. We cannot replicate the exam hall at home, but we can get them used to the clock.
Final weeks
May — exam dayFinal GCSE Computer Science revision should cover both theory recall and programming fluency. Test yourself on: binary/hex conversions, truth tables, network topologies, SQL syntax, and common algorithms. For programming, write small programs daily — input validation loops, search functions, file read/write operations. Don't forget ethical and environmental topics — these are often the last questions on Paper 2 and students frequently leave them blank or write vaguely.
ParentsThe most useful thing your child can do in the final two weeks is not to learn new content — it is to read back through their own mark-scheme notes from past papers and remind themselves of the exact phrasing that earns marks. Ask them to pick the five theory topics they feel least confident about and write a single model answer for each, from memory, in five minutes. Then compare to the mark scheme. That gap — between what they wrote and what the mark scheme says — is exactly what costs marks on the day.
PrepWise plots this journey for you — a daily plan that adapts to your year and your weak spots.
A note for parents
GCSE Computer Science is part theory, part practical programming skill. Both need practice. If your child can explain how a network works but can't write a simple Python program, they'll struggle on Paper 1. If they can code but can't do binary conversions, they'll lose marks on Paper 2.
Encourage your child to code outside of class. It doesn't have to be GCSE-related — building a simple game, automating something, or following a tutorial all build the fluency needed for the exam. The key skill is comfort with writing code, not memorising syntax.
Computer Science has a lower pass rate than most GCSEs because it genuinely requires both understanding and skill. Regular practice — even 15 minutes of coding or 10 binary conversion questions — makes a real difference over time.
If your child is doing the AQA on-screen exam, make sure they've practised coding in the actual exam environment. Ask their teacher if they can access practice papers in the same format — coding on paper vs on-screen feels very different.