A pupil-friendly guide to the 80-mark question paper: what is assessed, how the paper is structured, how marks are actually awarded, and real candidate answers showing exactly where marks are won and lost.
What the question paper is
The question paper is worth 80 marks out of the 160 marks available for the whole course — exactly half.
You sit it under closed-book exam conditions in one sitting, in May, at the end of the course.
Everyone attempts Section 1 (SDD and Computer Systems), then answers Section 2 questions for either DDD or WDD.
Paper structure
The question paper tests knowledge and skills from across the course through short-answer, structured and extended-response questions. Some questions ask you to state or explain a concept; others ask you to complete or design part of a solution — a data-flow table, an algorithm, a query, an HTML element — using a notation of your choice.
Standard algorithms, data structures, parameter passing, data-flow design, file handling, and tracing/explaining code — usually the larger share of Section 1.
Data representation, computer architecture, the fetch-execute cycle, performance factors, and the impact and legislation topics.
Query design tables, SQL statements (joins, aggregate functions, GROUP BY, sorting), and data dictionary or ER diagram questions.
HTML elements, CSS rules, and JavaScript functions and event handlers, usually built around editing or extending a given page.
How marks work
Question paper marking instructions break most multi-mark questions into explicit bullet points — one idea, one mark. You don't need to hit every bullet with a perfectly polished answer; you need to show each idea clearly enough that a marker can tick it off. The flip side is equally true: a confident, fluent-looking answer that skips one bullet point still loses that mark, however good the rest of it is.
| Command | What markers are looking for | Weak answer pattern |
|---|---|---|
| State | A short, correct fact — no working or justification needed. | An answer that drifts into explaining "why" when only "what" was asked for. |
| Complete | Fill in exactly what's missing, consistent with the parts of the table, diagram or code already given. | Repeating or restating data that's already provided elsewhere in the question, rather than the specific missing piece. |
| Design | Use a recognised design technique (pseudocode, a flowchart, or the SQA Reference Language) that covers every step precisely, in the right order. | Skipping the initial/setup step, or leaving a condition or comparison implied rather than written out. |
| Define / Declare | The exact construct asked for — a record structure, an array, a variable — with a correct name, fields and data types. | Declaring the right idea without a data type, or naming a field differently from how it's used later. |
| Write | Working code or SQL that does exactly what's described — every clause included, not just the core idea. | SQL that gets the calculation right but drops a clause such as FROM or GROUP BY. |
| Explain | Describe what specific lines do using the actual values at that point — a trace, not a summary. | Explaining what the code does in general, without ever referencing the iteration or values the question asked about. |
Marked examples from Understanding Standards
The cards below compare real candidate responses to the same question from the 2019 Higher question paper. None of these candidates is "the good one" — the same candidate scores full marks on one question and zero on the next. That's the real lesson: marks are awarded question by question, bullet point by bullet point, not on how strong an answer looks overall.
mid(month,1,3) & mid(year,3,1)
1 mark — the first substring is correct (characters 1–3 of month give "Apr"), but the second substring operation is incorrect: mid(year,3,1) only takes one character starting at position 3 ("1"), not the two characters needed for "19".
shortDate = month[0:3] + year[2:4]
2 marks — full marks. The indexes on both substrings are consistent: month[0:3] gives "Apr" and year[2:4] gives "19", matching Python's zero-indexed slicing exactly.
Step 2: "The processor activates the read line on the control bus." Step 3: "Instruction is sent to memory location using the data bus and then saved in the instruction register."
1 mark — step 2 correctly names the control bus. Step 3 has the data moving the wrong way: an instruction travels from memory to the processor along the data bus, not out to memory.
Step 2: "Read line is activated thereby transferring instructions to Memory Data Register." Step 3: "Instructions get passed to instruction register from Memory Data register."
0 marks — step 2 never names the control bus or unit responsible for activating the read line, and step 3 never mentions the data bus at all — it only describes movement inside the processor.
Both responses below scored full marks — they're shown side by side not as right-vs-wrong, but as two completely different, equally valid ways to answer the same question.
Structure SampleData Dim Speed As Real Dim accelerator As Integer Dim brake As Integer Dim seatbelt As Boolean End Structure
Dim Cars(200) As SampleData
Full marks — a named record structure with all four fields, then an array declared using that exact record name as its data type.
RECORD event IS { REAL speed; INTEGER accelerator; INTEGER brake; BOOLEAN seatbeltOn; }
DECLARE readings AS ARRAY OF event INITIALLY []
Full marks — the same pattern in the SQA Reference Language: a named record with four fields, then an array of that record type.
1. Set Max to first value in Cars.speed array 2. Initialise loop counter to 199 3. Compare Max with Cars(counter).Speed 4. Set Max to Cars(counter).Speed if Max is less 5. Return value after loop of 2–4 is finished
4/4 — the maximum starts at an appropriate value (the first element), the loop traverses the whole array, and the comparison and reassignment are both present, even though step 4 folds the If condition and the reassignment into a single line.
maxSpeed = -1 for index in range(200): if readings[index].speed > maxSpeed: maxSpeed = readings[index].speed
4/4 — the same four ideas expressed as working Python. Marking instructions credit the concept, not a specific language, so a correct program earns exactly the same marks as a correct pseudocode design.
"Fundraisers must be able to see their total donations." "Animal Help must be able to see the funds for each fundraiser."
0/2 — both requirements restate the end-user needs already given in the question stem, not the underlying query the database has to run.
"Calculate a query to show the sum of all the donations of a certain fundraiser (by sponsor)." "Show a query of all funds raised for a certain charity (Animal Help)."
2/2 — both requirements identify the actual underlying query, not just the end-user need behind it.
"Must be able to sum all donations from a specific person." "Must be able to sum all donation values in the database."
2/2 — awarded for identifying the functions the database needs to perform, inferred from the question stem rather than copied from it.
SELECT fundraiserID, AVG(amount) AS [Average donation (£)] WHERE fundraiser.fundraiserID = donation.fundraiserID
1/3 — fundraiserID is selected and AVG is applied to the correct field, and the alias is correct, but there's no FROM clause naming the tables, so the second mark isn't awarded.
SELECT fundraiserID, (SUM(amount)/COUNT(fundraiserID)) AS [Average donation (£)] FROM Donation, fundraiser WHERE Donation.fundraiserID = fundraiser.fundraiserID
2/3 — SUM divided by COUNT is an accepted alternative to AVG, and the alias and FROM with the correct tables are both present. The third mark needs GROUP BY, which isn't included.
SELECT fundraiserID, SUM(amount)/COUNT(amount) AS [Average donation(£)] FROM Fundraiser, Donation WHERE Fundraiser.fundraiserID = Donation.fundraiserID GROUP BY fundraiserID ORDER BY fundraiserID ASC
3/3 — full marks, despite joining two tables when the query could have run from Donation alone. A working, correctly structured query is credited even when it isn't the most efficient route to the answer.
Step 2 — IN: hotelname[], stars[], price[] OUT: position[]
0/2 — hotelname[] isn't needed to find the position of the cheapest 5-star hotel, so it shouldn't be in the IN data flow, and position should be a single value, not an array — position[] incorrectly annotates it as one.
Step 2 — IN: hotelname[], stars[], price[] OUT: position
1/2 — the OUT data flow (position, without array brackets) is now correct, earning that mark, but IN still carries the same unneeded hotelname[], so the IN mark isn't awarded.
position = 0 price = 5000000 loop for the length of stars[] if stars[index] equals to 5 then if price[index] < price set price to price[index] set position to index end if end if return position
4/5 — both If conditions are correct, price is reassigned correctly within the If, and position is correctly assigned within the If. All of that is credited even though the comparison and the reassignment share one line, after an earlier attempt was crossed out.
Flowchart: initialise position as 0, initialise min as price(0) → loop counter 1 to length → is stars(counter) = 5? → is price(counter) < min? → set min as price(counter), set position as counter.
4/5 — the same four ideas as Response 1, this time as a flowchart, reassigning "min" instead of "price". Different notation, identical mark.
Declare names AS Array*200 Initially Declare rank As Array*200 Initially Declare scores Array*200 Initially
1/2 — three arrays have been declared, after several crossed-out attempts, but none states a data type, so only the first mark is awarded.
name = [""] * 200 category = [""] * 200 score = [0] * 200
2/2 — three arrays, and each one's data type is implied correctly by its initial value: empty strings for the text fields, zero for the numeric score.
target = input(...) NumFound = 0 for score in scores: if category[score] == "Junior" AND scores[score] >= target: NumFound = NumFound + 1 print(...)
5/5 — NumFound is both initialised and incremented, the loop traverses the array, both conditions (category AND score) are present, and the output is concatenated correctly.
score = InputBox(...) FOR index 0 TO 199 DO IF performance(index) >= score THEN qualifiers = qualifiers + 1 END IF END FOR msgbox(...)
4/5 — qualifiers is initialised and the loop is correct, but only the score condition is tested — there's no check that the competitor is actually a Junior, so one condition mark is lost.
min = int(input(...)) count = 0 for i in range(200): if score[i] >= min: count += 1 print(...)
4/5 — the same gap as Response 2: only the score condition is tested, with no category check, so one condition mark is lost even though everything else is correct.
qualifyingScore = InputBox(...) count = 0 FOR i = 0 To 199 If category(i) = "Junior" AND scores(i) >= qualifyingScore Then count = count + 1 End If Next i Msgbox("i & ...")
2/5 — count is initialised and incremented, the loop is correct, and both conditions are present, worth 2 of the 5 marks — but the final message outputs the loop variable i instead of count, so the output isn't correctly concatenated.
Response 2 answered both part (i) and part (ii) inside the same box, so the same original page is used for both quotes below.
function rollaway(my_image) {my_image.src = '../images/Bailey2.png';}
1/2 — a function with the correct name and parameter, but it resets the image to the wrong file: Bailey2.png, not the original image.
onmouseout = "rollaway(this)"
1/2 — the function is called correctly with the right event, but the question asked for the whole HTML element to be re-written, not just the added attribute, so the second mark isn't awarded.
<img id="dogImage" src="../images/Bailey1.png" onmouseover="rollover(this)" onmouseoff="rolloff(this)">
2/2 — the function name, parameter, and the source attribute pointing to the correct original image (Bailey1.png) are all present.
onmouseoff = "rolloff(this)"
1/2 — the function is correctly called with the right parameter, but the event name is wrong: onmouseoff isn't a real mouse event — it needed to be onmouseout.
Field(s): forename, surname, SUM(time) Search criteria: Instructor.instructorID = Booking.instructorID AND date = ??/05/2019 Grouping: forename, surname
2/3 — the search criteria and grouping are both correct, but SUM is applied to the wrong field — "time" — rather than the lesson duration field being summed.
Field(s): forename, surname, Total(time) as Maxhours Search criteria: WHERE Customer.customerID = Booking.customerID AND date = "*/05/2019" Grouping: customerID
1/3 — the search criteria is correct, but the function name and the grouping are both wrong: "Total" isn't a recognised aggregate function, and grouping by customerID instead of the forename/surname fields loses the grouping mark.
Field(s): forename, surname, Sum(lessonDuration) Table(s): Instructor, Booking Grouping: forename, surname
2/4 — the tables and grouping are both correct, but SUM was used instead of COUNT to count lessons booked, and no sort order was given, so those two marks are lost.
Field(s): forename, surname, COUNT(instructorID) as [mostLessons] Table(s): Instructor, Booking Grouping: instructorID Sort order: [mostLessons] DESC
2/4 — the fields, COUNT and tables are all correct. Grouping by instructorID rather than the forename/surname fields the design table lists loses that mark, though the sort order on the alias, descending, is still credited since this is a design question, not a syntax check.
"The program is comparing the list to the newlist and if they are not equal to one another then the position is incremented, which then sets the list and newlist to be equal."
0/2 — this restates the code as a sentence but never refers to the first iteration, or to the actual values of the variables during it, which the question specifically asked for.
"This will only add the value to the newlist if the value has not already been entered. If the value in the original list is not equal to the last value (the newest in newlist), then it will increment the counter and add it to the newlist array."
1/2 — a meaningful description of what the code is for, earning one mark, but it still never references the relevant values during the first iteration specifically.
Exam technique
Source trail
Used for the official question paper structure, marks, timing, and the skill areas assessed.
Used for every mark breakdown and marker reasoning shown in the marked examples section above.
Used for every candidate quote and scanned answer shown in the marked examples section above.
The live SQA page hosting these and other question paper exemplars for Higher Computing Science.