programming project (nea)
Guidance on the Non-Examined Assessment
AQA A-Level Computer Science
The AQA A-Level Computer Science Non-Exam Assessment (NEA / 7517/C) is worth 75 marks (20% of the overall A-Level). The mark allocation heavily favours the actual code over lengthy paperwork, with 42 of the 75 marks allocated directly to the programmed solution.
To achieve high marks, a project must demonstrate an A-Level standard of technical complexity. If a chosen problem is deemed to be below A-Level standard, the marks awarded across Analysis, Design, Testing, and Evaluation are penalized by shifting downwards by two marking levels.
💻 What constitutes an A-Level Standard Project?
AQA expects projects to solve realistic, complex problems or conduct technical investigations. Project domains that naturally provide the necessary technical challenge include:
Optimization & Pathfinding: Shortest-path route finding (e.g., A* or Dijkstra algorithms), automated scheduling engines, or rota generation.
Complex Data Processing & Relational Databases: Systems utilizing multi-table Third Normal Form (3NF) relational databases, parameterized SQL queries, cross-table joins, and aggregate functions (
GROUP BYHAVINGSimulations & Cellular Automata: Business or scientific simulations, or investigations into complex rule systems (e.g., Conway's Game of Life).
Interactive Games & AI: Games incorporating dynamic state management, custom pathfinding, or artificial intelligence algorithms.
Hardware & Embedded Systems: Control systems using microcontrollers (e.g., Arduino or Raspberry Pi) linked with physical sensors and actuators.
Dynamic Web & Client-Server Systems: Socket-based client-server architectures or dynamic web applications calling parameterized Web APIs and parsing JSON/XML payloads.
🥷 Technical Skill Categorisation (Group A, B, and C)
AQA categorises technical skills into three groups to determine the mark range for Techniques Used (27 marks):
Group
A
B
C
Marks
19-27
10-18
1-9
Level
3
2
1
Standard
High (A-Level)
Intermediate (AS Level)
Low (GCSE)
Data Models
Interlinked relational database schemas, custom object-oriented models (using classes, inheritance, composition, polymorphism, and interfaces), direct-access files, dynamic object generation, hash tables, stacks, queues, trees, or graphs.
Cross-table parameterized SQL, aggregate SQL functions, graph/tree traversals (A*, Dijkstra, BFS, DFS), custom hashing, recursive algorithms with backtracking, O(n log n) sorting (e.g., Mergesort, Quicksort), or calling parameterized Web APIs and parsing JSON/XML payloads.
Single-dimensional arrays, single-table flat databases or CSV files.
Algorithms
Simple 2–3 table databases, multi-dimensional arrays, dictionaries, records, sequential text files, or simple single-class OOP models.
Single-table non-parameterized SQL, Bubble sort, binary search, sequential file I/O, or simple mathematical calculations.
linear searches, and simple arithmetic totals or averages
☑️ Quality of Code & Defensive Programming
Demonstrating Group A complexity must be paired with high-quality software engineering:
Defensive Programming: Input validation (sanitizing user data via regular expressions or range checks) and structured exception handling (try-catch blocks) around volatile file operations, database queries, or network sockets.
Code Architecture: High cohesion and loose coupling through modular subroutines, avoiding global variables in favor of local variables and parameters.
Portability: Parameterized or relative file paths (e.g., ..\data\database.db) rather than hardcoded absolute paths specific to one machine (e.g., C:\Users\...).
😲 Common Pitfalls Highlighted by Examiners
Senior moderators explicitly warn against project choices that fail to reach A-Level standard:
Simple Multiple-Choice Quizzes: Standard quizzes are frequently marked down to Level 1 or 2 unless extended with dynamic question generation, adaptive difficulty, or complex student tracking.
Basic CRUD Databases: Systems that only add and display database records without server-side data processing or cross-table aggregation struggle to score high marks.
Tutorial Reproduction: Following YouTube/GitHub tutorials or using heavy frameworks (like Pygame, Unity, or Django) without writing personal custom algorithms or clearly identifying external code.
Static "Boilerplate Inflation": Manually creating dozens of near-identical static classes instead of implementing dynamic object generation and algorithmic abstraction.
Sample Project Ideas
The following table contains some ideas on projects you might want to consider. Remember though that you need a REAL end-user with a REAL problem so please use these as a guide.
Group A
Group B
Group C
To achieve Level 3 in Techniques Used, projects must implement complex data models (3NF relational databases, custom data structures, complex OOP) and advanced algorithms (graph traversals, recursion, optimization, (O(n log n)) sorting).
These projects rely on intermediate structures such as 2–3 table databases, non-parameterised SQL, multi-dimensional arrays, dictionaries, sequential files, or basic algorithms (Bubble sort, Binary search).
Projects in this group rely on single-dimensional arrays, primitive data types, single-table databases or flat CSV files, linear searches, and simple arithmetic. If chosen for an A-Level NEA, a two-level mark penalty is applied across documentation sections.
1
Shortest-Path Logistics & Delivery Route Finder: Calculates optimal multi-stop routes using A* or Dijkstra graph traversal algorithms, supported by a weighted graph data structure and cross-table parameterised SQL queries.
2
Automated School Timetabling & Rota Engine: Solves complex room and teacher availability constraints using a recursive backtracking algorithm, backed by an interlinked 3NF relational database schema.
3
Turn-Based AI Strategy Game (e.g. Chess or Connect 4): Features a Minimax game tree traversal algorithm with alpha-beta pruning and a complex OOP model using inheritance and polymorphism for piece behaviors.
4
Interactive 2D Physics Simulator: Simulates rigid-body dynamics and elastic collisions using advanced matrix operations, custom spatial partitioning (Quadtrees), and dynamic object generation.
5
Real-Time Client-Server Multiplayer Game: Implements socket communication using request/response objects, handling thread management, queue data structures for game state, and custom hashing for session tokens.
6
Patient Triage & Appointment Scheduling System: Uses a priority queue (Heap data structure) for dynamic patient prioritization, linked to a 3NF relational database using parameterised SQL and aggregate functions (`GROUP BY`, `HAVING`).
7
Arithmetic Expression Evaluator & Mini-Compiler: Parses mathematical expressions into an Abstract Syntax Tree using recursive descent parsing and evaluates execution using custom stack and queue operations.
8
Automated Stock Portfolio & Risk Analyzer: Calls parameterised Web Service APIs to parse live JSON financial payloads, applying recursive moving-average algorithms and 3NF database persistence.
9
Library Management & Recommendation System: Implements a custom Hash Table with collision handling (chaining or open addressing) for fast ISBN lookups, combined with a multi-table database and cross-table SQL.
10
Conway's Game of Life & Pattern Simulator: Models cellular automata state transitions using dynamic object generation, pattern matching routines, and custom file serialization.
11
Autonomous Robot Pathfinding Visualizer: Simulates an autonomous agent navigating dynamic obstacles using Breadth-First Search (BFS) or Depth-First Search (DFS) on a grid network with dynamic OOP rendering.
12
E-Commerce Order Fulfillment & Inventory System: Utilizes a 3NF database schema (Orders, Products, Customers, OrderItems) with parameterised cross-table SQL and aggregate reporting queries.
13
Dynamic Maze Generator & Solver Visualizer: Generates complex mazes using recursive backtracking algorithms and visualizes solutions using Dijkstra or A* pathfinding.
14
Computer Control Laser / Target Tracking System (IoT): Combines microcontrollers (RaspberryFF Pi / Arduino) with computer vision object tracking algorithms, communicating via client-server sockets.
15
Adaptive Student Learning & Spaced-Repetition System: Generates dynamic revision schedules based on user performance algorithms, connected to an interlinked relational database tracking student progress via parameterised SQL queries.
16
3D Wireframe Graphics Engine: Renders 3D objects onto a 2D screen using matrix transformation operations (rotation, scaling, translation) and Z-buffer sorting using Mergesort.
1
Simple School Club Attendance Tracker: Uses a 2-table database (Students, Clubs), non-parameterised SQL queries, and text file logging.
2
Contact Management Application: Stores contact records in a dictionary / array of records, applying Binary search for lookups and Bubble sort to organize contacts alphabetically.
3
Basic 2D Platformer / Maze Game: Uses multi-dimensional arrays for tilemaps and a simple single-class OOP model for basic player movement and collision checks.
4
Simple Library Book Catalog: Uses a 2-table database with non-parameterised SQL search queries and sequential CSV file exports.
5
Basic Weather Data Viewer: Fetches data from a simple unparameterised Web API, parsing JSON into multi-dimensional arrays to calculate daily averages.
6
Student Grade Calculator & Report Generator: Stores assessment scores in multi-dimensional arrays, computing statistical totals using user-defined arithmetic routines.
7
Text-Based Flashcard Revision App: Reads question-answer pairs sequentially from text files and shuffles cards using a 2D array.
8
Simple Personal Expense Tracker: Uses a 2-table database (Categories, Expenses) with non-parameterised SQL to display category subtotals.
9
Basic Cinema Ticket Booking System: Models seating layouts using a 2D array and records reservations in a text file.
10
Local Shop Inventory Manager: Manages stock details in a 2-table database, applying Bubble sort to sort items by price or stock quantity.
11
Fitness & Workout Tracker: Logs workouts using records and dictionaries, exporting weekly performance summaries to text files.
12
Music Playlist Manager: Manages tracklists in multi-dimensional arrays, utilizing Binary search to find specific tracks.
13
Recipe & Meal Planning App: Reads recipe files sequentially, storing ingredients in dictionaries and calculating simple serving size scalings.
14
Simple Parking Lot Management App: Uses a 2D array to represent parking space availability and computes hourly rates via basic mathematical routines.
15
Hotel Room Reservation System: Utilizes a 3-table database (Rooms, Guests, Bookings) with non-parameterised SQL queries.
16
Task & To-Do List Manager: Stores tasks as structured records in a list, saving and loading data to sequential text files.
1
Basic Multiple-Choice Quiz: Stores questions in a 1D array, comparing user answers with `if` statements and maintaining a running score total.
2
Simple BMI & Calorie Calculator: Uses primitive data types to compute BMI values via standard mathematical formulas.
3
Flat-File Address Book: Saves names and phone numbers in a single CSV file, relying on a Linear search to locate entries.
4
Basic Temperature Unit Converter: Converts values between Celsius, Fahrenheit, and Kelvin using basic arithmetic.
5
Simple Currency Converter App: Multiplies user inputs by hardcoded exchange rates stored in primitive variables.
6
Basic Desktop Calculator: Performs standard addition, subtraction, multiplication, and division using simple arithmetic functions.
7
Single-Table Student Score Log: Saves student names and test scores into a single-table CSV file, calculating the class average.
8
Simple Shopping List Tool: Appends string items to a 1D array and prints the array contents.
9
Rock-Paper-Scissors Game: Uses random integer generation and conditional statements to compare choices.
10
Basic Password Strength Checker: Evaluates string length and character types using basic loop iteration.
11
Flat-File Movie Rating Tracker: Stores movie titles in a single CSV file and uses Linear search to find titles.
12
Dice Rolling Simulator: Generates random numbers (1–6) and tallies outcomes in a 1D array.
13
Simple Text Character/Word Counter: Iterates through a user-entered text string to count words and characters.
14
Basic Tip Calculator: Computes bill tip percentages and splits amounts evenly across a fixed number of people.
15
Single-Table Inventory Tracker: Keeps stock counts in a single CSV flat file with non-SQL file overwriting.
16
Guess-the-Number Game: Compares user guesses against a random target integer using basic comparison operators.
Structuring the Report
1️⃣ Analysis (9 Marks | ~12%)
Establishes the problem boundaries, stakeholder needs, and core project goals.
Problem Definition & Context: A clear explanation of the real-world problem or computational investigation, including the background context and target user/client.
Stakeholder Dialogue: Documented evidence of direct consultation (interviews or questionnaires) with a real end-user or domain expert to determine system requirements.
Measurable Specific Objectives: A numbered list of precise, quantifiable functional and non-functional objectives. (Avoid vague goals like "make it user-friendly"; use verifiable targets like "authenticate users against a 3NF database in < 1 second").
Computational Modelling: Abstraction models informing the design phase, such as Context Diagrams, Data Flow Diagrams (DFDs), Entity-Relationship Diagrams (ERDs), or state machine models.
2️⃣ Documented Design (12 Marks | ~16%)
Communicates the structural and algorithmic architecture clearly enough for a third party to understand without reading raw code.
System Architecture: High-level module hierarchy charts and component interaction diagrams (e.g. Model-View-Controller or client-server architecture).
Algorithm Design: Pseudocode or ANSI flowcharts for critical-path algorithms, detailing parameter passing, variable scoping, and Big O time/space complexity.
Database & Data Structure Design: Relational database schemas with a step-by-step normalisation proof up to Third Normal Form (3NF), data dictionary tables, and custom data structure definitions (e.g. trees, queues, linked lists).
User Interface Wireframes: Annotated layout designs linking interface controls directly to action triggers, input validation rules, and screen state transitions.
3️⃣ Technical Solution (42 Marks | 56%)
The primary deliverable, split into Completeness of Solution (15 marks) and Techniques Used & Coding Style (27 marks).
Code Navigation & Overview Guide: A cover page / code contents guide listing file names, database connections, executables, and path instructions so an evaluator can run and navigate the software.
Group A Technical Skills: Implementation of complex algorithms (e.g. graph search/A*, recursive algorithms, O(nn) sorting) and complex data models (e.g. interlinked SQL database tables, OOP models with dynamic object generation, client-server sockets).
Quality Coding Style & Defensive Programming: Robust input validation, structured try-catch exception handling, cohesive subroutines, relative/parameterised file paths, and self-documenting code with meaningful identifier names.
Complete Source Code Listing: Full, formatted source code pasted directly from the IDE (text, not screenshots) with appropriate inline annotations.
4️⃣ Testing (8 Marks | ~10.7%)
Provides empirical evidence that the solution works, handles edge cases, and satisfies requirements.
Comprehensive Test Plan: A structured test schedule directly mapped to the original Analysis objectives.
Categorised Test Data: Executed test cases demonstrating Normal (typical valid inputs), Boundary (extreme limit values), and Erroneous (invalid data to verify error handling) test conditions.
Representative Evidence: Annotated screenshots, step-by-step trace tables for complex data state changes, or references to short screen-recording videos with exact timestamps.
Whole-System Integration: Proof that individual modules, database storage, and UI elements function together cohesively end-to-end.
5️⃣ Evaluation (4 Marks | ~5.3%)
An objective, critical appraisal comparing final performance against analytical objectives.
Objective Verification Matrix: A table systematically comparing every specific objective from Section 1 against actual test outcomes to establish project completion.
Authentic Client Feedback: Candid feedback obtained from field-testing with the real end-user/stakeholder, evaluating system strengths and usability limitations.
Systemic Limitations & Future Enhancements: An honest critique of performance bottlenecks, scalability limits, and concrete technical upgrades if the project were to be revisited.
Last modified: October 16th, 2026
