A-level Computer Science Revision: Papers and Project

The most effective way to revise A-level computer science is to treat it as three jobs, not one: the two written papers, and the substantial programming project — the Non-Exam Assessment, or NEA — that sits alongside them. Confirm the exam board first, then split your revision cleanly. For the written papers, drill the algorithms, data structures and theory of computation until you can reason about them on paper, in a full programming language, not only at a keyboard. For the project, plan early and document as you build, because the marks come from a clear analysis, design, testing and evaluation, not from a clever program handed in with no working shown. This guide sets out what to revise, in what order, and — just as important — how to judge whether the tutoring help you bring in is genuinely credible or merely confident.

A-level computer science is a step up from GCSE in kind, not just in difficulty. At GCSE the whole grade comes from written papers and students work in a simplified board pseudocode. At A-level they write in a real high-level language, the theory reaches into abstract territory the GCSE never touches, and a large independent project becomes part of the final result. Revision that works for one will leave gaps in the other. The plan below is built backwards from how each of the three components is actually marked.

Know exactly which specification you are sitting

Before any timetable, find out which specification the course follows. The main boards at A-level — AQA, OCR and Eduqas/WJEC, with Cambridge International used by some schools — cover the same core computer science, but they differ in how they word questions, which programming language and reference style they expect, how the papers are split, and how the project is marked. Revising from the wrong board's past papers is one of the quietest ways to waste good effort: the topics look familiar, but the command words, the mark-scheme wording and the emphasis are not the ones you will meet in the exam hall.

So the first job is administrative, not academic: download the correct specification, the past papers, the mark schemes and — for the project — the board's assessment criteria and any exemplar material from the board's own website, before buying a single commercial revision guide. If you are still getting your bearings on how A-levels, papers and coursework fit together, our guide to understanding the UK exam system is a sensible place to start.

Paper one: programming and algorithms, on paper

The first written paper is, broadly, the programming and computational-thinking paper. It rewards a student who can design and follow a method under exam conditions, and it is where keyboard fluency quietly lets people down. A student who has only ever written code in an editor, with autocomplete and instant error messages, can find hand-writing a correct program surprisingly hard when the screen is not catching mistakes for them.

The highest-value revision here is deliberate practice of the exact skills the paper tests. Code-tracing comes first: take a short program and a trace table and work through it line by line, writing down how each variable changes with every pass of a loop. This is where careful students collect marks that stronger-but-hastier ones drop. Then rehearse the standard algorithms every A-level specification names — searches such as linear and binary search, sorts such as bubble, insertion and merge sort, and the graph traversals like breadth-first and depth-first search. You should be able to explain what each does, when it is appropriate, and — this is an A-level demand the GCSE does not make — reason about its efficiency using Big-O notation.

Data structures move from naming to using. Stacks, queues, linked lists, binary trees, hash tables and graphs all need to be understood well enough to trace an operation by hand: pushing and popping a stack, inserting into a tree, following a linked list through its pointers. Practise these on paper in your board's chosen language, and mark your attempts against the official scheme rather than a best guess. The point is not neat handwriting; it is producing correct, readable logic without a machine to lean on.

Paper two: theory that reaches further than GCSE

The second paper covers the concepts-and-theory side, and at A-level it goes somewhere the GCSE never does. Computer architecture is more detailed — the fetch-decode-execute cycle, registers, addressing modes and, at several boards, a simple assembly language. Boolean algebra extends into De Morgan's laws and simplification with Karnaugh maps. Data representation goes deeper into floating-point numbers, normalisation and two's complement. Networking, databases with SQL, and the legal, moral and ethical consequences of computing all carry more weight and expect a structured argument rather than a gut reaction.

The genuinely distinctive A-level topic is the theory of computation. This is the abstract heart of the subject: finite state machines, regular expressions, Backus-Naur Form for defining a language's syntax, Turing machines, and the idea that some problems are not computable at all. These reward precise recall and worked practice far more than reading. Turn each syllabus bullet into a question, close the book, and write the answer or draw the state diagram from memory before checking it. For the longer discussion questions, practise structuring a balanced response — a clear point, a reason and a consequence — because those marks are lost far more often to a thin answer than to a wrong one.

The programming project: the component most students under-plan

The NEA is where A-level computer science truly separates itself from GCSE, and it is the part families most often misjudge. It is a substantial independent programming project — you identify a real problem, design a solution, build it, test it and evaluate it — and it counts for a meaningful share of the final grade. It is marked by the school against the board's criteria and moderated by the board.

The mistake to avoid is treating it as a coding contest. The marks are not for the most ambitious program; they are for the quality of the write-up around it. Analysis has to identify a genuine problem and a real stakeholder, with clear, measurable success criteria. Design has to be detailed enough that someone else could build from it. Testing has to be systematic — normal, boundary and erroneous data, each with its expected and actual result — not a screenshot of the program working once. Evaluation has to judge the finished system honestly against the success criteria set at the start. A modest project, thoroughly documented, routinely out-scores an impressive one handed in as a bare program.

The practical lesson for revision planning is simple: start the project early and document as you go. Reconstructing your analysis and testing evidence weeks later, from memory, is where good projects lose easy marks — and it is time stolen from revising for the written papers in the same term.

Why "credible" should mean more than a confident pitch

At some point many families decide whether to bring in a tutor, and here the real difficulty is not finding someone — it is knowing whether the person is any good. Computer science makes this harder than most subjects. According to the Royal Society, the growth of a demanding computing curriculum in England outpaced the supply of specialist teachers, so a shortage of computing specialists has been a known problem for years. That shortage is exactly why a confident profile tells you so little: plenty of people can talk fluently about programming without being able to teach a specific board's exam technique or guide an NEA to its criteria.

This is the problem Tutorwise is built to solve, and it is worth understanding how. On Tutorwise, a tutor's credibility is not a self-written bio or a star rating that can be nudged up a few reviews at a time. It is a score the platform computes from real, checkable signals across six areas. Trust covers verified identity and an enhanced DBS check. Credentials cover the qualifications and subject knowledge behind the teaching. Delivery and Impact reflect a genuine record of sessions given and outcomes reached, rather than a claim about them. Network reflects how connected and reviewed a tutor is across the platform, and Digital reflects a complete, transparent profile.

The part that matters most for a parent is the gate in front of all of it: a tutor earns no score, and appears in no ranking, until their identity is verified and their onboarding is complete. You are never trusting an unchecked stranger's own description of themselves — you start from proof, an earned and transparent score you can see, rather than a pitch. From there, the sensible final step is one you control: ask a specification-specific question in a first session — "how would you scope an OCR NEA for a mid-ability student?", "how do you teach Big-O for the common sorts?", "how much theory of computation does AQA expect in the exam?" — and judge the answer yourself. If you want the fuller version of what each check means, our explainer on choosing an A-level computer science tutor walks through it, and many families prefer the flexibility of an A-level computer science online tutor who can screen-share code and project work as they teach.

A revision plan built around all three components

Good revision for this subject is shaped by how it is assessed, so build the plan backwards from the two papers and the project — and give the project its own protected time rather than letting it collide with exam preparation in the final term.

Start earlier than feels necessary. The theory builds on itself and leans on precise recall, so it responds far better to short, spaced sessions returned to over weeks than to a late burst of cramming. Beginning sooner also means shaky topics — a half-understood hash table, a fuzzy grasp of Big-O — surface while there is still time to fix them. If you find planning hard, our guide to building a revision timetable that works sets out a method you can adapt.

Separate recall from understanding. A student who nods along to an explanation of a Turing machine has not yet proven they can produce one. Close the book, write the definition or draw the diagram, then check — that act of retrieval is what makes knowledge stick under exam conditions. And because A-level computer science leans on discrete maths, students who also study A-level maths often find the two reinforce each other, especially on logic, sequences and reasoning about efficiency.

Move to full past papers early, and mark them against the official scheme rather than a parent's best guess. The scheme shows you the precise wording that earns marks and the exact places they are lost, which turns each paper into a targeted to-do list rather than a score to worry about. Save timed, whole-paper practice for the final stretch, once the content is genuinely known, so the last weeks rehearse exam technique instead of meeting topics for the first time. Handled this way, revision stops being an anxious slog and becomes a series of specific, winnable jobs — and a strong, well-prepared result becomes a realistic outcome rather than a hopeful one.

Frequently asked questions

When should A-level computer science revision start? Sooner than most families expect, and the programming project is the reason. The written-paper content builds on itself and rewards precise recall, so it responds best to short, spaced sessions across the year rather than a rush at the end. But the NEA also needs protected time, and if it drifts into the final term it eats into exam revision. Starting early on both means weak topics surface while there is still time, leaving the final weeks free for timed, whole-paper practice.

How is A-level computer science different from GCSE? In three ways that change how you revise. Students write in a full high-level language rather than a simplified board pseudocode; the theory reaches into abstract topics the GCSE never covers, such as Big-O complexity, finite state machines and the theory of computation; and a substantial independent programming project becomes part of the final grade. Revision that worked at GCSE will leave real gaps at A-level.

Does the programming project really matter that much? Yes — it counts for a meaningful share of the grade, and it is marked on the quality of the analysis, design, testing and evaluation, not on how impressive the program looks. A modest, thoroughly documented project routinely out-scores an ambitious one handed in as a bare program. Plan it early, document as you build, and treat the write-up as the assessed work it is.

Do the exam boards really change how we revise? Yes. AQA, OCR and Eduqas/WJEC teach the same core computer science but differ in their reference language, command words, mark-scheme wording, paper structure and project criteria. Revising from the correct board's specification and past papers is far more efficient than working from a generic guide. Confirm the board before buying any resource.

How do I choose a computer science tutor I can trust? Judge evidence, not presentation. Check the tutor knows your exact board and can guide the NEA to its criteria, and look for verified credibility rather than a well-written pitch. On Tutorwise, tutors are scored on checked credentials, verified identity and DBS, and a real record of teaching — and none of them ranks until they are verified — so you begin from proof rather than a claim. Then use your own specification-specific question in a first session to confirm the fit. Our guides to A-level computer science tuition and exam preparation for the written papers go further on both.

Ready to find a tutor whose credibility you can actually check? Browse verified A-level computer science tutors on Tutorwise and start from proof, not a pitch.