Chapters

22 IoT Deployment Failures: Power and Recovery

testing-validation
iot
deployment
failure

22.1 Start With the Situation

A warehouse deployment passes a desk test and still fails in operation. The team must trace coverage, power, protocol, and recovery evidence without treating the first visible symptom as the root cause.

22.2 Overview

This route follows larger deployment failures into battery realities, prevention controls, and recovery proof.

This is part 2 of 2. Review IoT Deployment Failures: Connectivity when you need the first route.

22.3 Learning Objectives

By the end of this chapter, you will be able to:

  • diagnose a warehouse connectivity failure
  • calculate and test battery-life assumptions
  • write prevention and recovery evidence for deployment risks

22.4 Chapter Roadmap

Follow the original sections below in order. They begin at the reviewed split boundary and keep every worked example, figure, check, and supporting banner with the section that owns it.

Project: Warehouse Inventory Tracking

Investment: $80,000 | Duration: 3 months | Outcome: Partial failure

The Setup: 500 Wi-Fi-connected inventory tags tracking pallets in a distribution warehouse.

What Went Wrong:

Expected: 99.9% uptime
Actual: 65% average connectivity
Peak hours: 30% packet loss
Result: Inventory accuracy dropped to 70%

Root Cause Analysis:

Channel Congestion

Too many clients shared one RF lane

Issue: All devices ran on the same channel.

Impact: Collision rate exceeded 40%.

AP Capacity

Per-access-point load was far too high

Issue: 500 devices were spread across only 10 APs.

Impact: 50 devices per AP exceeded the practical capacity target.

2.4 GHz Interference

Other warehouse systems occupied the same band

Issue: Forklifts used 2.4 GHz video cameras.

Impact: Constant interference reduced reliability.

Roaming

Mobility exposed handoff weaknesses

Issue: Tags moved between APs frequently.

Impact: Reconnection delays reached 5 seconds.

Lessons Learned:

Wi-Fi IoT Design Rules

Apply these controls as a connected design sequence: Capacity: Plan for max 30 IoT devices per AP (not 50+). Channels: Use 5GHz where possible, non-overlapping channels. Interference Survey: Conduct RF survey BEFORE deployment. Protocol Choice: Consider BLE mesh or Thread for moving assets. Roaming: Use 802.11r/k/v for fast roaming if available.

Better Architecture:

ORIGINAL (Failed):
[500 Tags] --Wi-Fi--> [10 APs] --> [Server]

IMPROVED (Successful):
[500 BLE Tags] --> [50 BLE Gateways] --Ethernet--> [Server]
                        |
                   No interference
                   No roaming issues
                   $40 per gateway

22.4.1 Case 3: The Matter of Protocol Mismatch

Project: Smart Building Retrofit

Investment: $200,000 | Duration: 12 months | Outcome: 18-month delay

The Setup: Retrofit 50 commercial buildings with smart lighting and HVAC using “the latest standard.”

What Went Wrong:

Trace the mismatch from decision to operational consequence. The project specified Matter before suitable devices were available, then filled the gap with four different protocols: Zigbee, Z-Wave, BLE, and a proprietary option. That fragmentation required six separate applications, and recurring firmware changes repeatedly broke compatibility. Read as a chain, the case shows why an emerging standard needs an explicit fallback and migration boundary rather than an assumption that the ecosystem will arrive on schedule.

Root Cause: Choosing emerging standards without fallback plan

Lessons Learned:

Protocol Selection Rules

Apply these controls as a connected design sequence: Do not depend solely on unreleased standards for production deployments. Have a migration path from current to future protocols. Use protocol gateways to isolate devices from cloud changes. Standardize on ONE protocol per building if possible. Reserve integration test capacity for vendor changes, commissioning, and fallback paths.

Test TessaCheckpoint: Connectivity Controls
  • You now know that connectivity failures are not only radio problems; they include field conditions, roaming behavior, gateway placement, backhaul, and fallback planning.
  • You now know to pair each story with a measured signal such as RSSI/SNR, packet delivery, retry count, join failure rate, or reconnect timing.
  • You now know to turn protocol choices into migration paths, gateway boundaries, and integration test capacity before deployment pressure arrives.


22.5 Power & Battery Failures

22.5.1 Case 4: Battery Lasted 3 Months

Project: Smart Water Meter Network

Investment: $2M | Duration: 24 months | Outcome: Mass battery replacement

The Setup: 10,000 water meters with “10-year battery life” deployed across a city.

What Went Wrong:

Datasheet claim: 10 years @ 1 msg/day
Reality: 3 months average life

Why?
- Specification: 1 message/day
- Implementation: 1 message/hour (for "better monitoring")
- Plus: 10 retries per failed message
- Plus: GPS fix every message (not needed!)
- Plus: Full power during server maintenance

Power Budget Analysis:

Messages per Day

Telemetry frequency exploded

Specified: 1 message/day

Actual: 24 messages/day

Impact: 24x more energy than planned.

TX Power

Radio configuration drifted upward

Specified: 14 dBm

Actual: 20 dBm

Impact: Roughly 4x the transmission power.

GPS

Location logic consumed the budget

Specified: Never enabled

Actual: GPS fix on every message

Impact: 100 mA for 30 seconds per reading was severe overkill.

Sleep Current

Standby power hid a firmware bug

Specified: 1 µA

Actual: 50 µA because of a bug

Impact: Standby draw was 50x higher than expected.

Putting Numbers to It

The “10-year battery” claim was based on theoretical calculations that ignored real deployment conditions. Let’s see the math that predicted 10 years and the reality that delivered 3 months:

Theoretical Daily Consumption (Datasheet):

Sleep: 1μA×23.97hr/day=0.024mAh/daySensor: 5mA×0.1sec×1/day÷3600=0.0001mAh/dayLoRa TX: 30mA×2sec×1/day÷3600=0.017mAh/dayTotal: 0.041mAh/dayBattery: 2400mAh÷0.041mAh/day=58,536days=160years!\begin{align} \text{Sleep: } & 1\,\mu\text{A} \times 23.97\,\text{hr/day} = 0.024\,\text{mAh/day}\\ \text{Sensor: } & 5\,\text{mA} \times 0.1\,\text{sec} \times 1/\text{day} \div 3600 = 0.0001\,\text{mAh/day}\\ \text{LoRa TX: } & 30\,\text{mA} \times 2\,\text{sec} \times 1/\text{day} \div 3600 = 0.017\,\text{mAh/day}\\ \hline \text{Total: } & 0.041\,\text{mAh/day}\\ \text{Battery: } & 2400\,\text{mAh} \div 0.041\,\text{mAh/day} = 58,536\,\text{days} = 160\,\text{years!} \end{align}

Actual Daily Consumption (Deployed):

Sleep: 50μA×23.0hr/day=1.15mAh/daySensor: 5mA×0.1sec×24/day÷3600=0.003mAh/dayLoRa TX: 35mA×2.5sec×24/day÷3600=0.583mAh/dayGPS fix: 100mA×30sec×24/day÷3600=20mAh/dayRetries (10× avg): 35mA×2.5sec×10×2.4/day÷3600=0.583mAh/dayTotal: 22.32mAh/dayBattery: 2400mAh÷22.32mAh/day=107days3.5months\begin{align} \text{Sleep: } & 50\,\mu\text{A} \times 23.0\,\text{hr/day} = 1.15\,\text{mAh/day}\\ \text{Sensor: } & 5\,\text{mA} \times 0.1\,\text{sec} \times 24/\text{day} \div 3600 = 0.003\,\text{mAh/day}\\ \text{LoRa TX: } & 35\,\text{mA} \times 2.5\,\text{sec} \times 24/\text{day} \div 3600 = 0.583\,\text{mAh/day}\\ \text{GPS fix: } & 100\,\text{mA} \times 30\,\text{sec} \times 24/\text{day} \div 3600 = 20\,\text{mAh/day}\\ \text{Retries (10× avg): } & 35\,\text{mA} \times 2.5\,\text{sec} \times 10 \times 2.4/\text{day} \div 3600 = 0.583\,\text{mAh/day}\\ \hline \text{Total: } & 22.32\,\text{mAh/day}\\ \text{Battery: } & 2400\,\text{mAh} \div 22.32\,\text{mAh/day} = 107\,\text{days} \approx 3.5\,\text{months} \end{align}

The GPS fix alone consumed 90% of daily energy. Had they measured instead of estimated, this would have been caught before deploying 10,000 units.

Lessons Learned:

Battery Life Realities

Apply these controls as a connected design sequence: Measure actual consumption - don’t trust calculations. Test with production firmware - development builds differ. Include retries in budget - real networks have failures. Verify sleep current - often 10-100x higher than spec. Budget for worst case - not typical case.

Interactive Power Budget Calculator:

Use the Power Budget Calculator for more advanced modeling.



Validate Power Budgets Early

Scenario: Preventing the “10-year battery lasting 3 months” failure BEFORE deployment.

The budget below needs a measurement that can resolve both long sleep intervals and brief radio peaks; a simple average can hide either contributor. Inspect Figure 22.1 before comparing the calculated energy ledger with the real device trace.

A Nordic Power Profiler Kit II board with USB connectors, current terminals, and measurement markings
Figure 22.1: A USB power profiler captures both sleep current and short radio bursts, so the theoretical budget below can be checked against the device’s real time-varying current instead of a multimeter average.

Photo: Thomas Amberg, CC BY-SA 2.0{target=“_blank” rel=“noopener”}

In Figure 22.1, start at the current-measurement terminals, then note the separate USB connections and the instrumented board under test. This arrangement lets the profiler record current against time, so sleep leakage, wake-up cost, radio bursts, and unexpected periodic work remain visible instead of collapsing into one multimeter reading. The trace supplies the physical evidence for the chapter’s running lesson: validate every important power-state assumption before scaling a battery-life promise into a deployment plan.

Step 1: Calculate Theoretical Power Budget

Device Specs (datasheet claims):

  • Microcontroller sleep: 1 µA
  • Sensor active: 5 mA for 100 ms
  • LoRa TX (14 dBm): 30 mA for 2 sec
  • Messages: 1 per hour

Math (theoretical):

Sleep power: 1 µA × 23.97 hours/day = 0.024 mAh/day
Sensor power: 5 mA × 0.1 sec × 24/day ÷ 3600 = 0.003 mAh/day
TX power: 30 mA × 2 sec × 24/day ÷ 3600 = 0.4 mAh/day
TOTAL: 0.427 mAh/day

Battery: 2400 mAh (2× AA)
Life: 2400 ÷ 0.427 = 5,621 days = 15.4 years ✓

Step 2: Measure ACTUAL Power Consumption

Equipment: Power Profiler Kit (Nordic nRF or Joulescope)

Findings:

Sleep current: 50 µA (NOT 1 µA!) - GPIO leakage, regulator quiescent current
Sensor warmup: 5 mA for 300 ms (NOT 100 ms) - datasheet showed "typical" not max
LoRa TX: 35 mA for 2.5 sec including ACK wait
Firmware bug: ADC left on, consuming 100 µA constantly
ACTUAL TOTAL: 3.8 mAh/day (8.9× higher than theory!)

Real battery life: 2400 ÷ 3.8 = 631 days = 1.7 years

Step 3: Fix Issues

GPIO Leakage

Disable all unused GPIOs

Savings: -30 µA

Regulator Loss

Switch to an ultra-low quiescent regulator (TPS62840)

Savings: -15 µA

Sensor Warmup

Pre-warm once every 10 samples

Savings: -0.5 mAh/day

ADC Bug

Disable the ADC after each read

Savings: -100 µA

LoRa Retries

Implement exponential backoff

Savings: -0.3 mAh/day

New total: 1.2 mAh/day Validated life: 2400 ÷ 1.2 = 2,000 days = 5.5 years

Step 4: Add Safety Margin

Design target: 10 years Safety factor: 2× Required: 1.2 mAh/day ÷ 2 = 0.6 mAh/day budget

Final optimizations:

  • Message every 2 hours (not 1) → -0.4 mAh/day
  • SF7 → SF8 on LoRa (better link margin, fewer retries) → -0.1 mAh/day
  • Result: 0.7 mAh/day (exceeds 10-year target with margin)

Cost: 2 days of engineering time with power profiler = $1,600 Saved: Avoiding field replacement of 10,000 devices in year 2 = ~$200,000

Key Lesson: ALWAYS measure actual power. Datasheets show “typical” or “minimum” values. Real-world deployments see 5-10× higher consumption due to:

  1. Sleep current dominated by leakage, not MCU datasheet
  2. Peripheral warmup times longer than advertised
  3. Firmware bugs (most common cause!)
  4. Environmental factors (cold weather increases battery ESR)

Tool Cost: Joulescope: $500, Nordic PPK2: $90. ROI on first project.


22.5.2 Case 5: The Solar-Powered Failure

Project: Remote Environmental Monitoring

Investment: $50,000 | Duration: 6 months | Outcome: Winter data gap

The Setup: Solar-powered air quality sensors in a northern city (52°N latitude).

What Went Wrong:

Summer: Perfect operation ✓
Fall: Intermittent outages
Winter: 3 months of no data
Spring: Sensors damaged by deep discharge

Root Cause:

Summer

Comfortable positive energy balance

Solar hours: 16 h

Panel output: 5 W average

Consumption: 1 W

Balance: +64 Wh/day

Winter

Daily deficit drained the battery

Solar hours: 6 h

Panel output: 0.5 W average

Consumption: 1 W

Balance: -21 Wh/day

Battery capacity: 50Wh. Winter deficit accumulated until batteries died.

Lessons Learned:

Solar IoT Design

Apply these controls as a connected design sequence: Design for worst month - not average. Include cloudy day buffer - 5+ days without sun. Add low-power mode - reduce consumption when low. Consider hybrid power - solar + grid backup. Protect batteries - low-voltage cutoff prevents damage.

Interactive Solar Energy Calculator:

Test TessaCheckpoint: Power Evidence
  • You now know to distrust a battery-life claim until production firmware, sleep current, wakeups, retransmission policy, and environmental behavior are measured together.
  • You now know that power cases need both a budget and a field validation plan, because solar input, cloudy-weather buffer, and maintenance access shape the real outcome.
  • You now know to record the gap between datasheet estimate and deployed behavior as a control, not just as a post-mortem anecdote.


22.6 Security Breaches

22.6.1 Case 6: The Default Password Botnet

Project: Smart Camera Network (Consumer)

Outcome: 100,000 devices compromised

The Setup: Consumer security cameras with “easy setup” shipped with default password admin:admin.

What Went Wrong:

Day 1: Cameras connected to internet
Day 3: Shodan indexed open ports
Day 7: Botnet scanning began
Day 14: 100,000 cameras compromised
Day 30: Used in DDoS attack (Mirai variant)

Root Cause Analysis:

Default Credentials

Authentication was effectively absent

Impact: trivial authentication bypass.

No Forced Change

Operators never rotated the factory secret

Impact: default passwords stayed in production.

UPnP Enabled

Home routers exposed the fleet automatically

Impact: automatic port forwarding widened the attack surface.

Unsigned Firmware

Malware could survive reboots

Impact: persistence after compromise.

Telnet Enabled

Attackers gained a direct remote shell

Impact: easy remote access for botnet operators.

Lessons Learned:

IoT Security Minimums

Apply these controls as a connected design sequence: Unique per-device credentials - printed on device, never defaults. Force password change on first use. Disable UPnP by default - require explicit enable. Signed firmware only - prevent malicious updates. Disable unnecessary services - no telnet, minimal ports. Security by design - not afterthought.

Use the Zero Trust Policy Builder to design secure policies.


22.6.2 Case 7: The Unencrypted Health Data

Project: Remote Patient Monitoring

Investment: $500,000 | Outcome: HIPAA violation, $1.5M fine

The Setup: Wearable health monitors transmitting patient vitals to cloud.

What Went Wrong:

The incident record is clearest when the failures are traced in order: Data transmitted over HTTP (not HTTPS). BLE pairing used “Just Works” (no authentication). Patient IDs in plaintext in MQTT topic names. No audit logging of data access. Data stored without encryption at rest.

Discovery: Security researcher demonstrated interception in conference presentation.

Lessons Learned:

Healthcare IoT Security

Apply these controls as a connected design sequence: TLS everywhere - no exceptions, even “internal” networks. BLE: Use Secure Connections - never Just Works for sensitive data. Anonymize identifiers - hash or encrypt patient IDs. Encryption at rest - database and backup encryption. Audit everything - who accessed what, when. Penetration test - before launch, not after breach.

Test TessaCheckpoint: Security Controls
  • You now know that default passwords, exposed services, weak pairing, plaintext identifiers, and missing audit logs are design decisions, not cleanup tasks.
  • You now know to connect credentials, TLS, BLE Secure Connections, encryption at rest, signed firmware, and audit evidence into one launch gate.
  • You now know why sensitive fleets need a documented revocation path and secure update verification before the first incident.


22.7 Scaling Issues

22.7.1 Case 8: The Million-Device Meltdown

Project: Smart Home Platform

Scale: 50,000 → 1,000,000 devices | Outcome: 4-hour outage

The Setup: Cloud platform designed for 50,000 devices, grew to 1M.

What Went Wrong:

Devices: 50K    → Platform stable
Devices: 200K   → Occasional slowdowns
Devices: 500K   → Daily degradation
Devices: 1M     → Complete outage

Root cause: Single MQTT broker, single database

Architecture Evolution:

Before comparing scale targets, inspect Figure 22.2 to locate the single shared services that turn growth into a fleet-wide outage and the boundaries introduced by the redesign.

Comparison of failed single-broker architecture versus redesigned scalable architecture showing load balancer distributing to multiple brokers, message queue for decoupling, and database shards for horizontal scaling.
Figure 22.2: Architecture evolution from single-point-of-failure design to horizontally scalable architecture with load balancing, multiple brokers, message queue, and database sharding.

Read Figure 22.2 from the failed single broker and database to the load balancer, broker pool, message queue, and database shards. The load balancer spreads connections, multiple brokers remove one process as the only ingress, the queue decouples ingestion from downstream work, and sharding divides persistent load. None of those boxes guarantees capacity by itself; together they identify the boundaries that must be load-tested. This evolution connects the million-device symptom to concrete scalability controls.

Lessons Learned:

Scalability Design Principles

Apply these controls as a connected design sequence: Design for 10x current scale - growth surprises everyone. Horizontal scaling - add nodes, not bigger nodes. Stateless services - no server affinity. Shard data - no single database bottleneck. Queue everything - decouple producers from consumers. Load test regularly - with production-like data.

Interactive Scaling Calculator:


22.8 Integration Problems

22.8.1 Case 9: The API Version Nightmare

Project: Multi-Vendor Smart Building

Duration: 18 months | Outcome: 6-month delay, 50% cost overrun

The Setup: Integrate 5 vendor systems (HVAC, lighting, access, security, energy).

What Went Wrong:

Vendor A: REST API v2.1
Vendor B: REST API v3.0 (breaking changes monthly)
Vendor C: SOAP (yes, really)
Vendor D: Proprietary binary protocol
Vendor E: "API available Q4" (arrived Q2 next year)

Integration Complexity:

HVAC ↔ Lighting

Simple estimate hid API churn

Estimated: 2 weeks

Actual: 8 weeks

Issue: Rate limiting and authentication changes.

Access ↔ Security

Protocol mismatch multiplied adapter work

Estimated: 3 weeks

Actual: 12 weeks

Issue: Incompatible protocols between vendors.

Energy ↔ All

Late vendor delivery broke the plan

Estimated: 4 weeks

Actual: 16 weeks

Issue: Vendor E missed the promised API timeline.

Read those three facts as one dependency failure: the estimate assumed a vendor API would arrive on time, the actual schedule exposed a twelve-week gap, and the missing interface blocked work across the integration plan. The lesson is not merely to add contingency time. Isolate vendor dependencies behind a contract and mock, track the promised interface as release evidence, and reopen the plan when delivery or compatibility moves. That connects schedule variance to a specific technical control.

Lessons Learned:

Integration Best Practices

Apply these controls as a connected design sequence: Verify API stability - check changelog frequency. Build abstraction layer - isolate vendor changes. Contract-first design - define interfaces before coding. Mock everything - don’t depend on vendor availability. Version everything - never break existing integrations. Plan explicit integration margin for vendor delays, protocol mismatches, and commissioning checks.

Test TessaCheckpoint: Scale and Integration
  • You now know that scaling failures can come from queue depth, session state, database writes, dashboard freshness, and support visibility, not only server capacity.
  • You now know to isolate vendor changes with contracts, mocks, versioning, abstraction layers, and explicit integration margin.
  • You now know to finish a failure review by choosing where the control will live: pre-deployment checklist, load test, staged rollout gate, monitoring alert, or architecture decision note.


22.9 Failure Prevention Checklist

Before deploying any IoT project, verify:

22.9.1 Connectivity

  • Tested in actual deployment environment
  • Accounted for seasonal/environmental changes
  • Redundant connectivity paths
  • Graceful degradation when offline

22.9.2 Power

  • Measured actual power consumption
  • Tested with production firmware
  • Battery life includes worst-case scenarios
  • Low-power modes implemented and tested

22.9.3 Security

  • No default passwords
  • Encryption in transit and at rest
  • Firmware signing implemented
  • Security audit completed

22.9.4 Scale

  • Designed for 10x current requirements
  • Horizontal scaling possible
  • Load tested with realistic data
  • Monitoring and alerting in place

22.9.5 Integration

  • All APIs verified and stable
  • Abstraction layer isolates vendors
  • Fallback plans for each integration
  • End-to-end testing complete

Match Failure Types to Root Causes

Analyze an IoT Failure Case

Place these analysis steps in the correct order.

Key Takeaway

Many IoT project failures stem from testing in ideal conditions rather than deployment environments. Test with actual terrain, weather, interference, firmware, and operating load; measure real power consumption instead of relying only on datasheet estimates; enforce unique device credentials; design with growth headroom; and plan explicit integration margin.


For Kids: Meet the Sensor Squad!

The Case of the Silent Sensors

Temperature Terry was so excited! He and 199 of his friends were placed across a huge farm to watch over the crops. “We will send messages about the soil every day!” cheered Sammy.

But then the corn grew tall — really, REALLY tall. “Hey, I cannot hear the gateway anymore!” called Sammy from behind the towering stalks. the microcontroller tried turning up the signal power, but the battery groaned, “If you do that, I will run out of energy in a week!”

the LED blinked a warning pattern. “We should have tested when the corn was fully grown, not just when the field was empty!”

The lesson Sammy learned: Test your IoT project in the REAL conditions it will face — not just the easy ones. Plants grow, weather changes, and what works in a lab might not work in a field. Plan ahead and keep a backup path!

Can you think of something in your home that works differently in summer versus winter?


Knowledge Check: IoT Failure Analysis

IoT Failure Case Relationships
Connectivity Failures

Relates to: Protocol Selection + Field Testing

LoRaWAN range failures happen when lab testing ignores terrain, vegetation, and interference in the real site.

Power Budget Miscalculations

Relates to: Sleep Modes + Transmission Frequency

Batteries lasting months instead of years usually trace to missing deep sleep or far more transmissions than budgeted.

Security Breaches

Relates to: Default Credentials + Encryption

Mirai-style compromise disappears when fleets use unique per-device credentials and modern encryption hygiene.

Scaling Issues

Relates to: Cloud Architecture + Load Testing

Systems that look stable at 100 devices collapse at 10,000 without queueing, sharding, and horizontal scale.

Integration Problems

Relates to: API Versioning + Legacy Systems

Retrofit programs fail when teams assume modern REST interfaces can cleanly meet old Modbus or proprietary systems.

Cross-module connection: Prevention checklists map to design best practices. See Protocol Selection Framework for connectivity, Energy-Aware Harvesting for power, and Zero Trust Policy Builder for security.

Common Pitfalls

Extract Failure Principles

Reading case studies as interesting stories without extracting reusable principles provides entertainment but not protection. For each case study, explicitly ask: “What general design rule would have prevented this?” Convert each case into a checklist item applicable to your own IoT projects.

Failures Hit Experienced Teams

Famous IoT failures have occurred at well-funded companies with experienced engineers. The common factor is not inexperience — it is specific architectural blind spots (no OTA update mechanism, inadequate security threat modeling, untested failure scenarios). Study failures with the assumption that your project could make the same mistakes.

3. Focusing Only on Technical Failures

Many IoT project failures are organizational or process failures: inadequate requirements gathering, insufficient field testing, poor user research, or missing operational procedures. Technical solutions to organizational problems rarely succeed. Analyze the full sociotechnical system, not just the hardware and software.

Label the Diagram

22.10 Try It: Build a Failure Review Note

Choose one case from this page. Write four lines: the failed assumption, the measured signal that would reveal it, the prevention control, and the next course page you would use to practice the underlying skill. Keep the note specific enough that another learner could run the check.

22.11 See Also

22.12 Summary

This chapter uses failure case studies to connect IoT concepts with real design and operations mistakes. Case studies help learners reason about causes, consequences, safeguards, and better review habits.