Micro:bit and Python: Design Thinking for Home Challenges

Embedded systems engineers design and program small computers that are built into everyday products and devices. They use microcontrollers, sensors, and programming languages such as Python to create systems that respond to their environment. They combine inputs, processing, and outputs to make devices perform specific tasks or solve real-world problems. They also build, test, troubleshoot, and improve prototypes to ensure their solutions work effectively.

After this activity, students should be able to:

• Formulate a human-centered problem statement identifying a user, a need, and technical constraints.
• Prototype a technical solution using a micro:bit and Python syntax (libraries, indentation).
• Identify micro:bit input and output components, specifically the LED display and sensors.
• Apply computational thinking to optimize code using for and while loops.

Students should be able to:

• Demonstrate basic computer literacy, including using a web browser, navigating an online application, and connecting a device via USB.
• Follow multi-step instructions and basic classroom technology safety procedures.
• Understand basic cause-and-effect relationships, which will support learning the Input → Process → Output model.
• Communicate ideas by asking questions, listening to others, and describing everyday problems or needs.
• Use basic logical and mathematical thinking, such as recognizing patterns and understanding simple sequences.

Today, we aren't just learning to code: We are going to start thinking like designers and engineers. We are going to learn how technology can be used to solve messy, human-centered problems.

But before I tell you about the process we are going to use, I want to hear how you would approach a problem.

Imagine that you have been asked to create something that will make another person's life easier or solve a problem they are experiencing. If you are designing something for another person, how would you know what that person actually needs? (Allow several students to respond.)

Now imagine that you already have a really cool idea for something you want to build. Should you start building your idea right away, or should you do something else first? Why? (Allow several students to respond. Listen for whether students mention asking the person questions, understanding the problem, learning about the person's experience, observing the situation, or trying different ideas.)

Now, think about your morning, from the moment you woke up until you arrived here. What is one small thing that frustrated you? Maybe your alarm was too quiet, you couldn't find something you needed, you missed your ride, or you forgot to water a plant. (Allow several students to respond.)

These might seem like small annoyances, but designers and engineers see them as problems and opportunities to make people's lives better.

In engineering and design, we are going to use an important mindset: ‘Fall in love with the problem, not the solution.’ What do you think that means? (Invite a few students to share their ideas.)

Before we start building something, we first need to understand the problem and the human experience behind it. We shouldn't assume that we know what another person needs just because we have a cool idea.

That's where design thinking comes in. Design thinking helps us understand people and their needs, explore different ideas, create solutions, test them, and improve them.

Later, you will use the micro:bit, a tiny but powerful programmable ‘brain’, and Python code to create technology that can address everyday challenges like the ones we just discussed.

But we're not starting with the hardware and code. We're starting with the person and the problem.

So, our big question is: How can we understand a person's everyday challenge and use design, technology, and code to create a solution that actually meets their needs?

Before we touch any hardware, let's practice thinking like designers.

Background  

Micro:bit

The BBC micro:bit is a pocket-sized microcontroller, a small, programmable computer designed to interact with the physical world. Unlike a standard laptop, which is designed for general-purpose tasks such as web browsing or word processing, the micro:bit is designed to receive inputs, process information, and produce outputs through its hardware components. The micro:bit contains several built-in components that students can use in their designs. Inputs include buttons and sensing capabilities for motion, light, and temperature. The microprocessor executes the programmed instructions, while outputs include the 5 × 5 LED display, speaker, and radio communication. The LED display can be used to show images, text, and numbers.

The micro:bit supports both block-based and text-based programming. In this activity, students use Python to gain experience with text-based programming and concepts such as libraries (collections of pre-written code that provide useful functions), syntax (the rules for writing code correctly), and indentation (the spacing used to organize and group Python instructions). In engineering projects, the micro:bit can act as the “brain” of a prototype by following an Input → Process → Output pattern. For example, pressing a button can provide the input, the Python program processes the button press according to the programmed instructions, and the micro:bit produces an output, such as displaying a reminder on the LED grid. Understanding this relationship helps students connect a human need to a programmable engineering solution and consider how the micro:bit's inputs, processing capabilities, and outputs can be combined to address real-world problems.

Python Programming

The micro:bit can be programmed using block-based or text-based programming environments; this activity uses Python to introduce students to text-based programming. You do not need advanced Python knowledge but should understand several fundamental concepts. A library is a collection of pre-written code that provides useful functions; in this activity, from micro:bit import * gives the program access to micro:bit-specific functionality. Syntax refers to the rules for correctly writing instructions in a programming language, while indentation is particularly important in Python because it indicates which instructions are grouped together within structures such as loops.

You should also be familiar with the basic commands students encounter, including display.show() for displaying images or other information, display.scroll() for scrolling text or numbers across the LED display, display.clear() for clearing the display, and sleep() for pausing the program. Students also explore loops, which allow programmers to repeat instructions efficiently rather than writing the same code multiple times. A for loop, such as for i in range(3):, repeats a set of instructions a specified number of times, whereas while True: repeats instructions continuously until the program is stopped.

Pseudocode, Testing, and Iteration

Before writing Python code, students use pseudocode, a plain-language description of the sequence of actions a program should perform. Pseudocode allows students to concentrate on the logic of their solution before dealing with exact Python syntax. For example, a student might first describe a program as “when Button A is pressed, display a reminder, wait, and clear the display” and then translate those steps into Python. In this activity, students identify their required inputs, processing or decisions, outputs, and pseudocode before developing the actual program.

Finally, you should emphasize that engineering and programming are iterative processes. Programs and prototypes are not expected to work perfectly on the first attempt. Students follow a Code → Test → Observe → Debug → Modify → Test Again cycle as they develop their projects. Debugging is the process of identifying and correcting problems in a program, while iteration involves using observations, testing results, and user feedback to improve the overall solution. You can support this process by encouraging students to predict what their code will do, test one change at a time, compare expected and actual results, identify possible sources of errors, and revise their code or design based on what they learn. This reinforces the larger design thinking principle that testing, failure, feedback, and revision are expected—and valuable—parts of developing an effective engineering solution.

The Design Thinking Process

Design thinking is a human-centered approach to innovation and problem-solving used by engineers to address complex or “messy” challenges. Rather than immediately jumping to a technical solution, engineers seek to understand the problem and the people affected by it before generating possible solutions. In this activity, students begin with a short backpack design challenge and then identify problems from their own lives using a Challenge Wall. They interview users to better understand their experiences, needs, and frustrations and develop a user-centered problem statement before considering possible solutions.

Following the Teach Engineering Design Thinking Process framework, the process used in this session consists of six essential pillars that guide students from initial observation to a final, tested prototype:

1. Formulating Problems: Engineers observe their environment and frame a problem within specific limits of time, resources, and materials. In this lesson, students use a "Challenge Wall" to identify specific frustrations in their daily lives.
2. Seeking Solutions: This stage focuses on empathy. Engineers interview stakeholders to understand their needs, ensuring the final product actually solves a real human requirement.
3. Thriving in Uncertainty: Design problems often have no single "right" answer. This phase encourages students to be creative and open-minded when brainstorming innovative solutions.
4. Prototyping Ideas: Students create "rapid and rough" versions of their ideas. This includes initial sketches and early versions of Python code to visualize how the solution will function.
5. Iterating Options: Engineering is an ongoing cycle. Students test their prototypes, gather feedback (using the "I like... I wonder..." format), and refine their code—such as using loops to make their program more efficient.
6. Reflecting Frequently: At the end of the process, students pause to talk through their outcomes. This reflection helps them define what they learned from "bugs" or failures and how they would improve the design in the future.

An important principle for you to reinforce throughout the activity is to “fall in love with the problem, not the solution.” Students should resist settling on a solution before understanding their user's needs. Their interviews should therefore focus on what happens, when and why the problem occurs, who is affected, what the user currently does about it, and what a successful solution would help the user accomplish. This approach helps students recognize that engineering design is driven by people's needs rather than by the technology itself.

Before the Activity

• Prepare the coding environment.
• • Ensure the micro:bit Python Editor is accessible on all student laptops or computers.
  • Confirm that the computers can connect to the micro:bit boards and that the necessary USB cables are available.
• Create and test a sample micro:bit project.
• • Create a simple program using the micro:bit Python Editor. (See Make It Code for examples.)
  • Test the program using the simulator.
  • Upload the program to a physical micro:bit board to confirm that the equipment and coding environment are working properly.
  • Prepare to demonstrate the sample program to students so they can see an example of what a completed micro:bit program can do.
• Gather and organize activity materials.
• • Prepare a micro:bit and USB cable for each student or student team.
  • Gather sticky notes, pencils, markers, and other writing materials.
  • Prepare the "Challenge Wall" using the categories of School, Home, Transportation, and Street.
  • If students will create physical prototypes, gather optional crafting materials such as cardboard, construction paper, tape, scissors, and markers.

During the Activity

Part 1: Engage - Introduction and Design Sprint (50 minutes)

1. Introduction and Framing (5 minutes)
2. 1. Open the session by challenging students to "fall in love with the problem, not the solution."
   2. Explain that design thinking is used to solve complex, "messy,” human-centered problems.
   3. Announce the challenge: "Your challenge is to improve your user's experience with their school bag/backpack. But you can't guess what they need. You have to ask."
2. Empathize and Define (10 minutes)
3. 1. Put students into pairs.  
   2. Assign Person A as the designer and Person B as the user. (Note: They will switch roles after the first interview.)
   3. The designer must interview the user about their school bag experience, asking about failures (broken zippers, weight) and wishes.
   4. Instruct designers to interview users about their experiences with their school bags or backpacks.
   5. Encourage students to ask about frustrations, failures, and wishes, such as broken zippers, heavy bags, difficulty finding items, or uncomfortable straps.
   6. Remind designers to listen carefully and avoid immediately proposing solutions.
3. Develop a Problem Statement (5 minutes)

• • Have each designer write a sticky note: "My user needs a way to __________ because__________."
  • Remind students to focus on a need, experience, or feeling, rather than a specific product feature.

4. Ideate and Prototype (15 minutes)

• • Ask students to sketch 3–5 possible or “crazy” ideas for addressing their user's need.
  • Have students select one idea.
  • Instruct them to develop the selected idea into a more detailed prototype sketch showing how the solution would work.

5. Gather Feedback (5 minutes):

• • Have designers present their prototype sketches to their users.
  • Ask users to provide feedback using:
  • • “I like…”
    • “I wonder…”
  • Encourage designers to listen to and record feedback without defending their designs. Designers present the sketch. Users provide feedback using "I like..." and "I wonder..."

6. Wrap Up (10 minutes)
7. 1. Bring the class together and review the design thinking process using the classroom poster: Empathize → Define → Ideate → Prototype → Test → Iterate.
   2. Ask students to identify how they used each stage during the backpack challenge.
   3. Explain that students will use design thinking to develop projects that address challenges around them.
   4. Introduce the next activity by explaining that students will identify challenges in their communities and, beginning today and continuing in upcoming sessions, develop projects to address those challenges.

Part 2: Explore – The Challenge Wall and Technology Patterns (50 minutes)

1. Build the Challenge Wall (10 minutes)
2. 1. Create four Challenge Wall categories: School, Home, Transportation, and Street.
   2. Conduct a silent brainstorm.
   3. 1. Ask students to write specific frustrations or problems they experience or observe on individual sticky notes.
      2. Have students place each sticky note in the appropriate Challenge Wall category.
      3. Encourage students to describe problems rather than solutions. For example: “I always forget to water my plants.”
      4. See Everyday Technologies Sheet (PDF) for examples.
2. Conduct a Gallery Walk (5 minutes)

• • Have students walk around the Challenge Wall and silently read problems contributed by their classmates.
  • Ask them to notice problems they have also experienced, problems they had not previously considered, and problems that technology might help address.

Sticky-note brainstorming activity organizing considerations into Home, Transportation, and School categories.CopyrightCopyright Amany Ayman

Sticky-note brainstorming activity documenting observations and considerations related to the “Street” category.CopyrightCopyright Amany Ayman

3. Introduce the Universal Technology Pattern (15 minutes)

• • Draw students' attention to the number of challenges identified on the Challenge Wall.
  • Explain that technology is often developed to address problems and make people's lives easier, safer, or more efficient. (See Everyday Technologies Sheet (PDF) for examples.)
  • Discuss familiar technologies such as phones, air conditioners, and cars. Asking the following for each technology:
  • • What problem does this technology solve?
    • What do we mean when we call a product ‘smart’?
    • Does a smart product actually have a brain?
  • Draw the following pattern on the board: Input → Process → Output
  • Explain each component:
  • • Input: Information received by the device.
    • Process: The device's “brain” follows programmed instructions and decides what to do.
    • Output: The action or information produced by the device.
  • Use familiar technologies to help students identify examples of inputs, processes, and outputs.

4. Meet the Micro:bit (20 minutes)

• • Distribute the micro:bit boards.
  • Give students time to observe the boards and identify components they notice. Connect the micro:bit hardware to the Input → Process → Output pattern:
  • • Inputs: Buttons, motion, light, and temperature sensors.
    • Process/Brain: The microprocessor executes the programmed instructions. (The microprocessor is programmed with Python.)
    • Outputs: LED display, speaker, and radio communication.
    • Introduce the micro:bit coding platform and explain that the micro:bit can be programmed using blocks or written Python code.

Part 3: Explain - Python Coding and Iteration (50 minutes)

1. Set Up and Complete the First Upload (10 minutes)

• • Explain that students will now begin programming their micro:bit.
  • Before connecting the devices, review the official micro:bit electrical product guidance and safety rules with students.
  • Guide students to the micro:bit Python Editor.
  • • Open micro:bit Python Editor.
    • From the “Reference” menu, choose “display.”
    • There will be commands display.show where they can choose a heart, a smile, or others.
    • Have students choose their shape and then, drag it to the text code area.
  • Have students create a simple program that displays a heart image. (See Image 3.)

A micro:bit Python programming environment showing code that uses a repeating loop to display and clear a heart icon on the simulated micro:bit.CopyrightCopyright Amany Ayman

A micro:bit displaying a heart pattern on its LED grid.CopyrightCopyright Amany Ayman

• • Ask students to run the program in the simulator and observe the output.
  • Have students connect their micro:bit using USB and transfer the program to the physical boards.
  • Ask students to compare the simulated output with the physical micro:bit output.

2. Explore the Display (15 minutes)
3. 1. Explain important code elements, including the library/import statement, display.show(), and sleep().
   2. Challenge students to modify their programs to:
   3. 1. Clear the display.
      2. Display a number.
      3. Display their name or initials.
      4. Display an image.
   3. Ask students to predict what their code will do before running it.
   4. Teacher reference: View this Code & Simulation Video.

• • • Written Code:

# Imports go at the top

from microbit import *

# Code in a while True: loop repeats forever:

while True:

display.clear()

display.scroll('My Name')

display.scroll('13')

3. Introduce Iteration and Loops (25 minutes)
4. 1. Write pseudocode on the board for a repetitive program, such as displaying a happy face three times.
   2. Example:

Display a happy face

sleep

Clear

sleep

Display a happy face

sleep

Clear

Sleep

Display a happy face

sleep

Clear

Sleep

3. 3. Ask students to identify the repeated pattern.
   4. Explain that programmers can use loops to avoid writing the same instructions repeatedly.
   5. Introduce for i in range(3): as a way to repeat instructions a specified number of times.
   6. Introduce while True: as a way to repeat instructions continuously.
   7. Compare the two:
   8. 1. A for loop repeats instructions a specified number of times.
      2. A while True loop repeats instructions indefinitely.
   8. Have students modify one of their previous programs to include a loop.
   9. Encourage students to test, identify errors, modify their code, and test again.

A micro:bit Python editor showing a while True loop programmed to repeatedly display a heart image.CopyrightCopyright Amany Ayman

A micro:bit Python editor showing a while True loop programmed to display a heart, pause, and scroll the text “Hello.”CopyrightCopyright Amany Ayman

Part 4: Elaborate - Building the Project (50 minutes)

1. Select a Home Challenge (5 minutes)
2. 1. Return students' attention to the Challenge Wall.
   2. Have students review the problems in the Home category.
   3. Ask each student or team to select a Home challenge they are excited to address.
   4. Remind students to select a problem they want to understand, rather than simply choosing a problem for which they already have a solution.
2. Interview the User (10 minutes)
3. 1. Have students identify and interview the classmate who originally wrote the selected sticky note.
   2. Ask students to learn more about:
   3. 1. What happens.
      2. When the problem occurs.
      3. Why it is frustrating.
      4. Who is affected.
      5. What the user currently does about it.
      6. What a successful solution would help the user accomplish.
   3. Have students summarize the need using: “My user needs a way to __________ because __________.”
3. Ideate, Plan, and Code (30 minutes)
4. 1. Have students generate at least three possible solutions to the challenge.
   2. Ask students to compare their ideas based on user needs, available micro:bit features, programming knowledge, available materials, time, and other limitations.
   3. Have students select one solution to develop.
   4. Distribute one Project Worksheet (PDF) to each student.
   5. Instruct students to complete their project worksheet by documenting:
   6. 1. The challenge.
      2. The user's needs.
      3. At least three possible solutions.
      4. The selected solution.
      5. Why they selected it.
      6. Required inputs.
      7. Required processing or decisions.
      8. Required outputs.
      9. Pseudocode.
   6. Have students write a brief project description explaining how their solution addresses the user's challenge.
   7. Have students develop the Python code for their micro:bit solution.
   8. Encourage students to follow an iterative process: Code → Test → Observe → Debug → Modify → Test Again.
4. Optional: Create a Physical Prototype
5. 1. Provide cardboard, markers, paper, tape, and other craft materials.
   2. Invite students to create a physical housing, plate, model, or interface demonstrating how the micro:bit could be incorporated into the final product.

Part 5: Evaluate - Presentation and Reflection (50 minutes)

1. Finalize Projects (15 minutes)
2. 1. Have students review and refine their project descriptions.
   2. Give students time to complete their Python code.
   3. Ask students to test their micro:bit projects and troubleshoot any errors.
   4. Have students verify that the project's inputs, processing, and outputs function as intended.
   5. Encourage students to make final improvements based on testing.
   6. If students created physical prototypes, allow time to complete their housings or models.
2. Present Projects (20 minutes)
3. 1. Have each student or team present their project and demonstrate the working micro:bit.
   2. Ask each presentation to address:
   3. 1. What problem did you choose?
      2. Who is the user?
      3. What did you learn from interviewing the user?
      4. What solutions did you initially generate?
      5. Which solution did you select, and why?
      6. What are your project's inputs, process, and outputs?
      7. How does your Python code work?
      8. How does the micro:bit prototype address the user's need?
      9. What changes did you make during testing and iteration?
3. Conduct a Reflection Discussion (15 minutes)
4. 1. Facilitate a whole-class discussion using questions such as:
   2. 1. What would you edit or modify to make your project better?
      2. What did you discover during testing?
      3. What was the most difficult part of troubleshooting your code?
      4. How did interviewing the user change your original assumptions?
      5. Did the project address the original user's challenge?
      6. What does the original user think about the solution?
      7. What feedback could help improve the next version?
      8. What impact did design thinking have on solving a user-centered problem?
   2. Return to the opening statement: “Fall in love with the problem, not the solution.”
   3. Ask students to explain what the statement means after completing the design and programming experience.

Pre Assessment

Design Thinking and Technology Discussion: Before beginning the activities, assess students’ prior knowledge of problem solving, technology, and programming through a brief whole-class discussion. Ask students questions such as:

1. When you experience a problem in your everyday life, how do you usually try to solve it?
2. If you are designing something for another person, how can you find out what that person actually needs?
3. What is an example of a technology you use every day? What problem does it solve?

Use student responses to identify their existing understanding of user needs, problem solving, technological systems, and programming. Do not correct every response at this stage; revisit students’ initial ideas as the lesson progresses.

Activity Embedded (Formative) Assessment

Design Thinking Check: During the backpack design sprint, circulate among student pairs and listen to their interviews. Check that designers are asking questions to understand the user rather than immediately proposing solutions. Review students’ problem statements to determine whether they identify a user need rather than a specific feature or solution. During testing, listen for constructive feedback using “I like…” and “I wonder…”

Python Programming Check: As students complete the introductory coding challenges, circulate and observe their programs. Ask individual students to predict what their code will do before running it and explain the purpose of selected lines of code. Check that students can modify the display, execute instructions in sequence, and transfer a program to the physical micro.

Project Planning Check: Review each student or team’s project worksheet before they move deeply into coding. Check that students have:

1. Identified the challenge.
2. Described the user’s need.
3. Generated at least three possible solutions.
4. Selected and justified one solution.
5. Identified the required inputs, processing/decisions, and outputs.
6. Developed pseudocode for the solution.

Use brief teacher conferences to ask students how evidence from their user interview influenced their selected solution.

Summative Assessment

Final Project and Presentation: Assess students based on their completed micro:bit project, project documentation, and presentation. Students should demonstrate both the engineering design process they followed and the functionality of their final solution. Use the Project Rubric (PDF) for assessment.

Reflection Discussion: Conclude the assessment with a whole-class reflection. Ask students to consider what they would change to improve their projects, what they learned through testing, how interviewing the user affected their assumptions, and whether the final solution addressed the original user’s challenge. Ask students to explain how design thinking influenced their approach to solving a user-centered problem.

• Before students begin working with the micro:bit, review the official Micro:bit Safety Rules with the class.

• Indentation Error: Remind students that Python uses indentation to identify instructions that belong inside a loop. Students should use consistent indentation (typically four spaces) for code inside a loop.
• Connectivity: If the code will not upload to the micro:bit, check that the USB cable is fully connected. If the problem continues, try another USB cable and make sure it supports data transfer and not just power.
• Library Error: Check that the program includes from microbit import * at the beginning when students are using the MicroPython APIs taught in this activity.
• Code Does Not Run as Expected: Ask students to read any error messages and check spelling, capitalization, parentheses, colons, and indentation.
• Nothing Appears on the Display: Check the display.show() or display.scroll() commands. Have students test a simple display command before returning to their larger program.
• Loop Does Not Work: Check that the instructions intended to repeat are correctly indented beneath the for or while statement.
• Program Runs Too Quickly: Add sleep() between outputs so students have enough time to observe what is happening.
• Input Does Not Produce the Expected Output: Test the input and output separately before combining them. Encourage students to use the process Predict → Test → Observe → Debug → Modify → Test Again.

• Have lower grades or students struggling with syntax use the built-in Reference Library in the Python Editor for copy-paste examples.
• Have older/advanced students create custom images using the Image() class using micro:bit display or use the A and B buttons in micro:bit as a trigger for their loops.