Apply the Six-Phase Design Process: Execute each phase from discovery through iteration effectively
Distinguish Divergent and Convergent Thinking: Know when to generate options versus select best solutions
Use Design Thinking Framework: Apply the Empathize-Define-Ideate-Prototype-Test cycle to IoT projects
Create “How Might We” Questions: Reframe problems as opportunities for innovation
Navigate Non-Linear Progress: Understand when and how to loop back to earlier phases
For Beginners: Interactive Design Process
Designing an IoT product is not a straight line from idea to finished product. The interactive design process follows six phases – Discover, Define, Ideate, Prototype, Test, Iterate – and you often loop back to earlier phases as you learn. For example, user testing in the Test phase might reveal that your smart thermostat’s schedule feature confuses people, sending you back to the Define phase to rethink the problem. This iterative approach means embracing uncertainty: you do not need the perfect plan upfront, because testing and learning will guide you to the right solution.
Sensor Squad: The Six-Step Design Journey!
“The design process has six phases, like a treasure map with six landmarks,” explained Max the Microcontroller. “Phase one is Discovery – explore the problem. Phase two is Define – narrow down what you are solving. Phase three is Ideate – brainstorm wildly. Phase four is Prototype – build something rough. Phase five is Test – let real users try it. Phase six is Iterate – go back and improve!”
“The fun part is divergent and convergent thinking,” said Sammy the Sensor. “In divergent phases, you spread out and explore every direction – like throwing paint everywhere. In convergent phases, you focus and pick the best ideas – like choosing your favorite color. You alternate between going wide and going narrow.”
Lila the LED added a key insight: “The path is not a straight line! Sometimes you test your prototype and discover you defined the problem wrong. So you loop back to Define and try again. That is not failure – that is learning! The best products come from teams that are not afraid to go backwards when needed.”
28.2 Prerequisites
Before diving into this chapter, you should be familiar with:
Interactive Design Principles: Understanding the core principles of iterative design provides the foundation for applying the process effectively
User Experience Design: Knowledge of UX principles helps you understand user-centered goals at each process phase
Key Concepts
Interaction Design: Discipline defining how users communicate with digital systems through input, output, and feedback mechanisms.
Multimodal Interface: System accepting input and delivering output through multiple channels (touch, voice, gesture, haptic) simultaneously.
User Testing: Structured observation of representative users attempting defined tasks, exposing interface problems invisible to designers.
Prototype Fidelity: Level of detail in a prototype: low fidelity (paper sketch) validates concepts; high fidelity (interactive mockup) validates usability.
Information Architecture: Structural design of digital spaces to support usability and findability, determining where content lives and how users navigate.
Cognitive Load: Mental effort required to use an interface; IoT systems must minimise cognitive load for users managing many connected devices.
Usability Heuristic: Principle-based rule for evaluating interface quality (e.g. Nielsen’s 10 heuristics) without requiring user testing.
28.3 Introduction
Most interactive design processes follow a cycle of divergent exploration (generating many options) followed by convergent decision-making (selecting best options). This chapter provides a structured six-phase methodology for applying interactive design principles in practice.
28.4 The Six-Phase Design Process
Figure 28.1: Six-Phase Interactive Design Process with Iteration Loops
Variant View: Design Thinking Double Diamond
This variant shows the Double Diamond framework - a different lens on the same design thinking process, emphasizing the alternation between divergent thinking (exploring many options) and convergent thinking (narrowing to best solution).
Wizard of Oz prototypes (human simulating system intelligence)
Digital mockups and clickable wireframes
Functional prototypes with limited capabilities
Deliverable: Testable prototypes at appropriate fidelity level.
28.4.5 Phase 5: Test and Learn
Goal: Validate assumptions and identify improvements.
Activities:
Usability testing with representative users
A/B testing different design alternatives
Pilot deployments in realistic environments
Analyzing usage data and user feedback
Testing methods by phase maturity:
Stage
Method
Participants
Duration
What You Learn
Early concept
Think-aloud with paper prototype
5-8 users
15 min each
Whether the concept makes sense
Mid-fidelity
Task completion testing
8-12 users
30 min each
Where users get stuck
High-fidelity
Realistic scenario testing
10-15 users
60 min each
Whether it works in context
Pre-launch
2-week home deployment
15-30 households
2 weeks
Long-term usability, edge cases
The 5-user rule: Jakob Nielsen’s research shows that 5 users uncover approximately 85% of usability problems. Running 3 rounds of 5 users (test-fix-retest) is more effective than one round of 15 users, because each round reveals new issues created by fixes to previous problems.
Deliverable: Insights about what works, what doesn’t, and why.
28.4.6 Phase 6: Iterate
Return to earlier phases based on learnings
Refine successful elements
Redesign or discard unsuccessful approaches
Gradually increase prototype fidelity as confidence grows
Continue cycling until solution meets success criteria
When to stop iterating: Diminishing returns set in when each round of testing reveals only minor cosmetic issues rather than fundamental usability problems. A practical threshold is when task completion rate exceeds 90% and the System Usability Scale (SUS) score exceeds 68 (the industry average). Below 50 on SUS indicates serious problems requiring redesign; above 80 indicates an excellent experience.
Key Insight: This is not a linear process. Teams frequently jump between phases as new insights emerge.
28.5 Design Thinking Methodology
Design thinking provides a structured framework for interactive design, particularly valuable for wicked problems where requirements are unclear and solutions non-obvious.
Figure 28.4: Design Thinking Framework: Five Phases with Iteration Loops
28.5.1 Core Tenets
Human-centered: Start with empathy for users
Show don’t tell: Make ideas tangible through prototypes
Bias toward action: Build to think, don’t just think
Radical collaboration: Diverse teams generate better solutions
28.5.2 Divergent vs. Convergent Thinking
Figure 28.5: Divergent and Convergent Thinking: From 100+ Ideas to Implementation
Alternate between divergent and convergent modes throughout process.
Common mistake: Converging too quickly, selecting first acceptable idea rather than exploring broadly.
28.5.3 Reframing Problems as Opportunities
Transform problem statements into “How Might We” questions:
Problem Statement
How Might We Reframe
“Elderly patients forget to take medication”
“How might we make medication routines engaging and memorable?”
“Users don’t understand automation rules”
“How might we visualize system logic in intuitive ways?”
“Installation takes too long”
“How might we create zero-setup IoT devices?”
Impact: Reframing shifts mindset from problem-solving to opportunity-seeking.
28.6 Worked Example: Redesigning a Smart Medication Dispenser
Scenario: A healthcare company’s automated pill dispenser has a 35% abandonment rate among elderly users within 60 days. The device uses a touchscreen to configure medication schedules. Apply the six-phase process to redesign it.
Phase 1: Discover (2 weeks)
Team conducted contextual inquiry with 12 elderly users (ages 68-89) in their homes:
Observation
Frequency
Severity
Cannot read small touchscreen text
11 of 12
Critical
Forgets whether dose was taken today
9 of 12
High
Confused by “Schedule” vs “Settings” menu
8 of 12
High
Arthritic fingers miss touch targets
7 of 12
High
Cannot hear alarm in another room
6 of 12
Medium
Phase 2: Define
“How might we ensure elderly users take the right medication at the right time without requiring screen interaction?”
Success criteria: 90%+ dose adherence, zero configuration by the user, setup by caregiver in under 5 minutes.
Phase 3: Ideate (53 ideas generated)
Top 3 selected for prototyping: 1. Physical dial with colored LED indicators (no screen) 2. Voice-guided dispenser with physical confirmation button 3. Pre-filled cassette system configured by pharmacist
Phase 4: Prototype and Test
Paper prototype testing with 8 users (3 rounds of iteration):
Design Element
Round 1 Result
Change Made
Round 3 Result
Large confirmation button
6/8 found it
Made 3x larger, added raised edge
8/8 found it
Colored LED per medication
5/8 understood
Added label below each LED
8/8 understood
Audible reminder
4/8 heard it
Added escalating volume + wearable buzzer
7/8 responded
Caregiver app setup
3/8 caregivers completed
Reduced to 3 screens, added QR scan
7/8 completed
Result after 6 months pilot (200 users):
Abandonment rate: 35% reduced to 8%
Dose adherence: 62% increased to 94%
Caregiver satisfaction (SUS): 42 increased to 81
Support calls: 4.2/user/month reduced to 0.6/user/month
Putting Numbers to It
How do you calculate the business value of iterative design? Here’s the medication dispenser case in dollars.
Net benefit: $907,650 - $105,600 = $802,050 in first month post-launch (7.6× return on investment)
Key insight: The 240-hour Prototype phase (33% of timeline) delivered 87% of total value—discovering that elderly users couldn’t read small touchscreen text prevented a $1.5M revenue loss from mass-market abandonment.
viewof abandonmentBefore = Inputs.range([0,100], {value:35,step:1,label:"Abandonment rate before (%)",format: x =>`${x}%`})viewof abandonmentAfter = Inputs.range([0,100], {value:8,step:1,label:"Abandonment rate after (%)",format: x =>`${x}%`})viewof units = Inputs.range([1000,20000], {value:5000,step:500,label:"Projected units",format: x => x.toLocaleString()})viewof unitPrice = Inputs.range([99,999], {value:299,step:10,label:"Unit price ($)",format: x =>`$${x}`})
Show code
viewof supportCallsBefore = Inputs.range([0,10], {value:4.2,step:0.1,label:"Support calls/user/month (before)",format: x => x.toFixed(1)})viewof supportCallsAfter = Inputs.range([0,10], {value:0.6,step:0.1,label:"Support calls/user/month (after)",format: x => x.toFixed(1)})viewof supportCostPerCall = Inputs.range([10,100], {value:28,step:2,label:"Cost per support call ($)",format: x =>`$${x}`})viewof deploymentMonths = Inputs.range([1,12], {value:1,step:1,label:"Deployment period (months)"})
Key Insight: Adjust the sliders above to model your own project economics. Notice how small improvements in abandonment rate or support calls create disproportionate ROI gains—this demonstrates why investing in thorough user testing pays off.
Key lesson: The redesign eliminated the touchscreen entirely for daily use. Users only interact with a physical button and LED indicators. All configuration happens through the caregiver’s smartphone app. This split interface (simple physical for users, complex digital for caregivers) directly emerged from Phase 1 observations.
Interactive Quiz: Match Concepts
Interactive Quiz: Sequence the Steps
Common Pitfalls
1. Over-Engineering the Initial Prototype
Adding too many features before validating core user needs wastes weeks of effort on a direction that user testing reveals is wrong. IoT projects frequently discover that users want simpler interactions than engineers assumed. Define and test a minimum viable version first, then add complexity only in response to validated user requirements.
2. Neglecting Security During Development
Treating security as a phase-2 concern results in architectures (hardcoded credentials, unencrypted channels, no firmware signing) that are expensive to remediate after deployment. Include security requirements in the initial design review, even for prototypes, because prototype patterns become production patterns.
3. Ignoring Failure Modes and Recovery Paths
Designing only for the happy path leaves a system that cannot recover gracefully from sensor failures, connectivity outages, or cloud unavailability. Explicitly design and test the behaviour for each failure mode and ensure devices fall back to a safe, locally functional state during outages.
Label the Diagram
💻 Code Challenge
28.7 Summary
Key Takeaways:
The six-phase process provides structure without being rigid—expect to loop back frequently
Divergent thinking generates options while convergent thinking selects best solutions—both are essential
“How Might We” questions reframe problems as opportunities for innovation
Each phase has clear deliverables but the process is non-linear
Design thinking provides a human-centered framework for tackling complex IoT challenges
28.8 Knowledge Check
Quiz: Interactive Design Process
28.9 Concept Relationships
The six-phase design process integrates multiple disciplines:
This chapter covers interactive design process, explaining the core concepts, practical design decisions, and common pitfalls that IoT practitioners need to build effective, reliable connected systems.
28.11 Try It Yourself
Apply the six-phase process to your own IoT project:
Exercise 1: Run a Mini Design Sprint (3-4 hours)
Compress the process into a single session:
Phase 1 - Discover (30 min):
Interview 2-3 potential users about their needs
Document 5 key pain points they mentioned
Note direct quotes revealing unmet needs
Phase 2 - Define (20 min):
Convert top pain point into “How Might We” question
Write success criteria: “Solution succeeds if users can _____”
Phase 3 - Ideate (40 min):
Sketch 8+ solution concepts (no judgment yet)
Select top 3 for prototyping based on: feasibility, user value, novelty
Phase 4 - Prototype (60 min):
Build paper/cardboard mockup of top concept
Must be tangible enough to test (not just drawings)
Phase 5 - Test (45 min):
Test with 3 users using think-aloud protocol
Record: what worked, what confused them, surprises
Phase 6 - Iterate (30 min):
Revise prototype based on learnings
Decide: Iterate again, pivot to different concept, or advance to digital prototype
Exercise 2: “How Might We” Reframing Practice (20 min)
Reframe these problems as opportunities:
Problem Statement
How Might We Reframe
“Elderly users can’t read small screens”
“How might we make information readable from across the room?”
“Users forget to charge the device”
HMW: _____
“Setup takes 12 steps and confuses people”
HMW: _____
“Notifications overwhelm users”
HMW: _____
Exercise 3: Divergent-Convergent Practice (30 min)
Given problem: “Smart doorbell misses package deliveries”
Divergent phase (15 min): Generate 15+ ideas (no filtering) Convergent phase (15 min): Rate each idea on feasibility (1-5) and impact (1-5), select top 3 with highest score
Exercise 4: Non-Linear Process Simulation (30 min)
You’re in Phase 5 (Testing) and discover users misunderstood the core problem. Map which phase to return to:
Discovery: Users wanted X but you solved for Y → Return to Phase 1
Problem framing was wrong → Return to Phase 2
Concept works but UI is confusing → Return to Phase 4
Feature missing from prototype → Return to Phase 3 (ideate on missing feature)
Practice recognizing when to loop back - it’s a feature, not a failure.
The next chapter covers Prototyping Techniques, providing detailed guidance on low, medium, and high-fidelity prototypes for IoT systems, including a case study demonstrating the full design process in action.
