Computing Curriculum KS2 and KS1: A Year-by-Year Breakdown
The computing National Curriculum is short. Fewer than 200 words for all of Key Stages 1 and 2 combined. It tells you what to teach but gives you almost nothing on when to teach it or what progression should look like year by year.
That is a problem. The curriculum says pupils should "design, write and debug programs that accomplish specific goals" and "use sequence, selection, and repetition in programs." But it does not specify which year group should learn selection, or when variables should be introduced, or what "debug" looks like for a Year 2 pupil versus a Year 5 pupil.
The result is that many schools either spread everything too thin (a bit of everything every year, with no depth) or leave the harder concepts to Year 5 and 6, by which point there is not enough time to teach them properly.
This guide maps the computing curriculum across all six primary year groups. It breaks the broad curriculum statements into year-specific expectations and recommends workshops that support each stage. Use it as a starting point for your own progression model, or adapt it to fit your school's existing scheme of work.
Year 1
What Pupils Should Learn
Computer science: Understand what algorithms are. Know that algorithms are step-by-step instructions that tell someone (or something) what to do. Follow simple algorithms given by a teacher. Create their own simple algorithms for everyday tasks (getting dressed, making a sandwich).
Programming: Use simple floor robots or apps to enter a short sequence of instructions. Predict what a simple programme will do before running it. Understand that the order of instructions matters.
Information technology: Use technology purposefully to create, organise, and store digital content. For example: type short sentences, take a photograph, record a sound.
Digital literacy: Understand basic rules for staying safe online. Know that personal information should not be shared. Recognise that technology is used at home and school for different purposes.
What This Looks Like in Practice
Year 1 computing is about laying foundations. Pupils do not need laptops for every lesson. Unplugged activities work brilliantly here. Giving a partner instructions to navigate around the classroom, creating pictorial algorithms for making toast, sorting instruction cards into the correct sequence. These activities build the conceptual understanding that underpins everything that follows.
When technology is used, keep it simple. Floor robots (like Bee-Bots) let pupils enter short sequences of commands and see immediate results. The debugging happens naturally: the robot goes the wrong way, so pupils must find and correct the mistake.
Recommended Workshop
Early Engineering (EYFS/KS1): Introduces sequencing and simple instructions through hands-on building challenges. Pupils follow and create step-by-step processes, making the link between algorithms and real-world tasks.
Year 2
What Pupils Should Learn
Computer science: Create and debug simple programs. Understand that programs execute instructions in a specific sequence. Use logical reasoning to predict the behaviour of simple programs.
Programming: Write simple programs that produce a specific outcome (e.g., a floor robot moving to a target location). Test programmes and identify when they do not work as expected. Fix errors by changing the sequence of instructions.
Information technology: Use technology to create simple digital content. Begin to organise and retrieve digital work (saving files, finding saved work).
Digital literacy: Follow school rules about using technology safely. Understand that some websites and apps are not suitable for children. Know how to tell a trusted adult if they see something that upsets them online.
What This Looks Like in Practice
Year 2 builds on Year 1 by introducing the concept of debugging explicitly. Pupils should be able to look at a sequence of instructions, predict what will happen, test it, and then identify and fix the error. This is logical reasoning in its most basic form.
Programming activities should produce clear, testable outcomes. "Programme the robot to reach the treasure" is better than "play with the robot," because it gives pupils a specific goal against which they can evaluate their programme.
The key vocabulary pupils should be using confidently by the end of Year 2: algorithm, instruction, sequence, programme, debug, predict.
Recommended Workshop
STEMbotics Beginner: Pupils programme robots to follow routes and complete challenges. Sequencing and debugging are taught through guided tasks with clear success criteria. Sessions are differentiated for Year 1 and Year 2 abilities.
Year 3
What Pupils Should Learn
Computer science: Design and write programs that use sequence, selection (if/then), and repetition (loops). Use logical reasoning to detect and correct errors in algorithms and programs. Understand that programmes can be planned before they are written.
Programming: Write programmes in a block-based environment (e.g., Scratch) that include simple selection statements (if something happens, do this) and repetition (repeat a set of instructions a given number of times). Plan programmes using written algorithms or flowcharts before coding.
Information technology: Use technology to collect and present data. Create simple charts or graphs using digital tools. Begin to use the internet for directed research.
Digital literacy: Understand that not all information online is accurate. Begin to evaluate the reliability of websites. Understand the basic rules of copyright (not everything online is free to use).
What This Looks Like in Practice
Year 3 is where computing starts to feel like computer science rather than "using technology." The introduction of selection and repetition marks a significant jump in complexity. Pupils are no longer just writing linear sequences of instructions; they are writing programmes that make decisions and repeat actions.
This is the year where screen-based programming becomes essential. Floor robots cannot handle selection and repetition in a meaningful way. Scratch (or a similar block-based environment) gives pupils the tools to build programmes with these structures.
The planning stage is critical. Pupils who jump straight into Scratch without planning their programme on paper will produce messy, unfocused code. Teach them to write their algorithm first (using pseudocode or a simple flowchart), then translate it into blocks.
Recommended Workshop
STEMbotics Intermediate: Introduces selection and repetition through programmable robots that respond to conditions. Pupils programme robots to make decisions based on sensor inputs, making abstract concepts tangible.
Year 4
What Pupils Should Learn
Computer science: Use selection (if/else) and repetition in programmes with increasing confidence. Work with variables (a named value that can be changed within a programme). Understand how simple computer networks work, including the internet.
Programming: Write programmes that use variables to keep score, track a count, or store user input. Use if/else statements to create programmes with two or more possible outcomes. Use definite and indefinite loops appropriately. Debug programmes by tracing through the code logically.
Information technology: Use technology to create content that combines text, images, and sound. Begin to understand how data is stored and retrieved.
Digital literacy: Understand how to report concerns about online content or contact. Recognise the difference between personal and private information. Understand that online actions have real-world consequences.
What This Looks Like in Practice
Variables are the big new concept in Year 4. A variable is a named container that stores a value, which can be changed as the programme runs. In Scratch, this is how you keep score in a game or count how many times something happens.
Many teachers find variables the hardest concept to teach because it is abstract. Make it concrete first. Use an unplugged activity: write a number on a whiteboard, call it "score," and change it as things happen. Then move to Scratch and show pupils how a variable block does the same thing.
Networks are also introduced here. Pupils should understand at a basic level that computers can be connected (a network), that the internet is a global network, and that information travels between computers on the network. This does not require detailed technical knowledge, but pupils should be able to explain the basic idea.
Recommended Workshop
Cybersecurity: Covers networks, data, and security in an age-appropriate way. Pupils learn how information travels across networks and how encryption protects it. Directly supports Year 4 objectives on understanding computer networks.
Year 5
What Pupils Should Learn
Computer science: Design programmes that accomplish specific goals. Decompose problems into smaller parts. Use sequence, selection, and repetition confidently. Work with various forms of input and output. Understand how computer networks can provide multiple services.
Programming: Design and write programmes with clear objectives. Use inputs (keyboard, mouse, sensors) and outputs (screen, sound, movement) in their programmes. Decompose complex tasks into sub-tasks and implement them as separate sections of code or separate programmes. Test programmes systematically, not just running them once and hoping.
Information technology: Use technology to create increasingly complex digital content. Select appropriate software for different tasks. Use spreadsheets to organise and analyse data.
Digital literacy: Use search engines effectively and understand that results are ranked algorithmically. Understand the basics of how personal data is collected online. Evaluate online content critically.
What This Looks Like in Practice
Year 5 is about applying everything learned so far to more complex problems. The key skill is decomposition: breaking a big problem into smaller, manageable parts. This is how real programmers work, and it is a skill that transfers far beyond computing.
For example, if the task is "create a quiz game in Scratch," a Year 5 pupil should be able to decompose this into: create a start screen, display a question, accept user input, check the answer, update the score, display the next question, show the final score. Each sub-task becomes a section of code.
Inputs and outputs become more varied. Rather than just keyboard and screen, pupils can work with sensors, microphones, cameras, and physical computing devices. This is where robotics workshops and drone programming add real value, because they introduce hardware inputs and outputs that are difficult to replicate in a standard classroom.
Recommended Workshop
STEMbotics Advanced: Pupils programme robots using sensor inputs (light, sound, distance) and multiple outputs (movement, display, sound). Sessions require decomposition and systematic testing, directly supporting Year 5 objectives.
Year 6
What Pupils Should Learn
Computer science: Design and create programmes that solve specific problems. Use logical reasoning to explain how increasingly complex algorithms work. Solve problems by decomposing them into smaller parts. Understand how search engines use algorithms to select and rank results.
Programming: Create programmes that combine sequence, selection, repetition, variables, and inputs/outputs to solve real problems. Use logical reasoning to test, debug, and refine programmes. Evaluate their own programmes against specific criteria. Work collaboratively on programming projects.
Information technology: Use a range of software confidently and appropriately. Create content for a specific audience and purpose. Understand that digital content can be reused, repurposed, and shared.
Digital literacy: Understand the opportunities and risks of using the internet and digital technology. Evaluate the reliability and bias of online content. Understand the concept of digital footprint. Use technology responsibly and ethically.
What This Looks Like in Practice
By Year 6, pupils should be fluent programmers in at least one block-based environment. They should be able to look at a problem, decompose it, design an algorithm, implement it as a programme, test it, debug it, and evaluate it. This is the full design cycle applied to computing.
Search engine algorithms are a specific objective. Pupils should understand, at a basic level, that search results are not random. They are selected and ranked by algorithms that consider factors like relevance, popularity, and recency. This links well to digital literacy objectives about evaluating online content.
Year 6 pupils should also be able to explain their computing knowledge verbally. If an Ofsted inspector asks a Year 6 pupil "what is an algorithm?" and the pupil can define it clearly, give an example, and explain why it matters, that is a good sign. If the pupil says "it's something on Scratch," the provision has not worked.
Recommended Workshop
AI and Machine Learning: Pupils explore how algorithms process data, make predictions, and improve over time. Directly addresses the Year 6 objective on understanding how results are selected. Pupils build simple ML models, connecting computing theory to real-world application.
Summary Table: Year Group, Key Objectives, and Recommended Workshops
Year Group | Key Computing Objectives | Recommended Workshop
Year 1 | Algorithms as step-by-step instructions. Simple sequencing. Predicting programme behaviour. | Early Engineering
Year 2 | Creating and debugging simple programmes. Logical reasoning to predict outcomes. | STEMbotics Beginner
Year 3 | Sequence, selection, and repetition. Detecting and correcting errors. Planning before coding. | STEMbotics Intermediate
Year 4 | Variables. If/else statements. Understanding computer networks. | Cybersecurity
Year 5 | Decomposition. Inputs and outputs. Systematic testing. Complex programmes. | STEMbotics Advanced
Year 6 | Problem-solving through programming. Search engine algorithms. Evaluating programmes. | AI and Machine Learning
Download the Full Progression Map
We have created a downloadable version of this progression map that includes additional detail on vocabulary expectations for each year group, suggested unplugged activities, and recommended software tools.
Download the Computing Progression Map [link]
How Workshops Fit Into Your Computing Provision
A point worth making clearly: workshops are not a substitute for weekly computing lessons. Your pupils need regular, sustained computing teaching throughout the year. That is where schemes of work like the Teach Computing Curriculum come in.
What workshops do is provide enrichment that covers the parts of the curriculum most schools find hardest to deliver: physical computing, real-world applications of algorithms, cybersecurity, AI, and advanced programming with hardware.
Think of it this way. Your weekly computing lessons are the curriculum. A STEM day with computing workshops is the enrichment that makes the curriculum come alive.
If you want to discuss how our workshops map to your school's specific computing provision, get in touch. We are happy to look at your curriculum and recommend the workshops that fill your gaps.
