Differentiated Instruction in an Arduino Class: 3 Tiers, 1 Lesson

Differentiated instruction in an Arduino class doesn't mean planning three separate lessons: the whole class builds the same project, but every project is split into three tiers. The basic tier gets the project running and changes one value, the developing tier adds a new behaviour to the project, and the advanced tier changes how the program is structured. You find out which student starts on which tier with a 10-minute pre-assessment in the first lesson, and the groups aren't fixed either: they change with the stage of the lesson. That way the student who has never seen code ends the lesson with a working traffic light, the student who has built robots is busy rewriting the same traffic light without delay(), and both of them can still talk about the same circuit.

This post covers every part of that template: three questions and a mini task for the pre-assessment, a table that turns the score into a tier, ready-made basic/developing/advanced tasks for four free BlueGrays projects, when each of four grouping strategies works, an extension menu for fast students, a scaffolding list for students who need support, an assessment approach that measures everyone from their own tier, and a minute-by-minute 40-minute lesson flow. The examples all rest on the same assumption: a class of 24 students, 12 Arduino Uno kits, pair work and a 40-minute lesson. We covered classroom logistics (kit boxes, help queue, packing up) in the post on teaching Arduino to a large class and the weekly topic order in the 8-week robotics coding plan; here the focus is only on how to open the same lesson up to different levels.

What differentiation means in an Arduino lesson, and what it doesn't

Differentiation means everyone reaches the same goal by different routes and to different depths. In an Arduino lesson the goal is usually a concept: digital output, timing, conditions, analog input. If the goal of the traffic light lesson is the idea that "the order and duration of commands decide how the program behaves", the basic-tier student learns it by changing one delay() value and the advanced-tier student by rebuilding the timing with millis(). Both have learned the same idea, one at the surface and one in depth. Differentiation can change three things: the task itself (what gets done), the support (how much help there is) and the product (how the student shows what they learned). The template in this post uses all three together.

Differentiation is not: giving the fast student more of the same work (lighting ten LEDs instead of five isn't depth, it's just the same task taking longer), sending the slower student to an easier project (then the class can't talk about the same thing), or labelling students as the "weak group" and the "strong group" for the whole year. With Arduino that label is also misleading, because skill grows along three separate strands: building circuits, reading code and debugging. A student who has built a robot may wire a circuit with their eyes closed yet never have read the code; a student who has never seen a circuit but has had Python lessons at school may understand an if block before anyone else. That's why tiers are given to tasks, not to students, and a student can move up a tier in any lesson.

A 10-minute pre-assessment in the first lesson

The pre-assessment isn't for marks, it's for assigning tasks in the first week; tell your students that from the start. It's done individually and on paper, so students who work in pairs don't end up in each other's shadow. It takes 10 minutes in total, and scoring 24 sheets after the lesson takes you about 10 minutes. Each item gets 0, 1 or 2 points, for a total out of 8.

1. Concept question (2 min): "Why do we put a resistor in between when we connect an LED to an Arduino?" A student who says it limits the current gets 2, a half answer such as "so the LED doesn't burn" gets 1, a blank gets 0.
2. Code reading question (2 min): Write four lines on the board: digitalWrite(2, HIGH); delay(1000); digitalWrite(2, LOW); delay(1000); Question: "What does this code do? What changes if you write delay(200) instead of delay(1000)?" Explaining both correctly gets 2, only one gets 1.
3. Experience statement (1 min): "What have you built before?" Nothing is 0; block coding or a step-by-step project from a kit is 1; a project where they wrote or changed their own code is 2.
4. Mini task (4 min): Hand out a printed drawing of an LED circuit with two mistakes in it: the LED is reversed and the resistor is missing. The student circles the mistakes and writes how to fix them. Finding both gets 2, finding one gets 1.
5. Collect (1 min): Collect the sheets. Don't tell anyone their score before the next lesson; tiers are handed out quietly in the first lesson using task cards.

You can back up the paper assessment with two tools in BlueGrays. The first is the Placement test in the Daily questions section: this 15-question test places the student on one of six levels (A1 First Light, A2 Circuit Builder, B1 Sensor Explorer, B2 Project Maker, C1 System Designer, C2 Workshop Master). As a rough mapping you can treat A1–A2 as the basic tier, B1–B2 as developing and C1–C2 as advanced. The second is the third question of the Project Finder, How much experience do you have?: its three options (This will be my first project, I've built a few projects, I'm comfortable, challenge me) match the three tiers almost one to one and show how the student sees themselves. You can set both as homework before the first lesson; the gap between their result and the paper score tells you whom to watch closely. We explained the placement test questions and the level system in detail in the daily questions post.

Same project, three tiers: a template with four free projects

The rule of the template is simple. The basic tier gets the project running, changes one value and observes the result; most of the time this is the Try it yourself task in the project's Understand the code tab. The developing tier adds a new behaviour to the project: a button, an LED, a condition or Serial Monitor output. The advanced tier changes the structure of the program: millis() instead of delay(), an array and a loop instead of repeated lines, holding a state between two thresholds. The four projects below are completely free in BlueGrays with the circuit diagram, code, blocks and Understand the code; no student in the class needs Premium.

Use the table as tier cards: print the three cards for each project on A5 paper and give each pair the card for their tier, but leave the other two cards in the middle of the table. A pair that finishes the basic card is free to pick up the developing card; a pair struggling with the advanced card is equally free to go back to the developing one, and that doesn't count as failure. For the circuit and code details of the pedestrian button task in the developing tier, see the Arduino traffic light post, and for the non-blocking timing behind the advanced tier, the millis() and delay() post. All tiers are built on the same base circuit, so the class talks about one diagram and the advanced student can tell their basic-tier classmate, "look, I don't have the delay() line you changed".

Grouping strategies: which one, and when?

In a mixed-ability class one grouping method isn't enough for the whole lesson. With flexible grouping the groups change with the stage of the lesson: mixed groups explain things to each other when a new concept is introduced, pairs at a similar level move at their own pace during tier tasks, and experts circulate at the end. The table below sums up where each of four strategies works and where it backfires.

Pair programming suits an Arduino lesson very well because the work has two hands: while one student deals with the circuit and the Arduino IDE, the other keeps the project's diagram and code open on a phone. The navigator guides with "the long leg of the red LED goes to the D2 row" or "look at the delay at the end of loop", and the driver carries it out. Swapping roles every 10 minutes stops the basic-tier student in a mixed pair from finishing the lesson without ever touching the keyboard. Set up the groups after the first pre-assessment, but refresh them every 2–3 lessons based on which colour of card students are picking up; a pair that moved up a card can start the next lesson with a new partner.

An extension menu for fast students

Telling a student who finishes early to "help your classmate" is easy, but on its own it isn't an extension; that student should also learn something new in that lesson. An extension menu means the student knows what to do the moment they finish and doesn't need to come to you. Write the menu in the corner of the board or on the back of the advanced tier card.

• Try it yourself, but without hints: Solve the Try it yourself task at the end of each project's Understand the code tab without touching the Hint and Show solution buttons, then compare your solution with the one in the app. After that, write a new task on the same project for your classmates. We explained how the tasks work in the Understand the code post.
• Code guide cards: In the Code guide, cards such as millis(), arrays and tone() are the groundwork for the advanced tier tasks. Each card ends with a mini quiz and a See it in projects section, so the student sees the command in other projects sorted from easy to hard. You'll find how the guide is organised in the Arduino commands guide post.
• Moving on to Premium projects: For a student who has finished the free projects, the next step is the Premium projects with sensors, displays and motors. The student doesn't need their own card or subscription for this; one of the educator codes described below is enough.
• Designing their own project: Have them design a project that combines two free projects: for example, Traffic Light plus Night Light with Ldr gives a traffic light that blinks yellow at night. The student first writes the goal, parts list, pin table and test plan on paper, then builds it. The student can share the finished project with photos and code as a Tutorial topic via Learn > Forum > New Post; the topic is public, not a private class post.
• Mentor role: Sitting at the expert table is a job, not a reward: the mentor only asks questions and explains, and doesn't touch the wires. Spending one lesson mentoring and the next on their own advanced task lets a fast student move forward both by explaining and by doing.
• A level-up goal: On the Daily questions side, when a student's level reaches 100% and they've answered enough questions at that level, the level-up exam unlocks; getting 9 out of 10 right moves them up a level. Setting a "move up one level" goal at the start of term is an extension that carries on outside the lesson too.

You don't have to buy codes for the whole class to open Premium projects to a few fast students. The Educator Packages screen in the Profile has packages of 5, 10 or 50 codes, monthly or yearly. Payment is one-off and doesn't renew automatically; the student enters the code on the Redeem Code screen and becomes Premium without adding a card to their Apple or Google account. Unused codes don't expire, and on the My Codes screen you see who used which code. Every code in a yearly package has 6 transfers and every code in a monthly package has 1: if the need shifts to another student during the term, you can cancel a used code and create a new one with the remaining time. In the 10-code package the cost per student is about 20% lower than in the 5-code one; you'll see the current price for your country on the same screen. Tell your students one thing up front: when a student redeems a code, their name, username, email and profile photo are shared with the educator who gave it. We covered the packages in detail in the bulk Premium codes for a class post.

Students who need support: lighten the load, not the goal

For a student who needs support, the aim isn't to give them an easier project but to remove unnecessary load from their path while they reach the same idea in the same project. If a student who has never seen a circuit tries to learn the breadboard's internal connections, which way round the LED goes, choosing a port in the Arduino IDE and the code all in the first lesson, they end the lesson having learned none of them. Scaffolding means you temporarily carry some of that load; as the student progresses, you take the scaffolding away piece by piece.

• Pre-built circuit: Give the basic-tier pair the circuit already built, or a half circuit with only the breadboard part ready. That way the first 15 minutes don't go on wiring and the student's energy goes to the question "which line changes what?". In the second lesson they build half of the circuit themselves, in the third all of it.
• Show as blocks and Understand the blocks: The Show as blocks switch on the project page shows the same program as blocks; while it's on, the Understand the code tab becomes Understand the blocks and explains the program block by block, step by step. The blocks are for reading and the project's real code is still what goes onto the board, but a student who reads the "if value < 50" block has no trouble finding the if (value < 50) line in the code.
• Step cards: Split the circuit and the task into 5–6 cards with one step per card: "Plug the long leg of the red LED into the D2 row", "Put the 330 Ω resistor between the LED's short leg and the GND row". The student turns the card over when it's done. Cards make progress visible and cut down the "what do I do now?" questions.
• Let's build it together mode: The Let's build it together mode in the app splits the project into four steps: Get the parts ready, Build the circuit, Upload the code, Run and test. In this mode the screen stays on and the student can carry on from the step where they stopped. For a basic-tier pair who leave the phone on the table it works like a ready-made deck of step cards. Details of the mode are in the first Arduino project post.
• Short goals: Split the 40 minutes into three small goals and write them on the board: "1. The LEDs light up in order", "2. I changed the yellow duration", "3. I explained my change in one sentence". A student who ticks each goal sees at the end of the lesson what they've achieved.
• The If you get stuck section: The If you get stuck section of the Understand the code tab lists common symptoms and their fixes. Teaching basic-tier students to look there first, then ask a classmate and only then come to you is the first step towards solving problems on their own.

For a basic-tier pair, a successful lesson looks like this: in the Night Light with Ldr project the circuit comes pre-built, the students read the blocks and say "if the value is less than 50, the LED turns on" in their own words, set the threshold to 300 and upload it, cover the LDR with their hands to see that the LED now turns on earlier, and on the exit question write "the higher the threshold, the less darkness it takes to turn the LED on". That's less code than the hysteresis task in the advanced tier, but it reaches the same idea: the program compares a measurement with a number and decides. In the next LDR lesson the same pair can read the value in the Serial Monitor and choose the threshold themselves, which moves them into the developing tier on their own.

Fair assessment: everyone is measured from their own tier

In a differentiated lesson, marking everyone against the same criteria is unfair in two ways: the basic-tier student gets a low mark because they never write millis(), and the advanced student gets the top mark without ever being stretched. The fix is to split assessment in two. The first part is the process criteria that are the same in every tier: predicting and testing, explaining what they did, finding the mistake. The second part is whether the student reached the goal of their own tier and how far they've come since the first pre-assessment. The table below shows what the same criterion looks like at the "goal reached" level in each tier. For detailed criteria, a submission form and a portfolio, see the Arduino lesson assessment rubric post.

An example for working out a mark: out of 100 points, give 40 to the process criteria that are the same in every tier (prediction, explanation, debugging), 40 to the goal of the student's own tier and 20 to progress. The progress score looks at whether the student moved up a tier during the term and how much they improved the weak strand from their pre-assessment (circuits, reading code or debugging). Let's say a student who scored 2 on the pre-assessment started picking up developing-tier cards halfway through the term: they get full marks for progress. A student who scored 8 and finished advanced-tier tasks all term without ever being stretched earns the progress points only by trying something new, for example mentoring or designing their own project. Make it a shared baseline that by the end of term everyone can do the basic tier of every project on their own; that way the tier is neither the ceiling nor the floor of the mark.

A 40-minute differentiated lesson flow: Traffic Light

The flow below uses the Traffic Light project and is planned for the first lesson after the pre-assessment. Let's say that after the pre-assessment 5 of the 12 pairs got the basic card, 4 the developing card and 3 the advanced card. While reading the project, two pairs share a table in a mixed seating (one basic pair and one developing or advanced pair); for building and tier tasks each pair goes back to its own kit. The start and end of the lesson are the same for everyone, and the middle splits into three tiers.

The exit questions each ask for a one-sentence answer and decide the tier assignments for the next lesson. Basic: "If you change the delay(2000) line to delay(5000), which light stays on and for how many seconds?" Developing: "What does your program do if you press the button right while yellow is on, and why?" Advanced: "Why does pressing the button sometimes not work in the version that uses delay()?" A basic-tier student who answers correctly is invited to try the developing card next lesson; if the advanced answer is vague, that student stays on the advanced card for one more lesson.

• Pre-assessment sheets scored and each student's starting tier noted.
• The project's three tier cards printed, with enough copies for the middle of each table.
• Pre-built or half circuits and step cards ready for the basic tier.
• Extra materials for the developing and advanced tiers (button, LED, 330 Ω, passive buzzer) set aside per pair.
• Mixed table pairings written down for the reading stage; 2–3 advanced students chosen for the expert table.
• Extension menu written in the corner of the board, short goals on the board.
• Exit questions ready on separate slips for the three tiers; the next lesson's tier assignments will be updated from these slips.

A mixed-ability class, set up well, isn't a problem but a resource: the advanced student goes deeper by explaining, and the basic-tier student stays part of the class by talking about the same project. When you plan your next lesson you can start with one of the four projects in the table; all of them have their circuit diagram, code, blocks and Understand the code section free in the BlueGrays app, and you can draw your tier cards straight from their Try it yourself tasks.