AQA A Level Computer Science NEA — How to Tackle the Skeleton Code Project

The AQA A Level Computer Science Non-Examined Assessment (NEA) is worth up to 70 marks — approximately 20% of the total A Level. Unlike the written papers, it is completed over several months, marked by your teacher and moderated by AQA. It is an opportunity to demonstrate real programming ability and problem-solving in a sustained, structured way.

This guide explains exactly what the NEA involves, how marks are awarded, and how to approach each section to maximise your grade.

What is the AQA NEA?

Each summer, AQA releases a skeleton code file — a partially written program in one or more programming languages (typically Python, Java and C#). The skeleton code provides the structure of a program but deliberately leaves significant sections incomplete, often marked with comments like # TODO or # complete this method.

Your task is to:

Analyse the skeleton code — understand what the program is meant to do and what is missing
Design the missing sections — plan your approach before coding
Implement — write the working code
Test — demonstrate that your code works with appropriate test data
Evaluate — reflect on what works well and what could be improved

The NEA is marked against AQA’s published mark scheme, which is released alongside the skeleton code.

When is the skeleton code released?

AQA typically releases the skeleton code in July, giving students the full summer holiday to begin familiarising themselves with it. The completed NEA must be submitted by May of the exam year (the exact date varies — check AQA’s website). Most schools set an internal submission deadline in March or April to allow time for teacher marking and moderation.

How are the 70 marks distributed?

Section	Marks
Analysis	7
Design	12
Technical solution (the code)	30
Testing and evaluation	16
Reporting (documentation quality)	5
Total	70

Analysis (7 marks)

You are expected to demonstrate a clear understanding of:

What the skeleton code does — its purpose, inputs and outputs
What the incomplete sections need to do
Any assumptions you are making about the requirements

Common mistake: Students write a general description of the program without specifically identifying what is missing and why it matters. Be specific — reference actual function names, variables and line numbers from the skeleton code.

Design (12 marks)

This section requires you to show your thinking before you code. For each major incomplete section:

Describe your chosen approach (with alternatives considered)
Use structured pseudocode, flowcharts or diagrams
Show how your design connects to the skeleton code’s existing structure
Identify data structures you will use

Common mistake: Writing “I will use a for loop to iterate through the list” — this is too vague. Describe which list, what the loop will compute on each iteration, and where the result goes.

Technical Solution (30 marks)

This is the most heavily weighted section. The marks are awarded for the quality and complexity of your working code. Typical sub-criteria include:

Correctness — does the code work as specified?
Complexity — does it use appropriate constructs (classes, recursion, data structures)?
Code quality — is it well-structured, readable and appropriately commented?
Integration — does it fit correctly into the skeleton code framework?

Most skeleton codes test specific A Level programming concepts — you will often need to implement data structures (stacks, queues, hash tables, trees) or algorithms (searching, sorting, graph traversal). Check the mark scheme carefully to understand exactly what AQA is looking for in each section.

Common mistake: Writing code that “sort of works” for easy test cases but fails on edge cases. Test thoroughly with boundary values, empty inputs and unexpected data.

Testing and Evaluation (16 marks)

Testing requires a test plan — a table showing:

Test number
What you are testing (the component or feature)
Test data used (including normal, boundary and erroneous values)
Expected result
Actual result
Pass/Fail

Run your tests and capture screenshots or output. If a test fails, describe what you changed and retest.

Evaluation should cover:

What works well and what does not
Limitations of your solution
What you would improve with more time
How well your solution meets the original requirements

Common mistake: Only testing happy-path cases with data that is guaranteed to work. Examiners specifically look for boundary and erroneous test data.

Reporting (5 marks)

The documentation should be clearly written, well-organised and appropriately technical. Include:

A contents page
Section headings matching AQA’s structure
Screenshots of working code with annotations
Code listings in an appendix

Choosing your programming language

AQA provides skeleton code in multiple languages. Choose the language you are most comfortable with — for most students this is Python. The marks for the technical solution are not affected by which language you use, provided the solution is functionally correct and appropriately complex.

If you choose Python, make sure you are confident with:

Class definitions and OOP (the skeleton code often uses classes heavily)
File I/O (reading and writing to text or JSON files)
Recursion (often needed for tree or graph data structures)
List and dictionary operations

Common pitfalls to avoid

1. Starting the NEA in September and panicking in March Begin reading and understanding the skeleton code over the summer. You do not need to write code yet — just understand what the program is meant to do.

2. Leaving the design section as an afterthought The design section is worth 12 marks. Students who write it up retrospectively (after they have already coded) produce weaker, less specific designs. Design before you code.

3. Not reading the mark scheme AQA publishes specific mark scheme criteria alongside the skeleton code. These tell you exactly what the markers are looking for. Read them. Build your analysis and design around them.

4. Poor test data A test plan with ten identical “normal” test cases scores poorly. Include: one normal case, one boundary case (e.g. the minimum valid value), one erroneous case (e.g. a string where a number is expected) and one extreme case (very large input).

5. Code that isn’t your own The NEA is an academic assessment. Your teacher will discuss your code with you as part of the moderation process. Use AI tools and online resources to learn techniques, but the code you submit must be code you can explain and defend.

The Algorithm Archives course

If you want to practise the kinds of data structure implementations that typically appear in the skeleton code — stacks, queues, hash tables, binary trees, linked lists — the Algorithm Archives interactive course on CompSci Tutoring is designed exactly for this. Each level asks you to implement a data structure by writing real Python code, with the game engine providing instant feedback.

Getting help with the NEA

If you are struggling with a particular section of the skeleton code, one-to-one tutoring can make a real difference. Working with an experienced A Level Computer Science teacher, you can:

Talk through the skeleton code to understand its structure
Get help designing your approach to missing sections
Debug your implementation
Prepare your test plan and evaluation

Find out more on the tutoring page.