30 August 2026

A Level Sociology: You Can Construct the Argument — Now We Need to Get the Knowledge Into Your Memory

One of the most encouraging things I can say to an A-level Sociology student is this:

If you can construct a good argument when the information is in front of you, then the fundamental problem is not that you cannot do Sociology.

That distinction matters.

A student may understand a question, recognise competing viewpoints, explain why one argument challenges another and reach a sensible conclusion — yet still receive disappointing marks because they cannot remember enough sociologists, studies, concepts and supporting detail when the textbook is taken away.

Those are two very different problems.

And the second is much easier to tackle once we recognise what it is.

Understanding Sociology and Remembering Sociology Are Not the Same Thing

Recently, I have been looking at answers produced with notes and a textbook available.

What interested me was not simply whether the facts were correct. It was what happened once the relevant information was available.

The student could use it.

They could take an idea, explain it, relate it to the question and begin to construct an argument around it.

That tells us something important.

The difficulty is not:

"I don't understand Sociology."

It is much closer to:

"I understand the Sociology, but I cannot always retrieve the precise evidence I need quickly enough."

That is a much more useful diagnosis.

It means we do not have to start again from the beginning. We have to improve knowledge retrieval.

Sociology Requires More Than General Understanding

A-level students often know considerably more than their written answers suggest.

Ask them verbally whether family structures have changed and they may give a perfectly sensible explanation.

They might talk about:

changing gender roles;
divorce;
same-sex relationships;
cohabitation;
lone-parent families;
greater individual choice;
changing attitudes towards marriage.

But the examination requires another level.

Instead of:

"Families have become more diverse."

we need something closer to:

"Weeks argues that greater social acceptance of same-sex relationships has contributed to greater diversity in personal and family relationships."

Now we have something recognisably sociological.

The student still needs to explain it, apply it and perhaps evaluate it, but the named sociologist gives the argument authority and precision.

That is why remembering names and ideas matters.

You Do Not Need to Memorise Whole Pages

This is where students can make revision unnecessarily difficult.

A page of Sociology notes may contain several theorists, examples, statistics, concepts and criticisms.

Trying to memorise the entire page can feel overwhelming.

Instead, reduce the subject to small retrieval units.

For example:

Parsons → nuclear family → instrumental and expressive roles

That may be enough to unlock a much larger piece of knowledge.

Once Parsons has been recalled, the student may remember that he took a functionalist view of the family, saw different roles as contributing to family stability and regarded the nuclear family as suited to industrial society.

Another memory unit might be:

Weeks → chosen families → support and care outside traditional family structures

Again, those few words can unlock a much bigger argument about family diversity and challenges to the idea that only one family form can successfully provide emotional support and social relationships.

The aim is therefore not to remember 300 words.

It may initially be to remember six or seven carefully chosen words.

Think of the Name as the Handle on a Filing Cabinet

I sometimes describe this as putting a handle on a piece of knowledge.

Imagine everything you know about a sociological argument sitting inside a filing cabinet.

The information may be there.

The problem is finding the drawer.

The theorist's name can become the handle.

Parsons opens one drawer.

Weeks opens another.

Oakley, Willmott and Young, Murdock, Beck, Giddens and others each become retrieval cues leading to a larger collection of knowledge.

That is one reason flashcards can be effective — provided they are used properly.

Flashcards Are for Testing, Not Reading

There is a common trap with flashcards.

Students make beautiful cards and then repeatedly read them.

That feels like revision because the material becomes familiar.

Unfortunately, familiarity is not the same as recall.

Seeing:

Parsons — instrumental and expressive roles

and thinking:

"Yes, I remember that."

is very different from seeing:

Who argued that husbands and wives perform instrumental and expressive roles?

and being able to produce:

Parsons

without turning the card over.

The second activity is retrieval practice.

That is what the examination requires.

Try Two-Way Flashcards

For particularly important material, test it in both directions.

Card 1

Front:

Parsons

Back:

Functionalism; nuclear family; instrumental and expressive roles.

Card 2

Front:

Who distinguished between instrumental and expressive roles within the family?

Back:

Parsons.

This prevents the student becoming dependent upon seeing the sociologist's name first.

Build Knowledge in Small Groups

I would not attempt to learn twenty sociologists in one evening.

Take perhaps three.

For example:

Parsons → nuclear family → instrumental/expressive roles

Weeks → chosen families → diversity/support

Oakley → housework → continuing gender inequality

Learn those.

Then test them.

An hour later, test them again.

The next day, test them again before adding another three.

Over time, the collection grows.

The important phrase here is:

before adding another three.

If yesterday's material has disappeared, simply adding another page of notes creates the illusion of progress rather than real progress.

Move Gradually From Open Book to Closed Book

There is nothing wrong with initially constructing answers with notes available.

In fact, it can be an excellent teaching technique.

The mistake would be stopping there.

I would use a progression such as this:

Stage 1 — Full notes

Write the answer with the textbook and detailed notes available.

Concentrate on understanding how the argument works.

Stage 2 — Reduced notes

Use only a one-page summary containing names and keywords.

Stage 3 — Cue words

Allow perhaps:

Parsons — roles
Weeks — diversity
Oakley — housework

Nothing more.

Stage 4 — Memory only

Write the paragraph without assistance.

Stage 5 — Timed memory

Now do exactly the same thing under examination conditions.

This bridges the enormous gap between:

"I can do this when looking at my notes."

and:

"I can retrieve this when I need it."

The Most Important Question at the End of Every Paragraph

There is another relatively simple improvement that can make a surprisingly large difference.

At the end of every paragraph, ask:

"So how does this actually answer the question?"

Then write the answer.

Do not assume the examiner will make the connection.

Make it explicit.

What That Looks Like in Practice

Suppose the question concerns whether the nuclear family is particularly important for society.

A student might write:

Parsons argues that men traditionally perform an instrumental role by providing economically for the family, while women perform an expressive role by providing emotional support.

That demonstrates knowledge.

But now ask:

So what?

Why does that help answer the question?

We might add:

Therefore, from a functionalist perspective, the nuclear family benefits society because this division of roles helps the family perform the functions needed to maintain stability.

Now the evidence has been connected directly to the argument.

That final sentence is doing analytical work.

Knowledge Alone Is Not Enough Either

There is another important lesson here.

Learning dozens of sociologists will not automatically produce a high grade.

Consider this answer:

Parsons said men have instrumental roles and women have expressive roles.

The sociologist has been remembered.

But very little has actually been done with him.

A stronger answer develops the evidence:

Parsons argued that the traditional nuclear family contains a division of labour in which the husband performs the instrumental role of economic provider while the wife performs the expressive role of providing emotional support. Functionalists see this specialisation as beneficial because the roles complement one another and contribute towards family stability. Therefore, Parsons' argument supports the view that the nuclear family performs important functions for both its members and wider society.

We have moved from:

Name

to:

Name → idea → explanation → question

That is the sequence students need.

Then Add Evaluation

At A level, however, we usually need another step.

Can somebody challenge this argument?

For Parsons, one possibility is a feminist criticism.

For example:

However, feminists would challenge Parsons' description of these roles as complementary. They may argue that the traditional division of labour benefits men more than women because women undertake disproportionate amounts of unpaid domestic and caring work. Therefore, what Parsons describes as functional could instead be interpreted as evidence of gender inequality.

Notice that this is not simply:

"Feminists disagree."

It explains why.

That is evaluation.

A Useful Paragraph Structure

I would encourage students to think of a strong Sociology paragraph as a short chain of reasoning:

Point → Sociological evidence → Explain → Evaluate → Link to the question

It does not have to become a rigid formula that makes every paragraph sound identical.

But when an answer is going wrong, it provides an excellent diagnostic tool.

Ask:

What is my point?
Which sociologist or evidence supports it?
Have I actually explained the evidence?
Is there a criticism or alternative interpretation?
Have I linked everything back to the question?

The last one is particularly important.

The "So What?" Test

There is a very simple exercise I like.

After every piece of evidence, mentally ask:

"So what?"

For example:

Weeks discusses chosen families among gay men and lesbians.

So what?

This suggests that emotional support, care and close family-like relationships do not have to depend upon the conventional heterosexual nuclear family.

So what?

Therefore, Weeks' work challenges the argument that the traditional nuclear family is uniquely capable of meeting people's emotional and social needs.

The repeated "So what?" forces the student to turn remembered knowledge into analysis.

That is often where additional marks are found.

Make Revision About Connections, Not Isolated Facts

Another difficulty with Sociology is that students sometimes revise every sociologist as an isolated fact.

That makes the subject far harder to remember.

Instead, connect people together.

For example:

Parsons

Traditional functionalist interpretation of differentiated family roles.

versus

Oakley

Feminist criticism of gender divisions and domestic labour.

Now there is an argument.

Or:

Traditional nuclear family

versus

Weeks and chosen families

Now there is a debate about family diversity.

Human memory tends to cope much better with connected ideas than with thirty unrelated names.

Create "Argument Pairs"

This can become an especially effective revision technique.

Instead of learning:

Parsons

on Monday and:

Feminism

on Wednesday, learn them together.

For example:

Argument: Different roles within the family are complementary.

Support: Parsons.

Challenge: Feminist perspectives — supposedly complementary roles may actually conceal inequality.

Another pair might be:

Argument: Traditional family structures are necessary for support and socialisation.

Challenge: Weeks — chosen and diverse family relationships can also provide close emotional support and care.

Now the student is learning an examination argument rather than merely a list of names.

Try the 60-Second Sociology Test

A useful daily exercise needs virtually no preparation.

Choose a topic.

Perhaps family diversity.

Set a timer for 60 seconds.

Write every sociologist, concept and argument you can remember.

Do not use the notes.

Then check.

Perhaps the first attempt produces:

Weeks
same-sex families
diversity

The next attempt might produce:

Weeks
chosen families
same-sex relationships
greater choice
family diversity
challenges traditional definitions

That improvement matters.

Do it repeatedly and retrieval becomes quicker.

And speed matters in an examination because a student does not have five minutes to sit wondering:

"What was that sociologist's name?"

Turn Notes Into Questions

Another improvement is to stop treating revision notes as something simply to be read.

Convert headings into questions.

Instead of:

Parsons and the family

write:

What does Parsons argue about the nuclear family?

Instead of:

Weeks and family diversity

write:

How can Weeks be used to challenge traditional definitions of the family?

Instead of:

Feminist criticisms

write:

Why might feminists reject the functionalist interpretation of domestic roles?

Now the notes themselves become a testing system.

Build a "Minimum Knowledge" List

A whole A-level Sociology course can look enormous.

Instead of staring at hundreds of pages, identify the essential material for each topic.

Perhaps for one subtopic you initially want:

six key sociologists;
four important concepts;
two useful examples;
three evaluation arguments.

Learn those properly.

Then expand.

Ten well-understood sociologists that can actually be remembered and applied are far more useful in an examination than thirty names that seem vaguely familiar.

Practise Retrieval Before Writing the Essay

There is another examination technique worth developing.

Before beginning a longer answer, spend a short amount of planning time retrieving the evidence.

For example:

Question

Evaluate the view that the nuclear family remains the most important family type in contemporary society.

A quick plan might contain:

Parsons — functions/roles
Functionalism — stability
Feminism — inequality
Oakley — housework
Weeks — chosen families
Family diversity
Conclusion — important but not uniquely important

That list gives the student the skeleton of an essay.

The writing then becomes much easier because the difficult retrieval has already been done.

Do Not Confuse Needing Notes Now With Needing Notes Forever

This is perhaps the most important psychological point.

If a student produces a much better answer with the textbook beside them, it can be tempting to dismiss it:

"It doesn't count because I used the book."

I disagree.

It tells us something extremely useful.

It proves that the student can process the sociological information and construct an argument from it.

That is progress.

Of course, an examination will not allow the textbook.

So the next stage is not to celebrate an open-book answer as the finished product.

It is to gradually remove the support.

Full notes.

Then reduced notes.

Then keywords.

Then nothing.

The scaffolding comes down as the student becomes stronger.

What I Would Rather See Than Another Hour of Reading

If I had to choose between:

one hour rereading a Sociology textbook

and

thirty minutes actively recalling sociologists followed by thirty minutes writing two paragraphs from memory,

I would usually choose the second.

Reading still has a purpose, especially when learning something for the first time.

But once the material has been understood, students need to practise the skill the examination actually demands:

retrieving it.

A Small Routine That Can Produce a Big Improvement

A useful Sociology revision session could be surprisingly short.

Five minutes: retrieval

Write everything remembered about one small topic.

Ten minutes: flashcards

Test names, studies, concepts and criticisms.

Do not simply read them.

Ten minutes: one paragraph

Choose one examination question and write a paragraph from memory.

Five minutes: check

Compare the paragraph with the notes.

What was missing?

Two minutes: repair

Create one or two new flashcards from whatever was forgotten.

That is just over half an hour.

Done repeatedly, it is far more powerful than occasionally attempting to revise an entire topic in one enormous session.

Look for Progress in the Right Place

A student's progress should not only be measured by their latest essay percentage.

Look at the smaller changes.

Last month, perhaps only one sociologist could be remembered.

Now there are four.

Previously the paragraph gave evidence but did not explain it.

Now it does.

Previously the argument wandered away from the question.

Now each paragraph ends with a clear link.

Previously an evaluation point consisted of:

"However, feminists disagree."

Now the student can explain precisely why.

Those small improvements eventually become higher marks.

The Encouraging Part: The Argument Is Already There

This is what I most want a struggling Sociology student to understand.

If, when given the relevant material, you can use it to construct a sensible sociological argument, that is evidence of ability.

We have identified the next obstacle.

The knowledge needs to become easier to retrieve.

That means learning in smaller chunks, testing rather than rereading, connecting sociologists into arguments, gradually removing the notes and repeatedly practising short pieces of examination writing.

And after every paragraph, keep asking one deceptively simple question:

"So how does this actually answer the question?"

Then put the answer on the page.

Because an examiner cannot award marks for the link you were thinking about.

You have to make it visible.

Conclusion: From "I Know This" to "I Can Use This"

A-level Sociology demands several skills at once.

Students have to understand ideas.

They have to remember evidence.

They have to select the right evidence for the question.

They have to explain it.

They have to evaluate it.

And they have to do all of that under time pressure.

So when a student struggles to remember names and studies, we should not automatically conclude that they do not understand Sociology.

Sometimes the understanding is already surprisingly strong.

The challenge is to make the knowledge accessible when it matters.

Learn:

Parsons → nuclear family → instrumental and expressive roles

rather than an entire page.

Learn:

Weeks → chosen families → support, care and diversity

Then retrieve it tomorrow.

And again next week.

Use it in a paragraph.

Challenge it with another perspective.

Finally ask:

"So what does this prove about the question?"

That is the transition we are aiming for:

from recognising Sociology when you see it to being able to retrieve, apply and evaluate it for yourself.

And once that begins to happen consistently, the quality of the examination answer can change dramatically.

29 August 2026

Can I Develop an A-Level Computer Science Project Using Unreal Engine 5?

Yes — But the Computer Science Must Be More Impressive Than the Graphics

One of the questions I increasingly hear from A-level Computer Science students is:

“Can I use Unreal Engine 5 for my programming project?”

The short answer is yes.

The more important answer is:

Yes — provided Unreal Engine is being used as a platform on which you build your own computational solution, rather than as a tool that builds most of the solution for you.

That distinction can make the difference between a visually spectacular project that demonstrates surprisingly little Computer Science and a relatively modest-looking game that provides excellent evidence for the NEA.

There is also some reassuring official guidance here. OCR specifically identifies Unity, Unreal and Defold as acceptable game engines. However, OCR also warns that students should not rely on built-in drag-and-drop scripting functionality for the assessed design and development. Its guidance emphasises a substantial coded solution using a textually derived high-level programming language.

AQA does not need the project to be a traditional business database either. Its guidance explicitly gives computer games, simulations, optimisation problems and artificial intelligence applications as possible project types.

So the problem isn't Unreal Engine.

The question is what the student actually programs inside it.

An Impressive Game Is Not Necessarily an Impressive Computer Science Project

This is probably the most important point for students to understand.

Imagine two projects.

Project A

A student creates a beautiful medieval arena.

There are animated horses, detailed knights, banners moving in the wind, realistic sunlight, spectators, sound effects and cinematic camera movements.

The horse movement comes from an existing controller.

The environment comes from an asset pack.

The animations come from an animation library.

The collision system is Unreal's.

The menus use a tutorial.

Most of the gameplay consists of connecting existing Blueprint nodes.

It might look extraordinary.

But there may actually be very little original Computer Science underneath it.

Now consider another project.

Project B

The graphics are considerably simpler.

However, the student has programmed:

an opponent decision-making system;
a tournament structure;
a scoring algorithm;
an impact calculation system;
different armour characteristics;
lance stability;
player stamina;
opponent personalities;
persistent save data;
rankings;
dynamic difficulty;
collision interpretation;
data structures containing competitors and results;
testing tools for examining the behaviour of the algorithms.

Project B might not make such an impressive YouTube trailer.

But as an A-level Computer Science project, it potentially contains far more that can actually be assessed.

That is the mindset I would encourage from the beginning:

Don't ask, “How impressive can I make Unreal look?”

Ask:

“What interesting computational problem can I solve using Unreal?”

Our Jousting Game: A Good Example

We have been developing a jousting game ourselves, and I think it provides an excellent example of how a game can be turned from entertainment into a genuine Computer Science problem.

Part of our teaching approach is to show students some of what we have developed, discuss why particular decisions were made and allow them to question how the systems work.

That can stimulate some very interesting conversations:

Why did the opponent choose that action?

How should a hit be scored?

Should a faster horse always produce a more powerful strike?

How do you represent the accuracy of the lance?

Should armour reduce damage?

What determines whether the rider remains mounted?

How should the computer-controlled opponent adapt to the player's behaviour?

Suddenly we have moved a long way beyond simply creating a knight riding towards another knight.

We have a computational modelling problem.

A tightly focused student project could therefore be something like:

“Design and development of a 3D jousting simulation incorporating player control, computer-controlled opponents, impact modelling, scoring, tournament progression and persistent results.”

That sounds rather different from:

“I made a jousting game.”

And that difference matters.

Start With the Problem, Not Unreal Engine

A common mistake is beginning the project proposal with:

“I want to use Unreal Engine 5.”

But Unreal isn't really the project.

It is the development environment.

A much better starting question is:

What problem am I trying to solve?

For our hypothetical jousting project, the problem could be:

To develop a system capable of simulating a jousting competition in which player skill, speed, aiming, defence and computer-controlled opponent behaviour influence the result of each pass.

Now we can begin identifying computational requirements.

For example:

Player system

The player must control:

speed;
lane position;
lance position;
aim;
timing of bracing;
defensive posture.

Opponent system

The computer might decide:

how aggressively to attack;
which target area to aim for;
when to accelerate;
whether to prioritise accuracy or power;
how much defensive stability to maintain.

Impact system

The program might consider:

relative speed;
aim accuracy;
target location;
lance stability;
armour;
rider balance;
previous damage;
random variation.

Now there is plenty to program.

Turning Jousting Into Algorithms

Suppose several variables are represented on a scale from 0 to 100.

A simple model might begin with:

impactScore = speedFactor + aimAccuracy + braceTiming - defenderStability

That is probably too simplistic for the finished project, but it provides a starting point.

A more sophisticated version might use weightings:

impactScore = (relativeSpeed * 0.30) + (aimAccuracy * 0.30) + (lanceStability * 0.25) + (braceTiming * 0.15)

Then defence could modify the result:

finalImpact = impactScore - armourProtection - defenderStability

The interesting Computer Science comes from deciding how those values interact.

For example:


IF targetZone = "shield"
    damageMultiplier = 0.6
ELSE IF targetZone = "torso"
    damageMultiplier = 1.0
ELSE IF targetZone = "helmet"
    damageMultiplier = 1.3
ENDIF

The student can then ask whether the algorithm produces believable results.

Perhaps the helmet is difficult to hit, so aiming accuracy must also influence the chance of success.

Perhaps an aggressive opponent sacrifices stability for speed.

Perhaps tired competitors become progressively less accurate.

That gives us another system:

effectiveAccuracy = baseAccuracy - fatiguePenalty

And perhaps:

fatiguePenalty = staminaUsed * 0.25

The particular numbers aren't the important part.

Designing, implementing, testing and improving the model is.

Opponent AI Is Particularly Valuable

A computer-controlled opponent gives the student considerable opportunity to demonstrate computational thinking.

It doesn't need ChatGPT-style artificial intelligence or a neural network.

A perfectly good opponent could use a finite-state machine.

For example:


READY
  |
  v
ACCELERATING
  |
  v
AIMING
  |
  v
BRACING
  |
  v
IMPACT
  |
  v
RECOVERY

Different opponents could have different characteristics.

One might be highly aggressive:

aggression = 90

accuracy = 55

defence = 40

Another might be cautious:

aggression = 45

accuracy = 80

defence = 85

The AI might then make decisions such as:


IF aggression > 70 AND opponentStamina > 50
    choose highPowerAttack
ELSE IF playerDefence > 75
    choose accuracyAttack
ELSE
    choose standardAttack
ENDIF

We now have something that can be tested properly.

Does an aggressive opponent actually behave aggressively?

Does the cautious opponent win differently?

Can the player identify the opponent's strategy?

Does increasing aggression make the AI stronger, or simply more reckless?

Those are excellent evaluation questions.

Data Structures Suddenly Become Meaningful

Games are particularly useful because they naturally generate interesting data.

A competitor might be represented as an object or structure containing:


competitorID
name
skill
aggression
accuracy
stamina
armour
wins
losses
points
ranking

A tournament could then contain a collection of competitors.

The student may need algorithms for:

sorting league positions;
selecting tournament opponents;
storing results;
calculating rankings;
searching competitors;
loading saved games;
updating statistics.

This provides natural opportunities to demonstrate arrays, lists, records or structs, classes, objects, functions, procedures and other techniques rather than trying to include them artificially simply because they appear in the specification.

What About Unreal Blueprints?

This requires some care.

Blueprints are tremendously useful. I would certainly not suggest avoiding them altogether.

They can be excellent for:

connecting game systems;
prototyping;
animation events;
interfaces;
level behaviour;
visualising state;
linking coded systems to Unreal actors.

But for an OCR A-level NEA, I would be cautious about making Blueprints the main evidence of programming ability.

OCR's published advice specifically states that Unreal is acceptable but warns against reliance on built-in drag-and-drop scripting, saying this does not count towards design and development in the way the required coded solution does.

Therefore, for an OCR student using Unreal, a much safer architecture might be:

C++ — computational core

Use C++ for:

impact algorithms;
opponent AI;
scoring;
tournament management;
data handling;
rankings;
save/load logic;
stamina calculations;
difficulty systems.

Blueprints — presentation and engine integration

Use Blueprints where appropriate for:

triggering animations;
connecting interface elements;
cameras;
sounds;
visual effects;
level events.

That also produces a very clean distinction in the report:

Unreal provided the 3D engine. The student programmed the game systems.

For AQA, students should likewise make sure the technical solution clearly demonstrates their programming skill. AQA's published guidance places particularly heavy emphasis on the programmed solution: its guidance allocates 42 of the 75 NEA marks to the technical solution.

Don't Reprogram Unreal Just to Prove You Can Program

There is an opposite mistake.

Students sometimes assume that using an engine means they must recreate everything themselves.

That isn't necessary.

There is little value in spending weeks writing a rendering engine when the interesting problem is opponent behaviour.

There may be no need to develop your own collision detection from first principles simply because Unreal contains one.

Instead, distinguish between:

engine functionality

and

student-developed functionality.

For example:

Unreal may detect that the lance collided with the opponent.

The student's program then decides:

where the lance hit;
how accurate the strike was;
the relative speed;
the stability of the lance;
armour protection;
impact score;
points awarded;
effect on balance;
whether the rider is unhorsed.

That is a perfectly sensible division of responsibility.

Marketplace Assets Aren't Automatically a Problem Either

There is another misconception worth clearing up.

The student does not necessarily have to model every horse, knight, castle, lance and tree.

In fact, doing so could become a serious distraction.

If the project is being assessed as Computer Science rather than 3D art, spending twenty hours modelling a historically accurate saddle may contribute very little to the programming evidence.

Third-party graphical, sound or animation assets can therefore be extremely useful.

But they should be clearly acknowledged.

And students should be able to say:

“This asset isn't my work.”

while also being able to say:

“This algorithm is.”

AQA's assessment requirements similarly expect students to present their technical solution clearly enough for another person to discern the quality and purpose of their coding.

The Tutor's Demonstration Must Remain a Demonstration

There is an important issue for teachers and tutors here too.

If I show students our jousting game, I want them asking questions such as:

Why did you implement the opponent this way?

Could I do it differently?

What happens when you change this variable?

Why did you use a state machine?

What other algorithm could solve the problem?

That is educationally valuable.

But I would not want a student's NEA to become a slightly modified copy of our project.

The awarding bodies require authenticated, independent candidate work. OCR's current guidance reiterates that only independent candidate work should receive credit, while AQA's candidate documentation similarly requires submitted work to be the candidate's own.

So our finished system should be inspiration rather than a solution to copy.

A particularly useful teaching method is to demonstrate a problem, discuss possible solutions and then ask:

“How would you solve it?”

The student's answer may be completely different from ours.

That is exactly what we want.

Keep the Scope Under Control

Unreal encourages ambition.

That is both one of its strengths and one of its dangers.

A student starts planning:

open-world medieval Britain;
fifty castles;
multiplayer;
historically accurate physics;
horse breeding;
character customisation;
destructible environments;
weather;
online tournaments;
200 opponents;
voice acting;
cinematic story sequences.

Six months later they have a beautiful castle entrance and no functioning tournament.

For an NEA, I would much rather see:

one arena, four opponents and five excellent computational systems

than:

an enormous medieval world containing dozens of unfinished systems.

OCR itself advises candidates to control projects with excessive scope and concentrate on something achievable within the available time.

What Could a Manageable Jousting NEA Contain?

A realistic version might have six major systems:

1. Player control

Speed, positioning, aiming and bracing.

2. Impact simulation

An original algorithm combining speed, accuracy, stability, armour and target zone.

3. Computer opponent

A state-based opponent capable of changing its behaviour.

4. Scoring

Points calculated according to successful strikes and outcomes.

5. Tournament management

Multiple opponents, progression, wins, losses and ranking.

6. Persistent data

Save and reload tournament progress.

That is already a substantial project.

Features such as weather, multiplayer and horse customisation can remain on a future development list.

Testing Becomes Much More Interesting Too

A good project should not simply demonstrate that pressing the Start button launches the game.

The algorithms themselves can be tested.

For example:

Speed	Accuracy	Stability	Expected outcome
Low	Low	Low	Weak/inaccurate strike
High	Low	High	Powerful but likely miss
High	High	High	Strong successful strike
High	High	Low	Powerful but unstable
Medium	High	High	Controlled accurate hit

Then investigate edge cases.

What happens if:

speed = 0

or:

accuracy = 100

or:

stamina = 0

or:

armour = 100

What if both riders are simultaneously unhorsed?

What if two competitors finish the tournament on identical points?

These aren't inconvenient problems.

They are opportunities to demonstrate good Computer Science.

The Report Should Explain Decisions, Not Just Show Screenshots

This is particularly important with Unreal.

Twenty screenshots of attractive medieval scenery prove very little.

A useful screenshot of a system accompanied by an explanation of:

what problem it solves;
what data enters it;
what algorithm is used;
why that algorithm was selected;
what output it produces;
how it was tested;
what was changed after testing;

is much more valuable.

The student should effectively be able to defend every important piece of the system by answering:

“Why did you do it this way?”

That is a very good test of whether the project genuinely belongs to them.

Unreal Can Actually Lead to Some Excellent A-Level Projects

Used properly, Unreal Engine opens up some fascinating possibilities beyond the typical game.

A student could develop:

a traffic simulation;
an evacuation model;
an autonomous vehicle simulation;
a predator-prey environment;
a crowd behaviour model;
an airport management simulation;
a robot navigation system;
an ecological simulation;
a projectile simulator;
a procedural maze;
an economic trading game;
a logistics simulation.

The important word here is simulation.

Once students stop thinking of Unreal simply as something that produces beautiful games and start thinking of it as an interactive environment within which algorithms operate, its potential for Computer Science becomes much clearer.

So, Can You Get a Good A-Level Project Using Unreal Engine 5?

Absolutely.

But Unreal won't earn the marks for you.

In some ways, it can actually make the project harder because the student has to demonstrate clearly where Unreal ends and their own computing begins.

A strong project might therefore be described as:

Design and development of a rule-based 3D jousting tournament simulation incorporating player input, computer-controlled opponent behaviour, impact modelling, ranking, progression and persistent data.

The weaker description remains:

I made a jousting game in Unreal.

The distinction isn't just in the wording.

It reflects two completely different approaches to the project.

One concentrates on what the engine can do.

The other concentrates on what the student can program.

Final Thoughts: Let Unreal Provide the World — You Provide the Computer Science

I think Unreal Engine 5 can be an excellent choice for the right A-level student.

It is exciting. It feels relevant to modern software development. It gives students an immediate visual reward when their algorithms work, and it can make quite sophisticated computational ideas tangible.

But I would repeatedly remind students of one principle:

The examiner isn't assessing Unreal Engine 5. They are assessing you.

Let Unreal draw the knights.

Let Unreal render the arena.

Let Unreal handle the camera and lighting.

But make the opponent think because you programmed it to think.

Make the tournament work because you designed its data structures.

Make the impact calculation work because you developed and tested the algorithm.

And make sure you can explain every important decision.

For an A-level Computer Science project, a relatively small game containing substantial original programming, thoughtful algorithms and excellent testing is far more valuable than an enormous, gorgeous, half-finished 3D world.

Use Unreal Engine as the stage.

Make the Computer Science the performance.