Rinse & Reteach
High school student tracing how data moves through a computer on an IPOS-C flowchart worksheet

How Does Data Actually Move Through a Computer? (An IPOS-C Flowchart Lesson)

A high school lesson where students trace how data moves through a computer—Input, Processing, Output, Storage, Communication—across 10 real-world scenarios.

At a Glance

Objective

  • Students will define and distinguish Input, Processing, Output, Storage, and Communication (IPOS-C).
  • Students will trace the IPOS-C cycle through 10 real-world, everyday scenarios and correctly label each step.
  • Students will (Extension only) describe the 4-step Machine Cycle — Fetch, Decode, Execute, Store — as a deeper look inside the Processing step, for students who want to go further.
Topics Covered
computer hardwarecomputing systemsflowchartssequencing
Subjects
Computer Science
Related Courses
Intro to Software TechIntro to Hardware Tech
Type of Lesson
individualworksheet

Related Unit(s)

Lesson Plan Notes How Does Data Actually Move Through a Computer? (An IPOS-C Flowchart Lesson)

When I first taught this lesson, I hadn’t thought much about IPOS myself, but I went through all the exercises like a student and quickly discovered that it’s easier for students to tell whether devices are used for input or output. Especially after learning about peripherals, it was easy to classify since peripherals are always an input or output. Then, by process of elimination, it becomes easier to identify output and storage devices. Instead of simply recalling what each does, it is important to see how they all connect in an actual flow, and that’s where the critical thinking comes in! In this model, I emphasize that Output, Storage, and Communication can all fire at once rather than strictly in sequence. Anchoring every question in a scenario the student has personally lived through (checking out at a self-checkout, syncing a fitness tracker, joining an online multiplayer match) makes the abstraction concrete before students diagram it cold. This lesson doubles as a first primer on flowcharts, which the course leans on heavily from here forward.

What the lesson actually is

This lesson is a whole-group recap of the 5 IPOS-C terms and the hub-and-spoke diagram model (Processing at the center, Output/Storage/Communication branching out simultaneously), a brief optional Machine Cycle mini-intro, then students work independently through 10 real-world scenario flowcharts (checkout, shopping app, fitness tracker, multiplayer game, and more), closing with a short whole-class debrief. The hub-and-spoke model is taught and shown before students touch a scenario—not left for them to discover on their own partway through —to make it clear that not all processes are linear. Though linear processes are where we often start in computer science. This worksheet mostly serves as practice via examples and illustration. This is a shorter, single-period worksheet by design.

Why the “things can happen at once” framing matters here

The biggest misconception this lesson corrects is students trying to force a strict 1-2-3-4-5 order onto IPOS-C. The real insight is that Output, Storage, and Communication can fire at once or asynchronously — swiping a hotel key card updates the room’s lock and the front desk system at the same time; it doesn’t update one then the other. The lesson also allows for gray areas. Several of the 10 scenarios have a genuinely debatable “right answer” by design (is confirming a PIN at checkout Processing, or also a form of Communication with the bank?) — students are graded on their reasoning, not on matching one single expected label. This is a deliberate shift from pure factual recall (the Components lesson) to applied, sometimes ambiguous reasoning —a preview of how the rest of the course will ask students to think.

What I look for when I grade it

  • Step Identification Accuracy (30 pts) - Correctly labels Input, Processing, Output, Storage, and Communication across all 10 scenarios. This is the bulk of the activity, but it’s not enough to show real critical thinking and understanding.
  • Reasoning on Ambiguous Steps (10 pts) - Where a step could reasonably fall into more than one category, I’m looking for the student to explain their choice rather than leave it blank or unjustified; this is where the real thinking shows up.
  • Hub-and-Spoke Understanding (10 pts) - At least one written or verbal response during the debrief demonstrating that Output, Storage, and Communication can happen simultaneously, not strictly in sequence.
  • Bonus Extension / Machine Cycle (+5 bonus) - Correctly sequences Fetch, Decode, Execute, Store and answers the reflection question(s); optional, never required for full credit on the base worksheet.

Where this goes next

This is Lesson 2 of Unit 2 (Computing Systems) — the Components lesson feeds directly into it, and it in turn sets up the Computer Components Maze (quick retrieval practice) and everything downstream that leans on students being comfortable with flowchart thinking.

Frequently Asked Questions

Do students need to finish the Components lesson first?
(Prerequisite/sequencing question, drawn from the Teacher Reference Guide's "At a Glance" prerequisites line.) Yes — this lesson assumes students already know the 6 hardware components and basic IPOS categories at a basic level. It's built as a direct follow-on to What Is a Computing System? — The Components, not a standalone first lesson.
Is the Machine Cycle (Fetch, Decode, Execute, Store) required?
No. It's included as an optional extension for students who want to go further, worth a small bonus, but every student can earn full credit on the base worksheet without touching it. I hard-cap the mini-intro at 10 minutes in class so it doesn't take over the period.
What if my students disagree with the answer key on a scenario?
That's expected on a few of the 10 scenarios by design — a step like confirming a PIN at checkout can reasonably be read as Processing or as Communication with the bank. I grade the reasoning, not just whether the label matches the key, and that's called out explicitly in the grading guidance.
How long does this lesson take?
About 70 minutes — one class period. It's shorter and more focused than the Components lesson: a 10-minute recap, a brief optional Machine Cycle intro, 45 minutes of independent scenario work, and a 5-minute debrief.
Is there support for students who struggle with the abstraction?
Yes — the guide includes a scaffolding option (a physical hub-and-spoke reference card taped to the student's desk during the scenario section) for students who need it, alongside the extension option for students who are ready to go further.
Have a question or feedback? Get in touch →