This is a hands-on lesson. The premise is simple: you have one energy-metering outlet, plugged into a non-critical device, say a desk, a lamp, chargers, or an audio setup. You connect it to Home Assistant, check power and energy, add it to the Energy Dashboard, calculate a cost, and only after watching it for a while do you consider automatic shutoff.

Plan on about 65 to 75 minutes. Some of that time is physically connecting the hardware and waiting for data. Don't rush it. In the energy module, understanding what you're looking at on the chart matters more than quickly pasting in five automations.

What to pick for your first measurement

The best first measurement is a device you can safely unplug without causing a household crisis. A desk, a lamp, a test monitor, a spare router, chargers. Don't start with a fridge, an oven, a heat pump, or a server the whole home depends on.

A Zigbee outlet with energy metering

A Zigbee outlet with energy metering is a popular first step. It works through a Zigbee coordinator, for example via the ZHA or Zigbee2MQTT integration. Once paired, Home Assistant usually gets a switch entity, a power entity in W, and sometimes an energy entity in kWh. Entity names depend on the manufacturer and integration, so below I use example names you'll swap for your own.

Typical entities after pairing look roughly like this: switch.office_outlet, sensor.office_outlet_power, sometimes also sensor.office_outlet_energy. If you only have power, Lesson 3 already showed you how to build energy with Integration. If you have ready-made energy in kWh, use it directly.

Shelly Plug and Shelly Plus Plug

An alternative to Zigbee is the Shelly Plug or Shelly Plus Plug. It's a Wi-Fi outlet with a local Shelly integration in Home Assistant. It usually gives you power, energy, a switch, and tends to update its data reasonably often. For many people, this is the simplest path to a first measurement if they don't already have a Zigbee network.

After adding a Shelly through the Shelly integration, check the entities in Developer Tools. You'll often see something like switch.shellyplug_s_office, sensor.shellyplug_s_office_power, and sensor.shellyplug_s_office_energy. The rest of this lesson works the same regardless of brand. What matters is correct entities, not the logo on the box.

How to check power and energy in Home Assistant

Before you build any automations, watch the data by hand for a few days. That's the heart of this lesson. Go into Developer Tools, States, type in the entity name, and look at values at different moments: when the device is running, when it's off, when it's in standby.

Is an outlet's measurement accurate

A metering outlet isn't a certified billing meter. It's usually good enough for household analysis, but don't treat it like lab equipment. A few percent of difference is normal, especially at low draw or with cheap outlets. What mostly matters to us is the trend: whether a device uses a lot, has standby draw, and whether a behavior change shows a visible effect.

How to add the device to the Energy Dashboard

In Lesson 2 you configured the Energy Dashboard. Now you're adding a single device. Go into the energy source configuration, choose the individual devices category, and point it at your energy entity in kWh. The entity needs the correct device class, state class, and unit. If your outlet only gives you power, first build energy with Integration from Lesson 3.

A daily counter and cost: a ready-made YAML package

Below is a complete helper example for an office. It assumes you already have an energy entity in kWh and an energy price from Lesson 3. Swap in your own names. This isn't one giant file to paste in without thinking. It's a template you adapt to your own outlet.

A daily counter and daily cost

utility_meter:
  office_energy_daily:
    source: sensor.office_outlet_energy
    name: "Office Energy Daily"
    cycle: daily

template:
  - sensor:
      - name: "Office Daily Cost"
        unique_id: office_daily_cost
        unit_of_measurement: "USD"
        availability: >
          {{ states('sensor.office_energy_daily') not in ['unknown', 'unavailable', 'none']
             and states('input_number.energy_price_kwh') not in ['unknown', 'unavailable', 'none'] }}
        state: >
          {{ (states('sensor.office_energy_daily') | float
              * states('input_number.energy_price_kwh') | float) | round(2) }}

If your outlet only has power, swap the utility_meter's source for your Integration energy entity, for example sensor.office_energy_from_power. If the outlet's energy reading resets every day, a monthly utility_meter won't work correctly. In that case, treat the device's daily counter as information, not as the foundation of your whole system.

How to spot standby draw

Standby is when a device is technically on but draws very little power over a long stretch of time. Don't guess a threshold blindly. Watch first. See how many watts the outlet shows when the desk is working normally, and how many when everything's supposedly asleep but the outlet is still switched on.

Only then set a threshold. For many desk setups, a reasonable starting point is around 10 to 20 W sustained over a while, but your threshold might differ. A monitor, chargers, and a router can all raise the draw even on a desk that's technically "off."

A simple standby sensor

template:
  - binary_sensor:
      - name: "Office Standby"
        unique_id: office_standby
        icon: mdi:power-sleep
        availability: >
          {{ states('sensor.office_outlet_power') not in ['unknown', 'unavailable', 'none'] }}
        state: >
          {{ is_state('switch.office_outlet', 'on')
             and states('sensor.office_outlet_power') | float < 15
             and states('sensor.office_outlet_power') | float > 0 }}
        delay_on: "00:10:00"
        delay_off: "00:02:00"

You can later show this binary sensor on a dashboard as a simple standby status. In the shutoff automation we'll use binary_sensor.office_standby itself, so the condition stays consistent with the standby definition (above 0 W and below the threshold), rather than a plain below: 15.

Notify first, don't switch off first

Once you detect standby, don't switch off right away. Send a notification first. That way you'll see whether the automation fires too often, and whether it would switch off something you don't actually want switched off. If you went through the phone module in this course, you already have the notify basics. Here we use them in the context of energy.

A notification for extended standby

automation:
  - alias: "Office: standby notification"
    description: "Sends an alert when draw stays low for 30 minutes"
    mode: single
    triggers:
      - trigger: numeric_state
        entity_id: sensor.office_outlet_power
        below: 15
        for:
          minutes: 30
    conditions:
      - condition: state
        entity_id: switch.office_outlet
        state: "on"
    actions:
      - action: notify.mobile_app_your_phone
        data:
          title: "Office: standby"
          message: >
            The outlet has been drawing {{ states('sensor.office_outlet_power') }} W
            for 30 minutes. Check if something can be switched off.

Watch for a week how often you get this notification. If it arrives daily around the same time and makes sense, that's a good sign standby draw genuinely exists. If it fires every hour from random power fluctuations, raise the threshold or lengthen the for duration.

Automatic shutoff only after observation

Only once you know standby is real and the notifications make sense should you consider an automatic shutoff. And even then, give yourself an override. The simplest way is an input_boolean that's off by default. You decide when to let Home Assistant switch the outlet off without your hand on it.

An override for automatic shutoff

input_boolean:
  office_auto_shutoff:
    name: "Office: Automatic Standby Shutoff"
    icon: mdi:power-plug-off
    initial: false

A safe shutoff after extended standby

automation:
  - alias: "Office: switch off after extended standby"
    description: "Switches off the outlet after two hours of confirmed standby"
    mode: restart
    triggers:
      - trigger: state
        entity_id: binary_sensor.office_standby
        to: "on"
        for:
          hours: 2
    conditions:
      - condition: state
        entity_id: input_boolean.office_auto_shutoff
        state: "on"
      - condition: state
        entity_id: switch.office_outlet
        state: "on"
      - condition: template
        value_template: >
          {{ states('sensor.office_outlet_power') not in ['unknown', 'unavailable', 'none'] }}
    actions:
      - action: switch.turn_off
        target:
          entity_id: switch.office_outlet
      - delay:
          seconds: 2
      - condition: state
        entity_id: switch.office_outlet
        state: "off"
      - action: notify.mobile_app_your_phone
        data:
          title: "Office switched off"
          message: "The outlet was switched off after two hours of standby."

Safety and common sense

Measuring one device is safe only if you treat it like a small lab experiment, not a way to shut down the whole house. A metering outlet doesn't replace your utility meter. A shutoff automation doesn't replace good judgment. Before you switch anything off automatically, work out whether the saving makes sense against the price of the outlet and the household's comfort.

Common mistakes

Assignment: your first real device measurement

Key takeaways

What's next

In Lesson 5 we'll go from a single outlet to measuring the whole home: a Shelly 3EM, DIN rail meters, current transformers, and safety when working near your breaker panel. That's a completely different scale from a desk on a Zigbee outlet, but it's built on the same foundation: correct data, understanding flows, and common sense over speed.

If you finish this lesson with one working device measurement, a daily counter, and at least one sensible standby notification, you've taken your first real step in the energy module. The foundation from Lessons 1 through 3 just got a body.