A-level Computer Science Exam Preparation: How to Revise the Papers and the Project

The most reliable way to prepare for an A-level computer science exam is to prepare for three things at once, not one. There are two written papers, and there is a programming project that counts towards the grade. Confirm your exam board and download its specification. Then split revision between the theory papers and the non-exam assessment — the NEA. At A-level, unlike GCSE, the project a student builds is worth real marks, so it cannot be left to the end. Drill the algorithms, data structures and computational-thinking questions until you can write them by hand. Rehearse on real past papers, marked against the official scheme. Treat the NEA as a term-long piece of work, not a weekend job. This guide sets out what to revise, in what order, how the boards differ, and how to judge whether the tutoring help you bring in is credible or merely confident.

Confirm the board first — the papers are not the same

Before any revision timetable, pin down the exact qualification, because "A-level computer science" is not a single exam. The main English boards are AQA and OCR, with Eduqas offering a further route, and the version a student sits changes what they should revise.

Start with the board. AQA runs its A-level Computer Science and OCR runs its own. The underlying computing overlaps heavily. But the split of topics between papers, the reference language used for algorithms, and the style of the questions all shift between them. According to AQA's published A-level Computer Science specification (7517), the two written papers are worth 40 per cent each and the non-exam assessment the remaining 20 per cent. OCR's own A-level divides its marks the same way, across two written papers and a project. Revising OCR's paper structure for an AQA exam wastes effort at the margin, and at A-level the margin is wide. Find the board on a past mock or a school letter, download that exact specification, and revise from it.

Next, understand how the two papers divide the subject. On both main boards, one paper leans towards computer systems: the CPU, memory and storage, networking, databases, and the legal, moral and ethical issues around computing. The other leans towards algorithms and programming, including computational thinking and the theory of computation. AQA sets its first paper as an on-screen exam, where students write, test and refine real code at a computer. That is a genuine difference from GCSE, and from OCR's fully written papers. Knowing which topics sit in which paper lets a student revise in the order the exams demand, rather than the order a textbook happens to print.

Then settle the programming language. Boards let schools choose the language, and a student should revise in the one their school teaches, because the code they read and write will be expected to match it. At A-level this matters even more than at GCSE, because the NEA is a substantial program the student designs and builds themselves in that language.

The NEA counts — treat the project as assessed work, not a formality

Here is the biggest structural difference between A-level and GCSE computer science, and the one families most often underestimate. At GCSE the practical programming project does not count towards the grade. At A-level it does. The non-exam assessment — a program the student analyses, designs, builds, tests and evaluates — carries a fifth of the whole A-level, and it is marked on the written report as much as on the code that runs.

Two things follow. First, the NEA rewards a genuine, well-scoped problem and a clear development story: analysis, justified design decisions, iterative testing with evidence, and an honest evaluation against the original objectives. A working program with a thin write-up loses marks that a slightly less ambitious program with a thorough, well-evidenced report keeps. Second, it cannot be rushed at the end. The strongest projects are built across the earlier part of the course with regular supervision, so the documentation grows alongside the code rather than being reconstructed from memory the night before the deadline. A tutor or teacher who understands the mark scheme is worth most here, because the marks live in the report structure as much as in the software.

Revise the theory papers as an ordered checklist

The written papers reward breadth and precise terminology, and the topics recur in predictable forms, so revise them against the specification rather than hoping a general read-through covers everything.

Data representation and data structures are reliable earners. Number bases and binary arithmetic, two's complement, floating-point representation, character sets, and how images and sound are stored all appear, and they are practised skills rather than facts to memorise. Beyond that, A-level goes well past GCSE into abstract data structures — stacks, queues, linked lists, trees, graphs and hash tables — where the exam asks a student to describe them, trace operations on them, and explain when each is the right choice.

Computer systems questions — the CPU and the fetch-decode-execute cycle, pipelining, memory and storage, Boolean algebra and logic gates, and assembly language with its addressing modes — reward clear definitions stated in the board's own language. Networking, databases and SQL, and the legal, moral, ethical and cultural issues around computing round out the systems side, and the essay-style issues questions reward concrete examples and a structured argument rather than vague generalisation.

The most efficient way to revise theory is active recall against the specification: take each named topic, close the book, write out everything you can, then check the gaps against the exact wording of the spec. Re-reading notes feels productive and rarely is; retrieving from memory is what fixes knowledge in place.

Drill algorithms and complexity until they are automatic

Algorithms sit at the heart of the programming paper and deserve their own revision block. Searching algorithms — linear and binary search — and sorting algorithms — bubble, insertion, merge and quick sort — are examined as theory, as trace questions on a given data set, and as "complete the code" questions. A-level then adds graph and tree traversal, breadth-first and depth-first search, and Dijkstra's shortest-path algorithm, along with the idea of computational complexity, where a student is expected to reason about how an algorithm's running time grows using Big-O notation.

The reliable method is to learn each algorithm three ways. Describe it in plain English. Trace it step by step through a small example on paper. And write it in the board's pseudocode or reference language. A student who can only recite a memorised definition falls down the moment the paper gives a specific input and asks for the state after a particular pass. Grouping past-paper questions by type, and drilling one type at a time, builds a fluency that mixed papers never quite deliver.

Rehearse timing on real past papers

Timing is a rehearsal that only comes from sitting complete papers to the clock. A-level papers mix short recall questions with extended-response questions and longer programming problems, and students strong on theory often run short on the programming answers, which take longer to write carefully. Sit a full paper, then mark it honestly against the official scheme; that surfaces two things a revision guide cannot — which topics are genuinely secure, and whether the student is fast enough to finish.

The extended-response and essay questions reward structure as much as knowledge. On the ethical and legal topics especially, a student who knows the material but writes a disorganised answer loses marks against a levels-based scheme that rewards a clear, logically ordered argument using correct terminology. Planning the points to hit, in order, before writing is itself a revision task worth practising.

A final-months plan that works

In the last stretch, stop trying to cover everything and revise from evidence instead. Sit one past paper, mark it against the scheme, and let the wrong answers write the revision list. Spend the next sessions on those specific gaps — a floating-point conversion that keeps dropping marks, a graph algorithm that will not quite stick, a complexity comparison answered loosely — then sit another paper and repeat. Keep the NEA moving in parallel, because a finished, well-documented project protects a fifth of the grade before the written papers even begin. This tight loop of past paper, honest marking and targeted repair does more in the final weeks than any amount of fresh reading, because it fixes the things the exam will actually punish.

When a tutor is worth it — and how to judge one

If a student needs support beyond school and self-study, a good tutor compresses this whole process: they know the board, they can supervise the NEA against the mark scheme, and they can explain the algorithms, data structures and complexity that a textbook leaves flat. The hard part is not finding a computer science tutor. It is knowing whether a particular one is safe, qualified and genuinely good before you commit a whole A-level year to them.

This is where most tutoring directories leave you guessing. You read a paragraph the tutor wrote about themselves and a star rating resting on a handful of reviews, then decide who guides a student through some of the most important exams they will sit. The bio is marketing and the rating is thin; you are trusting a claim.

Tutorwise is built to remove that guesswork. Credibility on the platform is not asserted, it is computed. Every tutor carries a credibility score assembled from real, checkable signals — how they deliver lessons and the outcomes they produce, their qualifications and subject background, their standing in the network, and the trust signals a family cares about most. A DBS check, a verified identity and completed onboarding feed that trust signal directly, and the model is weighted so that what genuinely protects and helps a student counts for the most. Two things follow from that design. First, a tutor cannot simply write a glowing self-description and appear trustworthy, because the platform will not produce a credibility score at all until identity is verified or onboarding is complete — there is a hard gate before any number exists. Second, verification is rewarded as points a tutor earns, with a completed DBS check the single largest trust signal. So when you compare two A-level computer science tutors on Tutorwise, you are comparing earned, checkable scores rather than two paragraphs of self-description. That is the difference between choosing on evidence and choosing on hope.

Use it deliberately. Before booking, check the tutor is DBS-checked and identity-verified, read the reviews behind the score, and confirm their exam-board experience, their programming language and their track record supervising the NEA match what the student needs.

FAQ

When should A-level computer science revision start? Structured revision usually works best from the start of the second year, resting on steady practice through the whole course. The habit that matters most is regular coding, code-tracing and algorithm work rather than a single block of reading before the exam, because programming skills are built by doing and fade quickly if left. Crucially, the NEA should be well underway long before then, because it is assessed work that cannot be produced well at the last minute.

How is A-level computer science different from GCSE? It goes deeper and it changes what counts. The theory reaches into object-oriented and functional programming, abstract data structures, computational complexity and the theory of computation, and the programming is more demanding. The biggest change is the non-exam assessment: at GCSE the practical project does not count towards the grade, while at A-level it carries a fifth of it, so the project has to be treated as serious assessed work built across the year.

Does the exam board change how my child should revise? It does. AQA and OCR divide topics between their papers differently and use different reference languages for algorithms, and AQA sets one paper as an on-screen programming exam while OCR's are fully written. Revision should use that board's own specification and past papers, because the real gains come from practising the exact version of each topic the paper will ask.

How much programming should revision involve, not just theory? A lot. Programming is examined directly in the papers and, on AQA, on-screen, and it is the whole basis of the NEA. A student who revises only the theory and stops writing code will lose marks on the programming questions and struggle with the project. Regular, small coding sessions — reading, correcting and writing code by hand as well as at a keyboard — should run right through the revision period.

Do I need a specialist computer science tutor, or will a general one do? For A-level, subject-specific experience matters. The tutor should know your exam board, be fluent in your school's programming language, and understand how the NEA is marked, because supervising the project well is a distinct skill from teaching the theory. On Tutorwise you can check a tutor's subject background and verification before booking rather than taking a self-written bio on trust.

Preparing with the right support

Good A-level computer science exam preparation is disciplined, evidence-led work — the right board, both papers revised against the specification, algorithms and data structures drilled until automatic, and the NEA built and documented across the year rather than crammed. If you want a tutor to run that process, Tutorwise lets you judge candidates on evidence rather than a self-written paragraph: browse A-level computer science tutors, compare their credibility scores and verification, and confirm they know your exam board, your programming language and the NEA before you book. You can also read our companion guide to what A-level computer science tuition covers, see how the foundations are built in our GCSE computer science exam preparation guide, and, if a second subject needs the same rigour, our A-level maths exam preparation guide.