Introduction: ScratchJr Lessons and UK Primary Computing

The UK National Curriculum for Computing establishes three core pillars for primary education: Computer Science (CS), Information Technology (IT), and Digital Literacy (DL).¹ Delivering these interconnected mandates effectively requires a pedagogical tool that is both robust in its functionality and developmentally appropriate for young learners. ScratchJr, designed specifically for children aged five to seven, is widely recognised as the most effective platform for building this foundational understanding.

ScratchJr uses a graphical, drag-and-drop block interface rather than relying on text-based code.² This visual foundation ensures that the primary cognitive effort of pupils is dedicated to grasping logical concepts—such as sequencing and events—rather than struggling with reading proficiency or complex syntax.⁴ By allowing young coders to create animated stories and simple games, ScratchJr fosters problem-solving capabilities, systematic thinking, and innate creativity.⁴

Crucially for primary computing leads, the design of effective ScratchJr lessons offers a significant curriculum efficiency advantage. While the curriculum separates CS objectives (programming) and IT objectives (content creation/manipulation), ScratchJr inherently integrates them. Pupils create, manipulate, and save content (meeting IT objectives) within the environment where they apply logical instruction (meeting CS objectives).¹ This holistic approach ensures comprehensive coverage of the statutory requirements without necessitating the use of multiple, disconnected software applications. The following report details how dedicated ScratchJr lessons satisfy every element of the Key Stage 1 (KS1) Programme of Study and establish the crucial conceptual bridge for progression into Key Stage 2 (KS2). Here is a dedicated page sharing ScratchJr lesson plans.

Alternatively, if you are looking for Coding Tutor in Hertfordshire to support your children with this, I can also help.

Part I: Core Computational Thinking – Algorithms and Sequence in ScratchJr Lessons

The foundational element of the UK computing curriculum demands that pupils “understand what algorithms are; how they are implemented as programs on digital devices; and that programs execute by following precise and unambiguous instructions”.¹ ScratchJr provides a concrete environment to meet this complex mandate.

Establishing the Algorithm Concept through Unplugged Activities

Algorithms, defined as precise sets of instructions ⁷, are initially abstract concepts for primary pupils. High-quality ScratchJr lessons must therefore begin with unplugged activities—screen-free exercises using physical materials—to lower this barrier to abstraction.⁸

Using physical, printable ScratchJr blocks, pupils can engage in activities such as ‘Simon Says’ or ‘Guide a Friend’.⁹ These exercises require the pupil to physically manipulate the blocks to define a sequence of actions (an algorithm) for a peer or teacher to follow, cementing the physical process of sequencing instructions before transitioning to the digital domain.¹⁰ This concrete experience ensures pupils focus on the logic and order of the instructions, which is vital for understanding how a program must be structured.

Implementing Precise and Unambiguous Instructions

Once the concept of sequencing is established, initial ScratchJr lessons focus on programming basic movement. Pupils use the yellow triggering blocks (such as the Green Flag block) and motion blocks (Move Right, Left, Up, Down, Hop).¹¹

The core requirement that programs follow “precise and unambiguous instructions” ¹ is met by focusing instruction on the numerical parameters beneath the movement blocks. If a pupil wishes a character to move four grid squares, they must understand that they need to either stack four ‘move right’ blocks or, more efficiently, use a single ‘move right’ block and change the number parameter from 1 to 4.¹³ This exercise enforces logical reasoning about magnitude and position, directly addressing the need for unambiguous instructions.¹⁴ The Green Flag trigger block visually demonstrates that the digital device will run the instruction sequence exactly as written when the flag is tapped, confirming that programs are the implementation of algorithms.¹⁵

Contextualising the learning is key to sustained engagement. Experts often recommend basing programming units around familiar narratives, such as animating the journey described in ‘We’re Going on a Bear Hunt’.¹⁴ Such tasks provide a clear purpose for the sequence of commands, driving pupil engagement while reinforcing the computational concept.

Part II: Achieving Programming Fluency – Debugging and Prediction in ScratchJr Lessons

Fluency in computing requires pupils to not only create programs but also to critique and refine them. The KS1 curriculum mandates that pupils “create and debug simple programs” and “use logical reasoning to predict the behaviour of simple programs”.¹

Creating and Debugging within ScratchJr Lessons

ScratchJr’s visual environment inherently supports debugging. Errors (or ‘bugs’) are easy to identify because they manifest as unexpected movements or character behaviour.¹⁴ Pupils can easily detach and reorder blocks, or use the Stop block (the red end block) to halt execution for immediate testing and iterative correction.¹² Furthermore, the application includes simple Undo and Redo functions, which empower pupils to experiment freely, knowing they can easily reverse mistakes. This environment is crucial for building persistence and resilience in problem-solving—key computational thinking skills.¹⁴

A highly effective pedagogical technique involves pre-loading a project with a deliberate, simple error (e.g., a sprite moving too far, or in the wrong direction) and tasking pupils with explicit “Find the Bug!” activities.⁹ By working collaboratively to suggest fixes without physically touching the device, pupils develop a structured approach to program diagnostics, learning that debugging is an essential part of the programming process.

Logical Reasoning and Prediction

The mandate to use logical reasoning to predict program behaviour requires dedicated instruction.¹ Pupils should be regularly asked to articulate the expected outcome of a sequence—where a character will land, how it will look, or what sound it will make—before they execute the script.

For formal assessment of this logical reasoning, low-tech methods often prove superior, as they demonstrate the conceptual understanding of the algorithm abstracted away from the technical skill of using the software.¹⁶

Summative Assessment of Logical Reasoning:

• Reverse Engineer Blocks: Pupils observe the outcome of a brief ScratchJr project, then use pre-printed blocks to physically reconstruct the sequence of commands that must have created that outcome.¹⁶ If a pupil can successfully reconstruct the algorithm offline, they have demonstrated robust conceptual understanding and met the rigorous expectation of using logical reasoning.
• Circle the Blocks: A simpler assessment where pupils identify only which specific programming blocks were used in a project, without needing to sequence them.¹⁶

Part III: Control Flow Fundamentals – Events and Simple Iteration in ScratchJr Lessons

As pupils progress in their programming journey, they must move beyond linear sequencing to control the flow of their programs, introducing the fundamental concepts of events and repetition.

Events as Triggers: Cause and Effect

Events are the mechanism by which actions are triggered in response to specific conditions. ScratchJr simplifies this concept using four main triggering blocks, represented by the yellow category ¹²:

1. Start on Green Flag: Starts the program globally.¹⁵
2. Start on Tap: Starts the script when the character is tapped (immediate cause and effect).¹²
3. Start on Bump: Starts the script when the character touches another character.
4. Start on Message: Starts the script when a message of a specified colour is received.

The use of the ‘Start on Tap’ block is particularly effective in early ScratchJr lessons for demonstrating the event-driven programming paradigm: “If I tap this, then this sequence runs.” This establishes a clear understanding of cause and effect in computing.¹⁸

Simple Iteration (Repetition)

The introduction of simple iteration is achieved through the Repeat control block, found in the orange category.¹² This block allows a sequence of instructions to be run a specified number of times.

Expert ScratchJr lessons strategically introduce the Repeat block to teach the computational thinking skill of abstraction—the ability to identify patterns and generalise a solution.¹⁴ For example, when making a character walk back and forth ten times, pupils quickly discover the inefficiency of stacking twenty individual move blocks. They learn that using the Repeat block with a numerical parameter (the number of iterations) is a much more efficient, abstract solution.¹³ Activities such as “Dribble a Basketball” or “Dance Party” provide immediate, engaging contexts for applying repetition.¹⁹

Mastering the simple Repeat block in KS1 is the direct conceptual prerequisite for understanding more complex loop structures (such as for or while loops) introduced in KS2 programming units, thereby ensuring a seamless conceptual transition.²⁰

Part IV: Information Technology – Creating and Manipulating Digital Content

The curriculum requires pupils to “use technology purposefully to create, organise, store, manipulate and retrieve digital content”.¹ ScratchJr fully embeds these Information Technology objectives within the programming environment.

Content Creation and Manipulation

ScratchJr allows pupils to create and manipulate two primary forms of digital content: visual and audio.

Visual Content Manipulation: The built-in Paint Editor enables pupils to customise characters (sprites), draw new characters, modify backgrounds, and even import external photographs.⁶ This practical, creative exercise directly addresses the mandate to ‘create’ and ‘manipulate’ visual digital content.¹

Audio Content Manipulation: The ‘Play Recorded Sound’ block allows pupils to record their own voices for character dialogue, add sound effects, or record simple musical snippets.⁶ By incorporating their own voices, pupils are actively manipulating digital audio content, making the project highly personal and engaging.

Organisation, Storage, and Retrieval

Digital literacy requires effective content management. ScratchJr lessons inherently teach content organisation and storage:

• Storage and Retrieval: The native project saving function ensures pupils practice the act of storing and retrieving their digital work.¹
• Organisation through Pages: Complex narrative projects (e.g., a story with scene changes) require the use of multiple pages.³ This introduces a fundamental data organisation structure, where content is sequentially ordered, allowing pupils to manage digital content across distinct scenes.¹⁹

The pedagogical power of ScratchJr lies in its ability to combine these objectives: when a pupil customises a sprite in the editor (manipulating content) and then uses programming blocks to define its actions (programming), they are demonstrating digital fluency—the practical and purposeful application of IT skills toward an algorithmic goal.

Part V: Digital Literacy and E-Safety – Contextualising ScratchJr Lessons

The final element of the KS1 curriculum covers Digital Literacy, requiring pupils to “recognise common uses of information technology beyond school” and “use technology safely and respectfully, keeping personal information private”.¹

Recognising Common Uses of IT

By coding interactive projects, pupils link the programming concepts they learn to the functionality of digital media they encounter outside school.²² Project ideas such as creating an animated race game, designing a digital birthday card, or animating a joke or story ¹³ demonstrate how programming, sequencing, and event triggers underpin common applications and digital experiences. Since ScratchJr is typically run on tablets, pupils implicitly understand that their creation functions as a digital ‘app’ that executes a program.¹⁴

Using Technology Safely and Respectfully

Meeting the e-safety mandate requires moving beyond passive advice. ScratchJr lessons provide a unique, active platform for teaching safe online behaviour.

E-Safety Scenario Coding: Teachers can design scenario-based ScratchJr lessons where pupils code a character, representing their ‘digital self,’ to navigate a virtual playground or maze.²³ Pupils use the ‘Say’ block (Looks category) to program their character to verbalise critical safety messages, such as explaining why they shouldn’t share their full name or private information.²³ They can also code a trusted adult sprite and use messaging blocks to guide their digital self to that character when concerns arise. This pedagogical approach transforms abstract e-safety concepts into a concrete, creative, and memorable exercise, significantly enhancing pupil retention and contextual understanding of digital respect and privacy.²³

Key Stage 1 Computing National Curriculum Alignment with ScratchJr Features

The following table provides a definitive, objective-by-objective map demonstrating how ScratchJr satisfies the statutory requirements for the Key Stage 1 Programme of Study.¹

Key Stage 1 Computing National Curriculum Alignment with ScratchJr Features

UK NC Objective (Key Stage 1)	ScratchJr Feature / Block	Pedagogical Application in ScratchJr Lessons	Citations
Understand algorithms; programs follow precise instructions.	Sequencing of Motion, Looks, Sound blocks; Green Flag start.	Creating unambiguous step-by-step animations (e.g., guide a character through a maze or dancing routine), adjusting numerical parameters for precision.	1
Create and debug simple programs.	Drag-and-drop interface; Stop Block; Undo/Redo function; Iterative Testing.	Identifying and correcting misplaced blocks or incorrect parameter values; developing resilience in program refinement.14	1
Use logical reasoning to predict program behaviour.	Reverse Engineering Blocks activity; Pre-testing sequences; Unplugged prediction.	Articulating the expected outcome of a sequence before execution; formally evaluating program logic using offline methods.	1
Use technology to create, organise, store, manipulate digital content.	Paint Editor; Record Sound Block; Import photos; Project saving/retrieval; Multiple pages (scenes).	Customising characters and recording dialogue; managing multi-scene projects and saving work.	1
Recognise common uses of IT beyond school.	Creating animated stories, race games, and visual media (e.g., animated cards).	Linking programming concepts to the functionality of common apps and digital entertainment experiences.	1
Use technology safely and respectfully, keeping personal information private.	Dialogue (Say block) and Scenario Coding.	Coding characters to role-play safe behaviour and identify trusted adult sprites for help and support.	1

Part VI: Bridging the Gap – Preparing Primary Pupils for Key Stage 2 Concepts (Advanced ScratchJr Lessons)

While ScratchJr is designed for KS1, its usefulness extends to Year 3 pupils by serving as a conceptual incubator for the more abstract and complex concepts required in KS2 programming (e.g., selection and variables).²⁰ Since ScratchJr intentionally omits built-in blocks for variables and formal selection statements to maintain simplicity ²⁵, advanced ScratchJr lessons must teach pupils to creatively simulate these concepts.

Simulating Selection (Conditionals)

Selection (or conditional logic) requires a program to make a decision: “If X happens, then do Y.”

Methodology: The ‘Start on Bump’ yellow block is the primary mechanism for simulating a basic IF-THEN statement.²⁵ A pupil can program character A to run a script (“jump”) only if it is touched by character B. This establishes the fundamental conditional logic (“If character B bumps A, then A jumps”).²⁵

Application: This simulation is essential for creating simple interactions in games, such as mazes or challenges where reaching a certain object triggers a change, providing a concrete precursor to the formal if-then blocks encountered in later primary coding platforms.

Simulating Variables (Counters and Scoring)

Variables are abstract storage locations for data (such as a score or health total).²⁶ For younger primary pupils, this abstraction can be challenging.

Methodology: Variables are simulated visually to make the concept concrete.²⁵ This requires drawing a numbered scale (e.g., 0 to 6) onto the background. A dedicated sprite, such as an arrow, is programmed to act as the ‘pointer’ for the current score. Messages are then used to move the arrow along the scale (e.g., sending a ‘Score Increase’ message triggers the arrow sprite to move one step to the right).²⁵

This visual counter is highly effective because it grounds the abstract concept of numerical data storage in a tangible, movable object. When pupils eventually transition to KS2 concepts involving numerical variables (e.g., ‘Variables in games’ in Year 6 ²⁰), the cognitive load is significantly reduced because they are learning new syntax (e.g., SET score TO 0) for an already familiar concept (the counter).

Advanced Event Handling (Message Passing for Synchronisation)

As animations and stories become more complex, pupils need to synchronise actions between multiple sprites, ensuring, for instance, that one character waits for another to finish speaking before replying.

Methodology: This is achieved using the colour-coded ‘Send Message’ and ‘Start on Message’ blocks (often referred to as envelopes).¹² Sending a message allows one sprite to trigger the script of a completely different sprite.¹²

Application: This technique is crucial for managing complex dialogue and scene transitions.³ It prepares pupils for the concept of ‘broadcasting’ in Scratch 3.0 ²⁸, demonstrating how messages facilitate coordination across different program threads.

By explicitly teaching these simulation techniques in advanced ScratchJr lessons, educators strategically pre-empt the cognitive challenge of KS2 programming. When Year 3 pupils encounter formal selection structures and data variables ²⁰, they are merely refining the notation for computational concepts they have already mastered visually.

Simulating Key Stage 2 Concepts using ScratchJr

The table below outlines the advanced pedagogical strategies required for curriculum leaders to confidently claim ScratchJr supports continuous progression into Key Stage 2.

Simulating Key Stage 2 Concepts using ScratchJr

KS2 Foundational Concept	UK NC Element	ScratchJr Simulation Method	Relevant Blocks and Pedagogical Goal	Citations
Selection (Conditionals)	Use of logical reasoning, control flow based on conditions.	‘Start on Bump’ event as a basic IF-THEN trigger.	Yellow ‘Bump’ Block. Triggers an action upon collision, simplifying conditional logic for KS1 game mechanics.	25
Variables (Data Storage)	Storing and manipulating numerical values (e.g., scoring).	Visual Counter: Draw a numeric scale as a background; program a separate sprite (arrow) to move based on message triggers.	Message Passing Blocks (Send/Receive), Motion Blocks. Provides a concrete, visual representation of abstract data manipulation.	25
Advanced Event Handling	Controlling character interactions and timing across programs.	Colour-Coded Messaging (Envelopes) for synchronised communication between sprites.	Yellow Start/Send Message Blocks (multiple colours). Necessary for complex, multi-character storytelling and dialogue pacing.	12

Part VII: Pedagogical Implementation and Assessment of ScratchJr Lessons

To maximise the effectiveness of ScratchJr lessons, a structured and concept-focused pedagogical approach is necessary, ensuring that computational thinking skills are developed alongside programming skills.

Structuring the Expert ScratchJr Lesson

Effective ScratchJr lessons should consistently follow a framework that moves logically from concrete activity to digital application:

1. Unplugged Warm-up: Introduction of the concept (e.g., sequencing, repetition) using physical materials.²¹
2. Clear Learning Intentions (LIs): Focusing objectives on the conceptual goal, such as “We are learning to code a story” or “We are learning to follow instructions,” rather than merely using a specific block.²¹
3. Coding Tutorial: Guided introduction to the relevant ScratchJr blocks.
4. Independent Practice/Extension: Pupils apply the concept in an independent project (e.g., creating a gymnastics routine or a race game).¹³
5. Plenary: Review and discussion of learning outcomes and problem-solving strategies.²¹

Fostering Computational Thinking (CT) Skills

ScratchJr lessons are crucial vehicles for embedding holistic CT skills ¹⁴:

• Decomposition: Pupils learn to break down a large, complex task (e.g., animating a story) into manageable parts—separate characters, distinct scenes (pages), and individual scripts.⁹
• Pattern Recognition: The identification of repeated movements that can be efficiently coded using the Repeat block is a clear application of pattern recognition and generalisation.¹⁴
• Logical Reasoning: This is continually applied through the processes of prediction and testing during iterative refinement.¹⁴

Collaborative Learning and Sharing

The sharing of digital creations is integral to digital literacy. ScratchJr encourages children to share their creations with peers, fostering a sense of community and providing opportunities for collaborative constellations.⁵ Furthermore, activities that encourage pupils to remix and build upon each other’s projects promote digital collaboration and reinforce the persistence and resilience needed when facing programming challenges.¹⁴

Conclusion: Maximising the Impact of UK-Aligned ScratchJr Lessons

The analysis confirms that ScratchJr provides exhaustive coverage of the UK Key Stage 1 Computing National Curriculum. The platform’s visual and intuitive design successfully addresses all statutory mandates across Computer Science, Information Technology, and Digital Literacy.¹

From establishing the fundamental concept of an algorithm through precise and unambiguous sequencing, to developing logical reasoning via prediction and debugging activities, ScratchJr provides the necessary tools for effective foundational programming education. Furthermore, its capacity to integrate IT objectives—such as manipulating audio and visual content and organising multi-page projects—seamlessly into the programming context streamlines curriculum delivery. The crucial alignment with the digital literacy requirement, especially through E-safety scenario coding, ensures pupils become active, responsible participants in the digital world.

For curriculum leaders, the highest value of ScratchJr lessons lies in their power to establish a robust conceptual pathway to KS2. By intentionally incorporating advanced lessons that simulate selection (via the ‘on bump’ event) and variables (via the visual counter and message passing), pupils arrive at Year 3 with conceptual mastery of control flow and data storage. This preparation effectively minimizes the cognitive hurdles associated with transitioning to text-based syntax in Scratch 3.0 and beyond, ensuring a smooth and successful primary computing journey.

Works cited

1. National Curriculum – Computing key stages 1 to 2 – GOV.UK, accessed on November 22, 2025, https://assets.publishing.service.gov.uk/media/5a7c576be5274a1b00423213/PRIMARY_national_curriculum_-_Computing.pdf
2. ScratchJr – Home, accessed on November 22, 2025, https://www.scratchjr.org/
3. Animated Genres Classroom Curriculum for Grades K-2 – ScratchJr, accessed on November 22, 2025, https://www.scratchjr.org/curricula/animatedgenres/full.pdf
4. Building Creativity Through Coding Activities of ScratchJr in Early Childhood – Portal Jurnal Universitas Negeri Jakarta, accessed on November 22, 2025, https://journal.unj.ac.id/unj/index.php/jpud/article/download/55194/21302/174479
5. ScratchJr Coding Space Adventure with Fun Music – YouTube, accessed on November 22, 2025, https://www.youtube.com/watch?v=gQrU4bdAS6k
6. Computing – Becket Primary School, accessed on November 22, 2025, https://www.becketprimary.co.uk/page/?title=Computing&pid=136
7. Understand what algorithms are; how they are implemented as programs on digital devices – Dobcroft Infant School, accessed on November 22, 2025, https://www.dobcroft-inf.sheffield.sch.uk/serve_file/24373095
8. Editable & Printable Scratch Jr Blocks – iCompute, accessed on November 22, 2025, https://www.icompute-uk.com/news/editable-printable-scratchjr-blocks/
9. Scratch Jr. Cards – Offline coding activity – Science World, accessed on November 22, 2025, https://www.scienceworld.ca/resource/scratch-jr-cards-line-coding-activity/
10. Scratch Jr Blocks – CS Unplugged – iCompute, accessed on November 22, 2025, https://www.icompute-uk.com/news/scratch-jr-blocks/
11. Lesson 1: Instructions, Sequencing, and an Introduction to ScratchJr, accessed on November 22, 2025, https://www.scratchjr.org/curricula/animatedgenres/1.pdf
12. Blocks – ScratchJr – Learn, accessed on November 22, 2025, https://www.scratchjr.org/learn/blocks
13. Using Scratch Jr to introduce coding to KS1? – Hyett Education, accessed on November 22, 2025, https://www.hyetteducation.com/blog/using-scratch-jr-to-introduce-coding-to-ks1
14. KS1 Computing with Scratch Jr – iCompute, accessed on November 22, 2025, https://www.icompute-uk.com/news/computing-scratch-jr/
15. Kids Coding Lesson 1: Learn Scratch Jr Commands & Sequences with Tic – YouTube, accessed on November 22, 2025, https://www.youtube.com/watch?v=4TPxUGPX6j0
16. KS1 Programming – STEM Learning, accessed on November 22, 2025, https://www.stem.org.uk/resources/library/collection/359493/ks1-programming
17. Events in Scratch Jr. – CS Concepts – Google Sites, accessed on November 22, 2025, https://sites.google.com/virginia.edu/csconcepts/cs-concepts/events/scratch-jr
18. Exploring Events in Scratch Jr. – Tuolumne County Superintendent of Schools, accessed on November 22, 2025, https://www.tcsos.us/resources/lesson-library/exploring-events-in-scratch-jr/
19. Teach – ScratchJr, accessed on November 22, 2025, https://www.scratchjr.org/teach
20. The Computing Curriculum | Key Stage 2 | Ages 7-11 – Raspberry Pi Foundation, accessed on November 22, 2025, https://www.raspberrypi.org/curriculum/key-stage-2
21. ScratchJr Lessons – Mr Morrison, accessed on November 22, 2025, https://mrmorrison.co.uk/scratchjr/
22. 101 Guide to Scratch Jr for Younger Kids – Codingal, accessed on November 22, 2025, https://www.codingal.com/coding-for-kids/blog/guide-to-scratch-jr/
23. How to Use Coding to Teach Kids About Internet Safety – Scratch Jr, accessed on November 22, 2025, https://workbookscratchjr.com/tips/how-to-use-coding-to-teach-kids-about-internet-safety
24. Key Stage 2 – Teach Computing, accessed on November 22, 2025, https://teachcomputing.org/curriculum/key-stage-2
25. Is it possible to use variables in ScratchJr? – ScratchJr Fun, accessed on November 22, 2025, https://scratchjrfun.com/variables-in-scratchjr/
26. Using Variables in Scratch Jr Desktop (Where Applicable), accessed on November 22, 2025, https://workbookscratchjr.com/tips/using-variables-in-scratch-jr-desktop-where-applicable
27. Using Message Passing in Scratch Jr Desktop, accessed on November 22, 2025, https://workbookscratchjr.com/tips/using-message-passing-in-scratch-jr-desktop
28. National Curriculum – Key Stage 1: • understand what, accessed on November 22, 2025, https://www.gems-salford.co.uk/documents/curriculum/computing/computing-progression.pdf