Cambridge International AS & A Level Computer Science (9618) Past Papers: Grade Thresholds and Examiner Report Notes

This page is a guide to past papers for Cambridge International AS & A Level Computer Science (9618). It covers three series: June 2024, November 2024 and June 2025. The grade thresholds are copied from Cambridge’s grade-threshold documents, and the examiner notes are our own summaries of Cambridge’s Principal Examiner Reports for Teachers. We do not host any papers: every paper, mark scheme and report comes from Cambridge’s own website.

Where to get the official papers

• Cambridge International AS & A Level Computer Science (9618) syllabus page
• 9618 past papers page

Cambridge publishes recent papers, mark schemes, examiner reports and grade thresholds on the syllabus’s past-papers page; older series are available to schools through the School Support Hub.

Use the three documents together. Sit the paper first, under timed conditions. Mark it strictly with the mark scheme, which tells you what earns each mark. Then read the examiner report for that paper, which tells you why answers lost marks. The notes on this page give you the short version of each report.

9618 has four papers. Paper 1 is Theory Fundamentals and Paper 2 is Fundamental Problem-solving and Programming Skills; together they make the AS Level. Paper 3 (Advanced Theory) and Paper 4 (Practical) complete the full A Level. The second digit of a component number is the variant, so Papers 11, 12 and 13 are three versions of Paper 1. The thresholds are given for each set of variants.

All three series on this page were set on the 2024-2025 syllabus; papers from 2021 to 2023 were set on the 2021-2023 syllabus. The current syllabus is the 2026 version, and Cambridge states that its 2027-2029 syllabus has no significant changes which affect teaching. Before you use an older paper, check the syllabus version on the paper’s front cover against the current syllabus.

Series index

Series	Papers (components) examined	Examiner report notes	Grade thresholds
November 2025	Not summarised here	Not summarised here	Official page
June 2025	11-13, 21-23, 31-33, 41-43	Yes	Yes
November 2024	11-13, 21-23, 31-33, 41-43	Yes	Yes
June 2024	11-13, 21-23, 31-33, 41-43	Yes	Yes
November 2023	Not summarised here	Not summarised here	Official page
June 2023	Not summarised here	Not summarised here	Official page
November 2022	Not summarised here	Not summarised here	Official page
June 2022	Not summarised here	Not summarised here	Official page
November 2021	Not summarised here	Not summarised here	Official page
June 2021	Not summarised here	Not summarised here	Official page
November 2020	No 9618 papers (first examined in 2021)	Not summarised here	Not summarised here
June 2020	No 9618 papers; Cambridge cancelled the June 2020 series because of COVID-19	Not summarised here	Not summarised here
November 2019	No 9618 papers (first examined in 2021)	Not summarised here	Not summarised here
June 2019	No 9618 papers (first examined in 2021)	Not summarised here	Not summarised here

9618 was first examined in 2021. Papers from 2019 and 2020 belong to the Computer Science syllabus that 9618 replaced, so they were set on different content; we do not summarise them. Some Cambridge syllabuses also have a March series for candidates in India. If you want March papers, check the official past-papers page; none is summarised here.

What examiners keep saying

These are the errors that come back across the three series summarised here, grouped by syllabus topic.

• Data Representation. Negative numbers cause repeated slips. Keep the minus sign when you convert a two’s complement value to denary, and give binary when the question asks for two’s complement binary. Do binary subtraction in binary, in the right order, not in denary. Keep binary prefixes (kibi, mebi) apart from denary ones (kilo, mega), and convert bits to bytes when a file size needs it. (June 2024, November 2024, June 2025)
• Compression. Lossy and lossless get mixed up. A fact about lossy compression is not a benefit until you say what it does for the user. When the question is about an image or a live stream, apply the method to that context, not to text. (June 2024, November 2024, June 2025)
• Central Processing Unit (CPU) Architecture. Registers hold data; buffers hold data. Neither “sends” anything on its own, and the processor or device does the work. The program counter holds the address of the next instruction, not a count of instructions run. Use register transfer notation when asked, not prose. (June 2024, November 2024, June 2025)
• Assembly Language and Bit manipulation. Keep an immediate value apart from the contents of an address. An arithmetic shift is not a cyclic shift, and a right arithmetic shift copies the sign bit into the gap. (June 2024, November 2024, June 2025)
• Logic Gates and Logic Circuits. Describe a gate’s output for every combination of inputs, and learn the NOR, XOR and NAND symbols so you do not swap them. (June 2024, June 2025)
• Networks including the internet. A device detects a collision and sends the jam signal; CSMA/CD is the method, not the sender. Keep thin and thick clients apart, and explain public and private IP addresses without just repeating those words. Label every device on a topology diagram. (June 2024, November 2024, June 2025)
• Data Security and Data Integrity. A parity bit is set per byte from the count of 1s in that byte. Checksums, check digits and parity checks are different methods. Encryption makes data unreadable; it does not stop access. (June 2024, June 2025)
• Data Definition Language (DDL) and Data Manipulation Language (DML). COUNT and SUM are confused in every series. Add a foreign key with ALTER TABLE, not UPDATE, and include GROUP BY when you aggregate per group. Test a Boolean field against TRUE or FALSE, not a string. Do not write “database” when you mean a table. (June 2024, November 2024, June 2025)
• Programming Basics and Constructs. Use RETURN, not OUTPUT, when a function must hand back a value. Do not use reserved words or built-in function names as identifiers. Join strings with the pseudocode concatenation operator, not +. Read a CASE structure as CASE, not as IF-ELSE, and do not INPUT a value that already arrives as a parameter. (June 2024, November 2024, June 2025)
• Files and File Processing. Filenames cause errors in every series: quote a literal filename, but not a parameter that holds one. Give EOF() its filename, close every file with CLOSEFILE and its filename, and close a file before you reopen it in another mode. Loop until end of file, not a fixed number of times, when the file length is unknown. (June 2024, November 2024, June 2025)
• Program Testing and Maintenance. Classify syntax, logic and run-time errors correctly, and say what a run-time error does to the program. Abnormal test data is not extreme test data. Test data must fit the range the question states. Stub testing is not integration testing. (June 2024, November 2024, June 2025)
• File organisation and access. Serial and sequential files are different, and a serial file stores records in the order they arrive. Hashing is applied to a record’s key field, not to the whole file, and you access a record, not the file. (June 2024, November 2024)
• Translation Software and Protocols. Lexical and syntax analysis are separate stages, and interpretation is not compilation. In BNF, separators go between alternatives only. Packet switching and circuit switching are confused, and HTTP is not a TLS protocol. (November 2024, June 2025)
• Programming Paradigms (object-oriented programming). Instantiate the objects and store them; do not keep the data in plain arrays. Call the parent constructor in a subclass, keep attributes private, and use inheritance only when it is asked for. Use the same name for an attribute, its getter and its setter. (June 2024, November 2024, June 2025)
• Introduction to Abstract Data Types (ADT) and Algorithms. Check whether a queue is empty every time, not only when it is first set up. A linear queue does not wrap round; a circular one must. In a binary search, compare the middle element, not the middle index, and move the bounds past it. Write iteration or recursion as the question requires, and do not let an insertion sort turn into a bubble sort. (June 2024, November 2024, June 2025)

Exam technique the reports repeat:

• Read the whole stem. An example given in the question earns no credit if you repeat it, and details in the stem apply to every part. (June 2024, June 2025)
• Match the command word and apply the scenario. “Explain” needs a reason, not a list of facts. A benefit or drawback must say what it means for the user, never define a term by repeating its name, and tie each point to the context. (June 2024, November 2024, June 2025)
• Make each point different. A point reworded, or its opposite, scores once. Only the first answer in each numbered space is marked. (June 2025)
• Plan on the blank pages. Cross out rough work, never ink over pencil, and draw syntax diagrams in pencil so you can fix them. (June 2024, November 2024, June 2025)
• Write Cambridge pseudocode. Use the syntax in Cambridge’s pseudocode guide and only the functions given in the Insert. Design the algorithm before you code it. (June 2024, June 2025)
• Paper 4 evidence. Paste code as text, keep the Python indentation, show the inputs in test screenshots, use full screenshots and submit partial attempts. (June 2024, November 2024, June 2025)

June 2025

This series tested a wide spread. On the AS theory papers: logic gates, number bases, two’s complement, tracing assembly code, database design with SQL, networks and security, all set in scenarios. Paper 2 asked about identifiers, constants, error types, random numbers, files, sorting, stacks and queues. Paper 3 covered user-defined types, floating point, TCP/IP, switching, Karnaugh maps, scheduling, syntax diagrams, compilation, AI and OOP. Paper 4 built queues, stacks, a hash table, linked lists, a binary tree, insertion sort, binary search and inheritance. Calculations and methods went well. The better scripts used precise terms and applied them to the scenario; weaker ones repeated the question or wrote textbook answers.

Where marks were lost:

• Paper 11: checksums mixed up with check digits and parity, and encryption described as blocking access rather than making data unreadable. SQL tested a Boolean field as if it held text.
• Paper 13: a right arithmetic shift did not copy the sign bit, subtraction was done the wrong way round, and bits were not turned into bytes.
• Paper 21: bubble sorts used one loop, the wrong bounds or no early exit, and a file was not closed before it was reopened to append.
• Paper 22: stub testing was called integration testing, RAND was given two parameters, and averages were declared as INTEGER.
• Paper 32: a negative floating-point value lost its sign, and HTTP was named as a TLS protocol.
• Papers 41 and 43: a circular queue did not wrap round, a linear queue was treated as circular, and tree nodes were compared instead of the data inside them.

Grade thresholds – June 2025

Full A Level, all papers in this series

Option	Components	Max	A*	A	B	C	D	E
AX	11, 21, 31, 41	300	228	195	162	132	102	73
AY	12, 22, 32, 42	300	228	197	166	135	104	73
AZ	13, 23, 33, 43	300	240	211	182	152	122	92

AS Level only

Option	Components	Max	a	b	c	d	e
SX	11, 21	150	99	86	71	56	41
SY	12, 22	150	100	88	72	56	41
SZ	13, 23	150	115	106	90	75	60

Not shown: 9 further route(s) in the official table (staged entries that carry AS marks from an earlier series, or other special routes). See the official document.

Official documents: past papers, mark schemes and examiner report

November 2024

The AS theory papers leaned on two’s complement, BCD, binary prefixes, relational databases with SQL, CPU registers, buffers, operating-system tasks, software licences and compression. Paper 2 set pseudocode with global variables, functions returning records, date functions and files. Paper 3 covered floating point, processor types, switching, hashing, Karnaugh maps, OOP, BNF and binary trees. Paper 4 depended on creating objects and using 2D arrays. The better scripts gave technical detail and turned each feature into a benefit or drawback. Weaker scripts defined a term with its own name, confused database with table or memory with storage, and in Paper 4 kept data in arrays instead of objects.

Where marks were lost:

• Paper 11: the minus sign was dropped when converting two’s complement, binary prefixes were mixed with denary ones, and limitations of file-based systems were repeated rather than solved.
• Paper 12: registers were said to send data, the program counter was treated as a count of instructions run, and EPROM was thought to be write-once.
• Paper 21: global variables were declared again or reset, and two values were returned where one record was needed. Abnormal test data was confused with extreme data.
• Paper 23: SETDATE and DAYINDEX were misused, date function names were used as identifiers, and the linked list’s head pointer was ignored.
• Papers 31 and 33: PRIVATE was read as data privacy, and BNF separators were put at the ends of lists or between items in a sequence.
• Papers 41, 42 and 43: objects were not created or not stored, and 2D arrays were built as 1D or with the dimensions swapped.

Grade thresholds – November 2024

Full A Level, all papers in this series

Option	Components	Max	A*	A	B	C	D	E
AX	11, 21, 31, 41	300	228	193	158	128	99	70
AY	12, 22, 32, 42	300	215	183	151	123	95	67
AZ	13, 23, 33, 43	300	230	194	158	130	102	74

AS Level only

Option	Components	Max	a	b	c	d	e
SX	11, 21	150	92	77	61	46	31
SY	12, 22	150	86	71	56	42	28
SZ	13, 23	150	93	77	63	49	35

Not shown: 12 further route(s) in the official table (staged entries that carry AS marks from an earlier series, or other special routes). See the official document.

Official documents: past papers, mark schemes and examiner report

June 2024

The AS theory papers rewarded applying knowledge to the scenario: embedded systems, buffers, memory types, compression, client-server roles, CSMA/CD, IP addressing, parity, table design and SQL. Paper 2 tested string handling in pseudocode, text files, parameters and error types. Paper 3 covered floating-point conversion, file access methods, Reverse Polish Notation, Karnaugh maps, declarative clauses and AI. Paper 4 was built round sorting, searching, OOP classes, queues and a binary tree. The better scripts used exact terms, linked every point to the context and set out their working clearly. Weaker scripts wrote textbook answers, made a buffer or protocol act on its own, and output values that should have been returned.

Where marks were lost:

• Paper 11: embedded-system answers were generic or only described the device, and SQL used SUM for COUNT or left out GROUP BY.
• Paper 12: a table was changed with UPDATE where ALTER TABLE was needed, binary subtraction was done in denary, and thin and thick clients were confused.
• Paper 13: CSMA/CD was treated as the thing that sends the jam signal, and parity was treated as one bit for all the data regardless of the number of 1s.
• Paper 22: syntax, logic and run-time errors were put in the wrong class, and EOF() was written without its filename.
• Paper 32: direct access to a sequential file was answered as sequential access, with no mention of an index of key fields, and virtual machines were confused with virtual memory. Paper 32, Question 10(b) contained an error, so every candidate was given its marks.
• Papers 41 and 43: a recursive binary search was written when an iterative one was required, and the middle index was compared instead of the middle element.
• Paper 42: inheritance was used where containment was needed, and an array was filled with integers instead of node objects.

Grade thresholds – June 2024

Full A Level, all papers in this series

Option	Components	Max	A*	A	B	C	D	E
AX	11, 21, 31, 41	300	222	191	160	130	100	71
AY	12, 22, 32, 42	300	222	191	160	130	100	71
AZ	13, 23, 33, 43	300	222	191	160	130	100	71

AS Level only

Option	Components	Max	a	b	c	d	e
SX	11, 21	150	94	80	67	54	41
SY	12, 22	150	94	80	67	54	41
SZ	13, 23	150	94	80	67	54	41

Not shown: 6 further route(s) in the official table (staged entries that carry AS marks from an earlier series, or other special routes). See the official document.

Official documents: past papers, mark schemes and examiner report

How to use this page

1. Sit a full paper under timed conditions. Use only the functions listed in the Insert.
2. Mark it strictly with the mark scheme. For Papers 2 and 4, check your pseudocode or code line by line against each marking point, not just whether it would run.
3. Read the notes for that series on this page. Then read the examiner report for your paper number on Cambridge’s site for the detail.
4. List the topics where you lost marks. Tick them off against the 9618 checklist, and use the free AS diagnostic or the free A Level diagnostic to find other weak spots. All our free diagnostics are listed on the diagnostics page.
5. Fix each topic. Work through the 9618 self-check question bank and the notes on the Computer Science subject hub, for example databases practice or processor fundamentals revision notes. Learn what each command word asks for.
6. Re-test on a different series. Sit another paper a week or two later and compare. Use the exam calendar to plan your papers up to the exam, and see grade thresholds for June 2026 thresholds for our flagship syllabuses.
7. Get help if a topic will not stick. Book a free trial lesson.

About these notes

The grade thresholds come from Cambridge’s grade-threshold tables, and the examiner notes are written in our own words from Cambridge’s Principal Examiner Reports for Teachers for June 2024, November 2024 and June 2025. Thresholds change every series, so never use them to predict future ones. If you spot an error, please report a correction.