Search every subject world, from Preschool to Grade 12. The first five courses of every subject path are free.
120 courses
Coding · Preschool
With Olly, children notice that doing something makes something happen: water a seed and it grows, push a ball and it rolls, tap an arrow and Bolt the robot moves. They practise predicting what will happen next and play a 'Robot, robot!' game with a grown-up.
Coding · Preschool
Children learn the words first, next and last, put picture steps of familiar routines in order (plants, butterflies, hand washing) and discover with Olly that some steps only work in the right order. Sequencing is the first big idea of programming.
Coding · Preschool
Children follow two-step instructions with Olly, then give Bolt the garden robot two arrow instructions to reach its charging pad. They discover that the order of two instructions can matter when a hedge is in the way.
Coding · Preschool
Children read picture steps from left to right, one at a time: a fruit-bowl recipe, a clap-and-stomp picture code and arrow pictures for Bolt the robot. They follow each sequence exactly and copy arrow pictures into blocks.
Coding · Preschool
Children spot picture plans with a gap, choose the missing step by looking at the picture before and after, and fix Bolt the robot's programs by adding the missing arrow. This is their first taste of debugging: finding and fixing a problem.
Coding · Preschool
Children plan routes of two or three arrows for Bolt the robot, test them by running and looking carefully at where Bolt stops, and fix routes that bump or stop short. A floor-grid game lets them be the robot.
Coding · Pre-K
Children learn that every sequence has a goal. They match everyday sequences to their goals, build longer arrow sequences that take Bolt the robot to its charging pad, and check sequences step by step to see whether they really reach the goal.
Coding · Pre-K
Children notice actions that happen again and again, count how many times they repeat, and say it the short way: repeat 3 times: hop. Then they use Bolt's repeat block to move the robot many squares with just a few blocks.
Coding · Pre-K
Children find two different routes to the same goal, count the steps on each to find the shorter one, and choose a route that goes around a problem such as a puddle or a hedge. Bolt the robot tests every choice.
Coding · Pre-K
Children hunt for the one wrong step, or bug, in everyday plans and in Bolt the robot's programs. They follow programs step by step to see where things first go wrong, then change just the wrong instruction to fix it.
Coding · Pre-K
Children learn Olly's planning routine (look, trace and say the plan, build, run and check). They predict where Bolt the robot will stop before running, plan routes that collect a gem, and compare what happened with their plan.
Coding · Pre-K
Children learn the word algorithm (steps in order that finish a job), make their own picture algorithms by choosing helpful pictures and ordering them, and test them by asking a grown-up to follow them exactly, then improve what did not work.
Coding · Kindergarten
Kindergartners learn to break a big job into small, numbered steps and to use first, next, then and last. They plan Bolt the robot's routes before building them, including routes that must collect gems before the charging pad counts.
Coding · Kindergarten
Kindergartners discover that the routines they follow every day (washing hands, tidying up, getting dressed) are algorithms. They decide which steps must stay in order and which can swap, and compare two algorithms for the same job to choose the clearer, complete, shorter one.
Coding · Kindergarten
Kindergartners learn the four arrow blocks, read short block programs by moving a finger one square per block, and build their own programs that steer Bolt the robot around hedges and over gems to the charging pad.
Coding · Kindergarten
Kindergartners find the part of a sequence that repeats, including groups such as clap-stomp or up-right, write it the short way (repeat 3 times: up, right), and use Bolt's repeat block to climb staircases and cross long gardens with only a few blocks.
Coding · Kindergarten
Kindergartners learn three kinds of bugs (missing, extra and wrong steps), find the first block that sends Bolt the wrong way by stepping through a program, and fix bugs and test again until the program works.
Coding · Kindergarten
Kindergartners learn that in an interactive story the reader's taps are events that make things happen. They plan a story with a beginning, a choice and an ending for each choice, and explain how it works using first, if you tap, then. They make story cards to share at home.
Coding · Grade 1
First graders read block programs from top to bottom, put blocks in order to make a character say and do things, and predict what a program will do before running it. They check predictions by running programs and tracing again when a prediction is wrong.
Coding · Grade 1
First graders learn that an event, such as a click, a key press or the green flag, starts a script. They match events to scripts in programs with several scripts, predict what happens when events occur, and build their own event scripts for Olly.
Coding · Grade 1
First graders replace repeated blocks with repeat loops, trace programs with loops to predict what happens inside and after the loop, and use loops to do useful work for Bolt the robot: staircases, long snaking paths and rows of gems.
Coding · Grade 1
First graders learn that a character's state is what is true about it right now: its costume, position, direction and score. They trace programs to find the state at the end, and use forward and turn blocks, whose result depends on which way Bolt the robot is facing.
Coding · Grade 1
First graders make a trace of a program, recording Bolt's row, column and direction after each block. They compare traces with plans to find the first wrong block (which may come before the bump), and fix bugs in programs and loops, then test again.
Coding · Grade 1
First graders plan an interactive story (characters, a beginning, events and an ending), turn each event in the plan into a block script with loops where things repeat, and test the story with a partner, fixing any script that does not match the plan.
Coding · Grade 2
Second graders learn what makes an algorithm clear, complete and in order, write clear forward-and-turn algorithms for Bolt the robot, follow a real sorting algorithm (the swap algorithm) step by step, and test algorithms on several cases to find and fix problems.
Coding · Grade 2
Second graders see how an event starts a sequence of blocks, predict what programs with several event scripts do when events happen in a given order (and more than once), and build arrow-key scripts that control a character like a game.
Coding · Grade 2
Second graders decide when loops are useful, find the repeating unit in a path and choose the right repeat count, trace loops that change a value each time round, and use loops to climb staircases and patrol square paths with forward and turn blocks.
Coding · Grade 2
Second graders learn that a condition is a true-or-false question, trace if-then-else programs where only one part runs, use conditions to build sorting machines (including a two-question sort), and write their own if-then-else rules.
Coding · Grade 2
Second graders name and plot squares with coordinates (x across, y up), see how each arrow move changes x or y, and use the differences in coordinates to plan Bolt the robot's routes around hedges.
Coding · Grade 2
Second graders write test cases (an input and the expected result worked out by hand), run programs to compare actual and expected results, discover that a single passing test can hide a bug, and use a failing test with a trace to find, fix and re-test.
Coding · Grade 2
Second graders become puzzle designers for Bolt the robot. They plan a puzzle (start, pad, hedges, gems and a goal), check it is solvable and find its par (the fewest blocks), tune it to be harder or easier, and test it with a player, using feedback to improve it.
Coding · Grade 2
Second graders explain programs by giving their purpose and steps, improve programs by making them shorter (loops) and clearer (good names and comments) without changing what they do, and improve an algorithm in a guessing game by always guessing the middle.
Coding · Grade 3
Third graders decompose big tasks into sub-tasks, split long robot routes into legs programmed as loops, learn linear search (and how sorted lists let a search stop early), and compare algorithms by counting their worst-case steps.
Coding · Grade 3
Third graders learn that a variable is a named box holding one value, trace set and change blocks with trace tables, use several variables to keep a game's state (score, lives, level), and use counters inside loops to count and to build totals.
Coding · Grade 3
Third graders build programs that interact with users: clicks, keys and typed answers. They use messages (broadcast and wait, when I receive) so characters can start each other's scripts, trace programs with several characters, and design interactions with clear instructions and helpful feedback.
Coding · Grade 3
Third graders draw regular shapes with loops (repeat the sides, turn 360 divided by the number of sides), predict number patterns made by loops, use repeat until loops that stop on a condition (and spot ones that never stop), and find repeating parts in robot paths.
Coding · Grade 3
Third graders read comparisons (equal to, more than, less than), trace if-then and if-then-else blocks inside loops, use decisions to win, lose and react in games, and choose conditions that match rules exactly, testing the boundary value.
Coding · Grade 3
Third graders trace programs with trace tables, design normal, boundary and unusual test cases, learn four common bug types (off by one, boundary, wrong order, not reset), and fix bugs with a failing test, a trace and a full re-test.
Coding · Grade 3
Third graders plan and build a maze game in parts: a game plan, arrow-key controls with walls that push the player back, a gems score with a win condition and message, and playtesting to find and fix bugs such as an early win or a score that is not reset.
Coding · Grade 3
Third graders write documentation for a project (title, what it is, how to use it, known problems, credits), learn to use only their own work or work they have permission to use and to give credit, share only with a trusted adult's approval and without personal information, and give kind, specific, helpful feedback.
Coding · Grade 4
Fourth graders learn the flowchart shapes (oval, rectangle, parallelogram, diamond and arrows), follow flowcharts with decisions and loops for given inputs, and turn flowcharts into pseudocode, finishing by planning a guess-my-number program as a flowchart.
Coding · Grade 4
Fourth graders evaluate expressions with the order of operations, trace assignments that use the current values of variables (including updating a variable from itself), turn word problems into expressions with clear variable names, and test programs that use input with several values.
Coding · Grade 4
Fourth graders use IF, ELSE IF and ELSE to choose between many paths, learn that the first true condition wins (so order matters), trace nested decisions, and test every branch, including the boundaries between branches.
Coding · Grade 4
Fourth graders use counting loops (FOR i FROM 1 TO n), accumulate totals, counts and the biggest value so far, combine loops with decisions to count values that pass a test, and replace copied-and-pasted code with loops that capture the repeating pattern.
Coding · Grade 4
Fourth graders define their own blocks (functions) and call them to reuse steps, give blocks inputs so one block can do slightly different jobs, trace programs that call functions (including from loops), and use Bolt's dance block to reuse a group of moves in a robot program.
Coding · Grade 4
Fourth graders describe and change a game character's position with x and y, program arrow-key events that move it, add boundary checks that keep it on the stage, and detect when two characters meet (same x and same y) to react with a score or message.
Coding · Grade 4
Fourth graders hunt for edge cases (zero, empty input, boundaries, capitals and other unusual inputs), write test plans with expected results and reasons, use their tests to catch hidden buggy versions of a real function, and debug with a reproduce-trace-fix-retest routine.
Coding · Grade 4
Fourth graders design an original mini-game (goal, controls, rules, score, win and lose, scripts), build it from events, variables, conditions, loops, functions and messages, playtest it with planned test cases including edge cases, and explain how it works and why they designed it that way.
Coding · Grade 5
Fifth graders decompose problems into sub-problems and design pseudocode algorithms for them, compare linear and binary search by counting comparisons (and learn why binary search needs sorted data), carry out the swap (bubble) sort counting passes and swaps, and choose algorithms by weighing trade-offs.
Coding · Grade 5
Fifth graders learn the main data types (whole and decimal numbers, text and Booleans), see how + adds numbers but joins text, handle user input that arrives as text by converting it with NUMBER and TEXT, and choose sensible types and names when designing a program's data.
Coding · Grade 5
Fifth graders combine conditions with AND and OR, use NOT and Boolean variables, complete truth tables, and turn real rules into compound conditions, testing them with cases that make each part true and false.
Coding · Grade 5
Fifth graders trace nested loops (the inner loop runs completely for every time round the outer loop), use them to build rows-and-columns patterns, make growing triangle patterns by using the outer counter in the inner loop, and program robots with repeats inside repeats.
Coding · Grade 5
Fifth graders define procedures with several parameters and call them with arguments, write functions that RETURN values used in expressions, trace calls inside loops and nested calls, and decompose programs (and robot routes) into functions with one clear job each.
Coding · Grade 5
Fifth graders store values in lists, get items by position (counting from 1 in PlayOwl pseudocode) and find the length, loop through lists with FOR EACH to total, count and find the biggest, change and search lists, and answer questions from structured records in a table.
Coding · Grade 5
Fifth graders connect blocks and pseudocode to Python: print, variables with =, for loops with range, and if, elif and else marked by colons and indentation. They find and fix common syntax errors and trace short Python programs.
Coding · Grade 5
Fifth graders plan a small application (purpose, users, inputs, processing, outputs), test it with normal, edge and invalid inputs (and catch hidden bugs with a test suite), document it with a README and helpful comments, and prepare it for responsible publishing with approval, privacy, accessibility and version notes.
Coding · Grade 6
Learners discover what makes an algorithm precise, ordered and finite by programming a library delivery robot, then plan algorithms in simple pseudocode. They learn to trace step by step with a trace table, and to debug by finding the first line where a traced value goes wrong.
Coding · Grade 6
Learners meet Python's four basic types (int, float, str and bool), evaluate arithmetic expressions with the order of operations, floor division and remainder, and join and repeat strings. They practise predicting the exact output of print statements, the skill that every later trace depends on.
Coding · Grade 6
Learners see assignment as an instruction (work out the right side, then store), read user input with input() and convert it with int() and float(), format output with f-strings and choose valid, meaningful names. They finish by tracing complete programs, including the classic swap bug and its fix.
Coding · Grade 6
Learners use comparisons to ask True/False questions, trace if, elif and else to see which single branch runs, and combine conditions with and, or and not using truth tables. A reading-club badge program shows why the order of an elif chain matters and how boundary values reveal decision bugs.
Coding · Grade 6
Learners use for loops with range(), build running totals and counts with accumulators, and trace while loops that stop when a condition becomes False, including spotting infinite loops. Robot puzzles with repeat blocks show how repetition shortens programs, and learners decide when a for or while loop fits a task.
Coding · Grade 6
Learners define and call their own Python functions, follow the flow of control into and out of a function, pass arguments to parameters by position, and see the difference between returning a value and printing it. Robot puzzles with a reusable 'hop' function and a look at local variables show why functions make programs shorter, clearer and easier to change.
Coding · Grade 6
Learners store many values in Python lists, use zero-based and negative indexes, and loop over lists to total, count and find the largest value. They then test a function by comparing expected and actual results, design edge-case tests that catch hidden buggy versions, and debug using error messages, tracing and temporary prints.
Coding · Grade 6
In this project course learners plan, build, test and explain a Word Puzzle Toolkit for a school puzzle club. They decompose the application into functions, assemble and trace string-processing features with loops and conditions, design test plans that catch hidden bugs, combine everything with a menu loop, and write design notes reviewed by a teacher.
Coding · Grade 7
Using a realistic field-trip organiser, learners break a large problem into a decomposition tree, describe each piece with inputs, process and outputs, use abstraction to keep only the details that matter, and generalise repeated patterns into parameterised functions. They then order the build by dependencies, connect the parts in a short main program, and decompose a new problem in a reviewed write-up.
Coding · Grade 7
Learners extend their list skills with insert, remove, pop, slicing, in and sorting, then meet dictionaries for looking values up by key, including tallying with counts. They see how functions interact with mutable lists and dictionaries, and decide when a list, a dictionary or a combination of both best fits a task.
Coding · Grade 7
Learners discover why programs must check input, using a coding-club sign-up form that keeps crashing. They classify presence, type, range, length and format checks, write checks with string methods, build validation loops that re-ask until input is valid, handle conversion errors with try and except, and choose normal, boundary and invalid test data.
Coding · Grade 7
Learners trace linear search and binary search, counting comparisons with an interactive search tracer, and see why binary search needs sorted data. They sort lists with bubble sort pass by pass and compare algorithms by how their work grows, deciding when sorting first pays off.
Coding · Grade 7
Learners read JavaScript by comparing it with Python, then learn how event-driven programs wait for clicks and key presses and respond with handler functions. Using a small event simulator, they trace how handlers change program state, and they debug the classic event bugs: calling instead of passing a handler, = instead of ===, resetting state inside a handler and forgetting to render.
Coding · Grade 7
Learners build the structure of a coding-club web page in HTML (elements, nesting, attributes, head and body), choose semantic elements that work for keyboard and screen-reader users, style pages with CSS selectors while predicting which rule wins in the cascade, and calculate box-model sizes. Accessible design (alt text, labels, contrast and focus) runs through the whole course.
Coding · Grade 7
Learners write automated tests with assert and test functions, design test cases from a specification that catch hidden buggy versions, and follow a systematic debugging process (reproduce, isolate, fix, re-test). They finish by using version history (commits, messages, diffs and reverting) to find when a bug appeared and to keep a project safe.
Coding · Grade 7
A guided project course: learners turn an original idea into user stories with priorities, design the interface and state with an events table, build and trace JavaScript handlers using a worked example (Flashcard Flipper), and finish with a test plan, user feedback and iteration. The reviewed project plan asks each learner to design their own original application.
Coding · Grade 8
Using a community-garden booking app, learners write and classify functional and non-functional requirements and constraints, identify stakeholders, and turn vague wishes into testable Given/When/Then acceptance criteria that become code checks. They decompose the system into modules with clear responsibilities and data flow, then plan an MVP, milestones and risks, and write a reviewed mini specification for a project of their own.
Coding · Grade 8
Learners design functions that are easy for teammates to use (default and keyword arguments, docstrings, returning several values), organise code into modules and use the standard library, represent real data as lists of dictionary records with nested fields, and process records with filter, aggregate, transform and key-based sorting.
Coding · Grade 8
Learners count the basic operations algorithms perform, classify growth as constant, logarithmic, linear or quadratic from the shape of the code, and predict how running time scales. They explore trading memory for time with sets and caching, and weigh efficiency against input size, frequency, clarity and resources when choosing an approach.
Coding · Grade 8
Learners model the garden app with classes: they create objects from a class blueprint, write and trace __init__ and methods that use self, and build programs where objects contain and work with other objects, including the surprise of two variables referring to the same object. They finish by designing classes with single responsibilities, deciding which data and behaviour each class owns.
Coding · Grade 8
Learners design interface behaviour as state machines with named states, events and allowed transitions, and separate the model (state) from the view (a single render function) so the screen never disagrees with the data. They trace longer JavaScript event sequences with guards and counters, and design helpful feedback: clear status messages, disabled controls and an undo stack.
Coding · Grade 8
Learners discover how programs request data from other programs through APIs, using a local mock weather service so that no real network calls are made. They read requests, responses, status codes and JSON, parse JSON in Python, write code that checks status codes and missing fields with safe fallbacks and caching, and use APIs responsibly by protecting keys, minimising personal data and respecting limits.
Coding · Grade 8
Learners make the garden app trustworthy: they design thorough unit tests that cover normal, edge and invalid inputs and every branch, debug systematically with tracebacks, minimal failing examples and assertions, and apply secure design principles (input validation, least privilege, safe defaults, failing securely, careful error messages). They finish by seeing why passwords are stored as hashes and why data must be kept separate from commands.
Coding · Grade 8
The Grade 8 capstone course guides learners from a specification to a finished, documented and demonstrated project. They plan milestones with a checkable definition of done, write documentation for different readers (README, docstrings, comments, user guide), gather honest evidence from tests and checklists without overclaiming, and plan a clear demonstration and a reviewed reflection.
Coding · Grade 9
Learners start the game-development elective by treating games as systems of mechanics, dynamics and player experience, then judge fairness with exact probabilities and expected values computed by counting dice outcomes, find dominant strategies in payoff tables and rebalance them, and test a mechanic with a paper prototype and observed playtests, ending with a reviewed design document for an original mechanic.
Coding · Grade 9
High-school learners define algorithms precisely (finite, definite, effective, with input and output) and test procedures against that definition, including the unsolved Collatz problem as a case where testing is not proof. They represent algorithms as flowcharts and pseudocode, trace classic algorithms such as Euclid's GCD with trace tables, and decompose problems while comparing algorithms for correctness and efficiency.
Coding · Grade 9
Using a fictional boating game, learners convert between world coordinates and screen pixels, move objects with vector addition, scaling, length and normalization, transform shapes by translation, scaling and rotation about a pivot, and apply vectors to gameplay: range checks with squared distances, aiming and fixing the diagonal-speed bug.
Coding · Grade 9
Learners see how the Python interpreter runs a program statement by statement, why indentation is part of the grammar and how comments work. They control output precisely with print's sep and end, classify and locate syntax, runtime and logic errors from messages and behaviour, and use types and built-in functions, including Python's round-half-to-even rule.
Coding · Grade 9
Using a bike-share fare calculator, learners evaluate Python expressions with precedence and associativity (including floor division of negatives and right-to-left powers), use augmented and simultaneous assignment, read and convert input, and format output with f-string specifiers. They discover why floating-point arithmetic is approximate and learn practical rules: compare with a tolerance and keep money in integer cents.
Coding · Grade 9
Learners trace the input-update-render game loop frame by frame, make movement fair on every device with delta time and a fixed-timestep accumulator, organise menus, play, pause and game over as a state machine that controls which systems run, and derive pressed, held and released events from raw input, with buffering and remappable controls.
Coding · Grade 9
Built around a school weather station, the course develops selection (elif chains, nested conditions, branch order and boundaries) and Boolean logic (short-circuit evaluation and De Morgan's laws), then repetition patterns with for, while, break, continue, sentinels and nested loops. It closes with reasoning about loop correctness: termination, off-by-one errors and loop invariants.
Coding · Grade 9
Learners detect collisions between axis-aligned boxes and circles, simulate motion with velocity, gravity and Euler steps, respond to collisions by resolving overlaps and bouncing with restitution, and examine the limits of simple physics, especially tunnelling at high speed and how substeps or swept tests prevent it.
Coding · Grade 9
Learners animate sprites from elapsed time with looping and one-shot sequences, give a non-player character a patrol-chase-search-return state machine with hysteresis, find shortest paths on grids with breadth-first search and program routes with blocks, and tune behaviour so it is readable and fair through telegraphing, reaction delays and learnable patterns.
Coding · Grade 9
Using a fictional fitness-tracker app, learners trace calls between functions with the call stack, control scope by passing parameters and returning results instead of using globals, write precise contracts with preconditions and postconditions, and separate pure functions from side effects. They then design programs top-down, build them bottom-up and plan a modular program in a reviewed design task.
Coding · Grade 9
Using a school clubs fair, learners work with Python's four core collections: lists (slicing, comprehensions, enumerate), tuples (immutable records and unpacking), sets (uniqueness and set operations) and dictionaries (lookup, counting, grouping and nested data). They reason about mutability, aliasing and copies, and choose the right collection for each job.
Coding · Grade 9
Learners design levels that teach mechanics step by step and guide players through layout, read playtest data (completion rates and attempts) to find difficulty spikes, trace a bounded dynamic difficulty adjustment rule, and build accessibility into games through remapping, toggles, captions, colour-independent cues, assist options and photosensitivity safety.
Coding · Grade 9
Learners design tests with equivalence partitions and boundary value analysis, build edge-case checklists for collections and text, and write test suites that catch hidden buggy versions of real functions. They debug as an investigation (reproduce, hypothesise, predict, fix, regression-test) and use assertions and automated tests to make programs check themselves, while keeping validation for user input.
Coding · Grade 9
Learners test game rules with exact expected values, write reproducible bug reports, analyse performance against the frame budget and see how spatial grids cut collision checks, and evaluate responsible design: avoiding pay-to-win, loot boxes and dark patterns, supporting healthy play, and protecting young players' privacy and safety, ending with a reviewed responsible-design review.
Coding · Grade 9
Learners plan an original game with prioritised, estimated features and milestones, check every asset's licence and keep a credits list, release the game privately with no personal information, and write an evidence-based postmortem, ending with a reviewed final project.
Coding · Grade 9
The Grade 9 project course: learners design an interactive text program (state, command functions and a main loop), trace it through sequences of valid and invalid commands using the worked example TaskBoard, test it with normal, boundary and invalid interactions, and explain it with clear code walkthroughs. A reviewed task asks each learner to plan and explain an interactive program of their own.
Coding · Grade 10
Using a school print-credit system, learners write structured code with guard clauses instead of deep nesting, specify functions with preconditions, postconditions and clear exceptions, protect data invariants in a class, and practise defensive programming by testing both sides of each contract and checking that refusals leave state unchanged.
Coding · Grade 10
Using a makerspace tool library, learners design classes that start valid, act through well-named methods and print readably with __str__. They protect data with encapsulation (underscore conventions and validating properties), distinguish class and instance attributes and identity from equality, and build classes from others with composition (has-a) and inheritance (is-a), including overriding and polymorphism.
Coding · Grade 10
Using real-world-style air-quality, loan and sales data, learners recognise and apply the core collection patterns (accumulate, count, filter, map, any/all, find-first and best-by-key), group and index data with dictionaries and zip, and use sliding windows and two pointers to avoid repeated work. They finish by testing each pattern's characteristic edge cases, including testsuite activities against hidden buggy versions.
Coding · Grade 10
Learners describe algorithm costs with Big-O notation, trace binary search with an interactive tracer, and trace selection sort and insertion sort pass by pass. They study merge sort as divide and conquer, explaining why it is O(n log n) and stable, and use growth rates to choose between sorting once and searching many times, dictionaries and Python's built-in sort.
Coding · Grade 10
Using athletics results files, learners read and write text files safely with with and in-memory file objects, validate every record for field count, type and range while logging rejects with line numbers, handle exceptions precisely with try, except, else and finally, and assemble a robust read-validate-process-report pipeline whose summary never hides rejected data.
Coding · Grade 10
Learners discover how JavaScript's event loop runs handlers and timers one at a time, use event objects and event delegation, and manage interface state with a single state object, actions and pure update (reducer) functions. They finish by designing responsive and accessible interactions: throttling rapid clicks, preventing double submissions, keyboard support, focus management and announced status messages.
Coding · Grade 10
Learners work like a software team on a club-booking app: they use feature branches, pull requests and merges and resolve merge conflicts deliberately; write independent Arrange-Act-Assert unit tests and require tests before approving changes; give and respond to specific, kind and actionable code reviews; and use continuous integration to stop regressions reaching the main branch.
Coding · Grade 10
In this project course learners design an object-oriented solution with nouns, verbs and CRC cards, trace a worked board-game library with collaborating Game, Member and Library classes, test classes and scenarios including side effects of refusals, and plan iterative development with a design log. A reviewed task asks each learner to plan an original object-oriented project of their own.
Coding · Grade 11
Learners separate abstract data types from their implementations, specifying stacks and queues by their operations and rules, and apply them to bracket matching, browser history and print queues. They then study representation invariants through a circular-buffer queue with wrap-around indexes, and compare implementations of the same ADT to see why clients must depend only on the interface.
Coding · Grade 11
Learners compare dynamic arrays with linked lists, trace a toy hash table with buckets and collisions to see why dictionaries are fast and keys must be immutable, and build binary search trees, observing how insertion order changes their height and performance. They then choose structures for realistic workloads by comparing the costs of the operations that matter most.
Coding · Grade 11
Learners derive Big-O bounds from code by counting operations through sequences, nested loops with dependent bounds and halving loops, distinguish best, worst and average cases, and check their analysis with exact operation counts and doubling experiments rather than noisy timings. They finish with space complexity and judgement about when complexity really matters.
Coding · Grade 11
Learners build recursive solutions from base cases and smaller subproblems, tracing them with the call stack and indented call logs. They design recursive functions for palindromes, powers by halving, digit sums and lists, test them against hidden buggy versions, analyse costs with call trees (including Fibonacci's exponential blow-up and memoisation), and decide when iteration is the better choice.
Coding · Grade 11
Learners model networks (bus stops, study partners, prerequisites, roads) as directed, undirected and weighted graphs stored as adjacency lists, trace breadth-first and depth-first search, find shortest paths with BFS and Dijkstra's algorithm, and answer network questions with reachability, connected components and topological ordering.
Coding · Grade 11
Learners design and implement an API from the provider's side using a controlled, network-free club-information service: resources, methods, consistent JSON responses and status codes; a request handler that authenticates, routes, validates and authorises before acting; access control, data minimisation and rate limiting; and safe evolution with versioning, deprecation and contract tests.
Coding · Grade 11
Built around one realistic task, testing a search algorithm, this course teaches learners to trace binary search, state its input assumptions, reason about edge cases and efficiency, inspect and repair broken implementations, and design test suites that catch realistic bugs. It closes with reliability and security practices for untrusted input: validating preconditions, bounded execution, toy datasets and safe failure. Learner code is never executed; tests are checked against a reference and registered buggy versions.
Coding · Grade 11
In this capstone-style course learners define a computing problem precisely (a lab-booking clash checker), compare candidate algorithms, gather evidence from edge-case tests and operation counts, discover that a fast shortcut is subtly wrong, evaluate solutions honestly against success criteria, and defend a recommendation with claim, evidence and reasoning, including limitations and effects on people.
Coding · Grade 12
Learners begin the senior capstone by choosing a worthwhile, feasible project with a weighted decision matrix, writing an evidenced problem statement and an aim or research question with measurable success criteria, scoping an MVP with stretch goals and an out-of-scope list, planning milestones with a buffer, and addressing risks, privacy, consent and licences in a reviewed proposal.
Coding · Grade 12
Learners give their capstone a sound structure: layered architecture with separation of concerns, modules judged by cohesion and coupling, interfaces expressed as abstract base classes, and dependency injection so storage and clocks can be swapped for fakes in tests. They record significant choices in architecture decision records and weigh flexibility against unnecessary complexity.
Coding · Grade 12
Learners design the data layer of a capstone: entities, primary and foreign keys, one-to-many and many-to-many relationships with link tables, and normalisation to avoid update, insertion and deletion anomalies. They query real in-memory SQLite databases with SELECT, JOIN, GROUP BY and IS NULL from Python, and persist state safely with serialisation round trips, transactions, parameterised queries and planned migrations.
Coding · Grade 12
Learners make their capstone robust: they classify failures and choose strategies (validate, retry, fall back, fail fast), design custom exception hierarchies that are raised where problems are detected and handled at the right layer, implement bounded retries with exponential backoff against a simulated unreliable service with attention to idempotence, and write useful, safe logs alongside clear user messages.
Coding · Grade 12
Before release, learners check their capstone three ways: a test strategy shaped like the test pyramid with an honest view of coverage; stronger tests through mutation thinking, property-based checks against an oracle and testsuite activities against hidden mutants; profiling to find real hot spots before optimising; and a defensive security review built on a simple threat model and a prioritised checklist.
Coding · Grade 12
Learners put people at the centre of their capstone: they observe users and write evidence-based personas, prototype and iterate, run neutral usability tests and analyse success, time and errors, apply WCAG accessibility principles (computing real contrast ratios, keyboard access, labels and semantic HTML), and evaluate designs for inclusion, cognitive load, consent and dark patterns.
Coding · Grade 12
Learners prepare their capstone for life after the first release: documentation for each reader (README, docstrings, user guide, runbook, changelog), semantic versioning traced in code, deployment pipelines with test gates, staging, rollback and configuration from environment variables, and maintenance planning (corrective, adaptive, perfective and preventive work, monitoring, technical debt and a secure handover).
Coding · Grade 12
The final Grade 12 course prepares learners to present their capstone professionally: a scripted, rehearsed demonstration built around the success criteria with contingencies and test data; an honest evaluation that reports every criterion with evidence (including those not met); a defence that answers hard questions with claim, evidence, reasoning and trade-offs; and a specific, analytical reflection with complete attribution of sources and AI assistance.
