OCR A Level Computer Science NEA: Ideas, Sections, AI Rules
OCR H446 NEA guide: 70 marks and 20% of the A Level. Project ideas, what each section needs for top bands, and OCR and JCQ rules on using AI.
By Yuness, qualified Computer Science teacher and former Head of KS5 Computer Science · Last reviewed 21 November 2026
The OCR A Level Computer Science NEA (H446 component 03 or 04, the Programming Project) is worth 70 marks and 20% of your A Level. You choose a real problem with real users, then analyse it, design a solution, build and test it in iterations and evaluate it against success criteria you set yourself. You can use AI tools in limited ways, but every use must be acknowledged, and you only get marks for work you did yourself.
This guide is for Year 12 and 13 students (and their parents). It covers how marks are split, how to pick a project that can reach the top bands, what each section needs, and what OCR and JCQ say about AI as of November 2026.
What the OCR A Level Computer Science NEA is
The OCR H446 specification describes the Programming Project as "a substantial piece of work which assesses a variety of different skills". You hand it in as a report. Your teacher marks it, and OCR moderates a sample from your school. Component 03 means your school uploads electronic copies of the sample using OCR's Submit for Assessment service. Component 04 means the sample is posted to a moderator. The marking criteria are the same for both.
There is no word count. The marks are split across six areas:
| Section | Spec reference | Marks | What the top band asks for |
|---|---|---|---|
| Analysis of the problem | 3.1 | 10 | Justified computational approach, stakeholders, research into existing solutions, justified requirements and measurable success criteria |
| Design of the solution | 3.2 | 15 | Systematic, justified decomposition; full algorithms; usability features; justified data structures and validation; test data planned |
| Iterative development | 3.3.1 | 15 | Evidence of each stage with prototypes, modular code, annotation that helps maintenance, validation of all key elements |
| Testing to inform development | 3.3.2 | 10 | Testing at each stage, failed tests and fully justified remedial actions |
| Testing to inform evaluation | 3.4.1 | 5 | Annotated final testing for function and robustness, plus usability testing |
| Evaluation of the solution | 3.4.2–3.4.4 | 15 | Each success criterion judged against test evidence, usability evaluated, maintenance, limitations and future development discussed |
| Total | 70 | 20% of the A Level |
Each section is marked by best fit. Your teacher reads the whole section, chooses the band whose descriptors fit your work best, and then places you within that band. You don't need every bullet point to get into a band, but the quality has to be consistent.
The habit that separates the bands
As you move up the bands, the wording changes from "identified" to "described" to "explained and justified". Top-band work explains why as well as what. The clearest example is the difference between description and evaluation:
- Description (low marks): "The login screen shows the username and password boxes, and the login button is in the middle."
- Evaluation (high marks): "This screen meets SC4 (login checked in under one second). Test 12 measured 0.3 seconds on the minimum hardware. The error message deliberately does not say whether the username or the password was wrong (SC9), so attackers cannot find out which usernames exist."
Most of the marks students lose in Analysis and Evaluation come from writing the first kind of sentence where the second kind was needed.
Choosing your NEA project: good ideas and risky ones
Your choice of project matters more than any other decision, because a project that is too thin limits your marks however well you write it up. OCR's project setting guidance says a project needs a substantial coded element that you wrote yourself. It lists signs that a project has enough scope: persistent data storage, an object-oriented approach, interfacing with hardware or a network, sensible use of libraries, and combining technologies.
A good project:
- solves a real problem for real people you can interview and who can test your product
- needs non-trivial algorithms or data structures that you design and code yourself
- is small enough to finish, with extra features kept on a "wish list"
- has a proper graphical interface (the spec expects a suitable GUI, and OCR's guidance says a command-line-only project needs OCR's approval first)
Project ideas that work, and why
OCR expects the final idea to come from you, and teachers should not give you ready-made titles or ideas. Use these as starting points and adapt them to people you actually know.
- A revision app for younger students that uses spaced repetition. The scheduling algorithm and the progress data give you real logic and persistent storage, and the students can be your stakeholders.
- A fixture and training scheduler for a sports club, with clash detection. OCR lists automated scheduling and timetabling as suitable. Clash detection makes you think carefully about data structures.
- A grid-based strategy game with a computer opponent. OCR lists complex games against the computer. Pathfinding (for example Dijkstra's or A*) is the kind of algorithm OCR values when you implement or adapt it yourself.
- A stealth game with AI-controlled guards. This example comes from OCR's own guidance. Guard behaviour, states and line-of-sight give you plenty to design and justify.
- A budget tracker with categorisation, forecasting and charts. It handles real data and needs a forecasting algorithm and thorough validation.
- An adaptive quiz that stores results and changes difficulty based on performance. OCR rates this as suitable, while a plain multiple-choice quiz is too limited. The adaptive logic is what makes the difference.
- A loans and reservations system for a school department. This only works if it goes past simple storage and retrieval, for example with reservation queues, overdue rules and different user roles, because OCR warns that simple data storage and retrieval lacks scope.
- A networked sports-day scoring system. OCR's example. Several devices send results to a central server, which brings networking and concurrency into the project.
- A mobile app that works offline and syncs to a remote database. Also an OCR example. Handling sync conflicts is a real computational problem.
- A scientific simulation (for example projectile motion or population spread) built with maths libraries and a clear model-view-controller structure. OCR lists this kind of project. You get algorithms, OOP and measurable success criteria.
- A multi-user website with accounts and server-side logic (for example, booking slots for a local tutor or club). OCR lists online multi-user websites. Static pages are not enough.
- A Raspberry Pi monitor (greenhouse, fish tank, classroom CO2) that logs sensor data and raises alerts. Interfacing with hardware is one of OCR's signs of good scope, and the data analysis gives you algorithms to design.
Risky or unsuitable ideas
- Too trivial: a calculator, a simple multiple-choice quiz, a simple single-player game, or a login page that only displays database records.
- Wrong tools: OCR's guidance names Microsoft Access or Excel projects, VBA, drag-and-drop tools such as Scratch or App Inventor, and environments that generate most of the code for you as limited or unsuitable.
- Too big or too vague: "Minecraft" or "an app like Instagram". You won't finish, and you can't write measurable success criteria for something that vague.
- Someone else's code doing the heavy lifting: a chatbot that mostly passes text to an AI API, or a static website with no logic. You won't lose marks just for using libraries, and OCR calls sensible library use good practice. The problem comes when your own code is only a thin layer on top of someone else's.
On games, OCR advises quality over quantity: a polished single level that works properly can score more than a large game full of bugs. If you aren't sure, your teacher can send project proposals to OCR for feedback.
Section-by-section guide
Analysis (10 marks)
This section shows that you understand the problem and who it is for. Include:
- a problem statement, and a justified argument for why it suits a computational solution, using ideas such as abstraction, decomposition and thinking ahead (see computational methods)
- two or three stakeholders, each described with their needs and how your solution meets them, with interview or survey evidence
- research into two or three existing solutions, saying what you will adopt or reject and why
- justified hardware and software requirements, plus functional and non-functional requirements
- numbered, measurable success criteria (SC1, SC2…), each with a target such as "search returns results in under 2 seconds" and a way to test it
- limitations of your proposed solution, explained
Research into existing solutions is already expected in the 3–5 band, so leaving it out makes it very hard to get beyond the lowest band. "The game will be fun" is not a success criterion, because you can't test it.
Design (15 marks)
The design is your plan for development. The top band asks for a systematic, justified breakdown of the problem, a clearly defined structure, algorithms that together form a complete solution, justified usability features, justified variables, data structures and classes with their validation, and test data planned for both development and post-development testing. In practice that means:
- a decomposition diagram, with a reason for the order you will build things in
- pseudocode for each major routine, plus flowcharts or UML class diagrams where the logic or object-oriented structure needs them
- annotated wireframes that link each screen element to a success criterion
- justified data structure choices, for example a dictionary lookup instead of a list search because it is queried constantly (Big O reasoning helps here)
- validation rules for every input, and test tables planned in advance with normal, boundary and erroneous data
Don't paste finished code into the design section. OCR's AI guidance says that examiners will not reward reverse-engineered designs, and pseudocode that looks like code is one of the warning signs teachers look for. Your design doesn't have to be perfect. Iterative development is supposed to expose flaws, and fixing them is part of the evidence.
Iterative development (15) and testing to inform development (10)
These two sections go together. Build in numbered prototypes (v0.1, v0.2… or Stage 1, 2, 3), each one linked back to a part of your decomposition. For each iteration, show:
- what you built and why, with the relevant code snippets inside that iteration rather than one large dump at the end
- screenshots of the output
- a test table for that stage, including tests that failed
- what went wrong, how you worked out the cause, what you changed, and the re-test that proves the fix (a cause-and-action table works well)
- a short review before moving on
The top band of iterative development asks for code that is well structured and modular, meaningful names for every variable and structure, comments that would help a future developer, and validation of all key elements. The top band of testing asks for evidence of failed tests and remedial actions with full justification, so a table where every test passes is a weakness. It suggests either that you didn't test properly or that you didn't record what happened.
Testing to inform evaluation (5 marks)
Once the product is finished, test it for three separate things: function (does it do what the success criteria say?), robustness (invalid input, extreme values, missing files, lost connection) and usability (real users, ideally the stakeholders from your analysis). Testing function only gets you up to 2 marks. The full 5 needs all three, annotated. Record honest "partially met" and "failed" results.
Evaluation (15 marks)
Students often write this section in the last few days and lose marks they could have kept. Go through every numbered success criterion and say whether it is met, partially met or not met. Give the test ID that shows it, and explain why the evidence supports your judgement. Then:
- evaluate each usability feature from your design, quoting your users' feedback
- explain how unmet criteria could be dealt with
- discuss maintainability: could another developer extend your code, and why?
- describe limitations and specific future developments (not just "I would add more features")
The top band asks for a well-developed line of reasoning that is clear and logically structured.
What keeps you in the lower bands, and what gets you into the top ones
| Keeps you low | Gets you into the top bands |
|---|---|
| No research into existing solutions | A comparison table of existing solutions with adopt/reject decisions tied to your success criteria |
| One stakeholder, asked once | Several stakeholders, involved in analysis, testing and evaluation |
| Vague success criteria ("easy to use") | Numbered, measurable criteria with targets and test methods |
| Finished code pasted into the design | Pseudocode with justified algorithm and data structure choices |
| One big code dump, no prototypes | Numbered iterations, each linked to the decomposition and reviewed |
| Every test passes | Real failures recorded, diagnosed, fixed and re-tested |
| Final testing for function only | Function, robustness and usability tested separately |
| "The project was successful" | Each criterion judged against specific test evidence |
Evidence, authenticity and version control
You and your school both have to declare that the work is your own (spec section 4d). The spec also says your work must be properly referenced and must be assessable without any special hardware or software. Screenshot everything that matters, and assume nobody will run your program. As you go, keep:
- annotated screenshots of code and output for every iteration
- dated stakeholder evidence (interview notes, emails, survey results)
- test results recorded at the time, not written up afterwards
- a bibliography of every tutorial, website, library and piece of code you used or adapted
Use version control. Git is ideal. At the very least, save a dated copy of your code at the end of each iteration. You get a backup, and the dated history is strong evidence that the work developed over time and is yours.
Presentation. The spec's checklist expects a title, contents list, description and justification of the investigation, analysis, design and methods, evaluation, bibliography and numbered pages. Make sure the page numbers in your contents list are correct.
Time management
Your school will set its own internal deadlines. Within those, this is the split I recommend to my students:
| Phase | Suggested weeks |
|---|---|
| Analysis | 2–3 |
| Design | 2–3 |
| Iterative development and testing | 8–12 |
| Testing to inform evaluation | 1–2 |
| Evaluation | 1–2 |
| Buffer and final review | 1–2 |
The most common timing mistake is leaving the evaluation until the last weekend. Aim to finish development with two or three weeks left for final testing and the evaluation write-up.
Can you use AI in the OCR A Level CS NEA?
Yes, but only in limited ways, and every use must be acknowledged. OCR's guidance on AI in the A Level Computer Science NEA (updated February 2026) treats AI like any other outside help. The current H446 specification (version 3.0, April 2026) also has a section on AI use in the NEA, which says you must make clear how any AI use informed your own work. Its principle is: "Only independent candidate work should be credited." If AI gives you more than general advice, for example by writing or fixing code for you, that has to be recorded and taken into account when your work is marked.
What OCR's guidance describes as reasonable
- Analysis: generating ideas and finding similar existing products, as long as AI is not driving the whole process.
- Design: generally discouraged. Make your own first attempt. If you are struggling and then compare it with an AI suggestion, reference the AI output and justify which approach is better.
- Development: researching techniques rather than solutions (ask "what algorithms could find a shortest path?", not "write Dijkstra's for my game"), asking why your code won't run, or asking how a method could be written and then clearly adapting it. If you're completely stuck, a short referenced section is acceptable, but you must show how your own work continued from there.
- Testing and evaluation: very limited use. Your evaluation has to link back to your stakeholders, and OCR calls AI-written evaluation poor practice that makes the upper bands very difficult to reach.
What counts as misuse
Using AI output without acknowledging it, disguising AI use, or using AI for substantial sections of the work. OCR also points out that AI code is not always correct, and if you don't understand your own code, you will struggle in the testing sections.
How to acknowledge AI (JCQ rules)
Under the JCQ guidance on AI use in assessments (revised November 2026), you must:
- name the specific tool and the date you used it. Writing just "AI" or "ChatGPT" is not enough
- keep your prompts and the AI's responses in a form that can't be edited, such as screenshots
- if AI changed your work directly, keep a copy of the original version from before the change
- add a short explanation of how you used it, and submit all of this with your work (OCR suggests an appendix)
Acknowledged AI use is not automatically penalised, but you won't get marks for work you didn't do yourself. Your school will also have its own AI policy, so check it. If misuse is found before you sign the declaration, your school deals with it. After you sign, it must be reported to OCR, and the possible penalties go up to disqualification.
Final checklist before you submit
Go through this one or two weeks before your deadline, not the night before.
- Analysis: 2–3 stakeholders with evidence; 2–3 existing solutions analysed; justified hardware/software requirements; numbered, measurable success criteria; limitations explained
- Design: justified decomposition; pseudocode (not finished code); diagrams where needed; annotated wireframes; justified data structures; validation rules; planned normal/boundary/erroneous test data
- Development: numbered iterations linked to the decomposition; modular, well-named, commented code; validation on all key inputs; failed tests and fixes recorded
- Final testing: function, robustness and usability, with real users
- Evaluation: every success criterion judged with test IDs; usability, maintenance, limitations and specific future development
- Submission: title page; contents with accurate page numbers; every page numbered; bibliography; AI use acknowledged with screenshots; all screenshots annotated; declaration signed
Teachers marking the project may find my companion post on marking the OCR H446 NEA useful.
FAQ
How much is the OCR A Level Computer Science NEA worth?
70 marks, which is 20% of the H446 A Level.
Can I use ChatGPT or Copilot for my NEA?
Only for limited support, such as ideas, researching techniques or understanding an error, and every use must be acknowledged with the tool name, the date, and screenshots of your prompts and its output. You only get credit for your own work, and your school's own AI policy also applies.
Which programming language should I use?
The spec lists Python, the C family, Java, Visual Basic, PHP and Delphi. OCR's guidance has also approved others, including JavaScript, Node.js, Swift and the Unity and Unreal game engines, and other languages can be submitted to OCR for approval. Choose the language you are most fluent in that suits the project.
Can I make a game for my NEA?
Yes. OCR lists complex games, especially ones with a computer opponent, as suitable. Put your effort into the logic rather than the artwork (graphics earn no credit), and keep the scope small enough to finish properly.
Is there a word limit?
No. The spec says there is no word count. Clear, cross-referenced writing scores better than padding.
How much can my teacher help?
Teachers can advise on how to approach each section and supervise your progress, but they must not over-direct you or give you a solution. Any significant help has to be recorded and taken into account in your mark.
For revision notes on the theory behind your project, from OOP to algorithms, see the free OCR A Level Computer Science hub. If you'd like one-to-one help with planning, structuring or debugging your NEA (in a way that keeps the work yours), you can book a free 1-hour trial lesson.