Life logging and custom dashboards

Why create your own records?

Once you have a smart home, you notice an odd gap: sensors can record temperature, humidity, battery levels, and whether a door is open, yet many of the things that matter in daily life have no sensor.

• Was the balcony air purifier’s filter last replaced in March or April? No one remembers.
• How much have water, electricity, and gas cost this month? You may not know until the bills arrive, when it is too late to adjust.
• How long has it been since the aquarium water was changed? Relying on memory often means noticing only when the water turns cloudy.
• A family member leaves “Do not run the dishwasher today” on the refrigerator, but you never enter the kitchen.

These situations have one thing in common: the information is in someone’s memory, not in a system. Put it into Home Assistant and you can retain a timeline, create charts, and receive reminders when something is due.

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

1. Turn anything into a recordable entity

   Match numbers, text, options, dates, and counts to the appropriate helper for each recording need.

2. Let the record draw itself into a chart

   Understand why some values support long-term trend charts while others do not, and learn how to bridge the gap.

3. Process raw numbers into meaningful metrics

   Use Utility Meter to calculate monthly usage automatically, and use Template sensors to calculate the days since the last maintenance.

4. Create a really useful dashboard

   Use the Sections layout and conditional cards to tailor what phones and tablets display.

Five helpers and what each one records

Create helpers under Settings → Devices & services → Helpers, then select Create helper in the lower-right corner. The following five types are the most useful for record keeping.

What is the difference between a Number and a Counter?

Both hold numbers, but they suit different kinds of input:

Actions you will use

Use this table as a quick reference when writing automations or scripts. Older documentation called these “Services”; they are now called “Actions,” and the YAML key has changed from service: to action:.

Hands-on: Track today’s water in five minutes

Start with a simple example: add a dashboard control that records each glass of water and resets the count at midnight.

1. Create a Counter

   Go to Settings → Devices & services → Helpers, select Create helper, and choose Counter. Name it “Water today,” set the icon to mdi:cup-water, the minimum to 0, and the step to 1. Leave the remaining settings at their defaults, then select Create.

2. Confirm its entity ID

   Open the new helper and check its entity ID. If the generated ID is unclear, change it to a readable value such as counter.water_cups_today. Chapter 4 explains naming rules and the implications of changing an ID.

3. Add it to the dashboard and enable its controls

   Return to the dashboard, select Edit in the upper-right corner, and then select Add card. Search for “Water today” and choose a Tile card. One detail often causes confusion: a Tile card displays only the number by default; it does not include increment or decrement buttons. In the card editor, scroll to Features, add Counter actions, and choose the controls to display: increment, decrement, and reset. Save the card to make the controls appear.

4. Create an automation that resets the counter at midnight

   Go to Settings → Automations & scenes → Create automation, switch to YAML mode, and paste the following configuration. If the trigger-condition-action structure is unfamiliar, review Chapter 8.

5. Test

   In the automation editor, select Run and confirm that the counter returns to 0. If it does, the complete workflow is working.

alias: Reset daily water count at midnight
triggers:
  - trigger: time
    at: "00:00:00"
conditions: []
actions:
  - action: counter.reset
    target:
      entity_id: counter.water_cups_today
mode: single

In YAML mode, the Tile card looks like this. To add more counters later, copy it and change the entity:

type: tile
entity: counter.water_cups_today
name: Water today
features:
  - type: counter-actions
    actions:
      - increment
      - decrement
      - reset

Example 1: Everyday habit tracking

How the three helpers divide the work

For weight, use an input box rather than a slider. Dragging a slider precisely to 62.4 is awkward; typing the value is much faster. Under Display mode, choose Input box. The kilogram range shown here is only an example; use the unit and range appropriate to your measurement system.

Reset the workout count every Monday

alias: Reset the workout count every Monday
triggers:
  - trigger: time
    at: "05:00:00"
conditions:
  - condition: time
    weekday:
      - mon
actions:
  - action: counter.reset
    target:
      entity_id: counter.workout_count
mode: single

Arrange it on the dashboard

Place three cards in one section: two Tile cards for water and workouts, plus a Gauge card for today’s water count. A Gauge’s min defaults to 0 and its max defaults to 100, so adjust the range to suit your use.

type: gauge
entity: counter.water_cups_today
name: Water today
unit: glasses
min: 0
max: 8
needle: true
segments:
  - from: 0
    color: var(--error-color)
  - from: 3
    color: var(--warning-color)
  - from: 6
    color: var(--success-color)

Want to see long-term trends? Read the next step first

To chart a value over three months, account for this limitation: the helper does not produce long-term statistics. Adding input_number.weight directly to a Statistics graph card therefore reports that statistics are unavailable. The “Derived values” section shows the required sensor pattern.

Example 2: Household spending and meter readings

A. Record an expense as it occurs

Use two Number helpers and one script: one helper stores the new entry, the other stores the monthly total, and the script adds the entry to the total.

1. Create three Number helpers

   Create input_number.expense_entry for one expense and input_number.expense_month_total for the running monthly total. Choose a maximum appropriate to your currency instead of treating 100000 as universal, and choose a step of 1 or the smallest denomination you plan to enter. Use Input box mode. In these examples, local currency means the currency code or symbol you use. A code such as USD or EUR is unambiguous; a symbol such as $ or € is shorter but may be shared by several currencies. Also create input_number.expense_last_month with the same settings as the total. The third helper is used by the monthly close-out automation below.

2. Create a script that adds the entry

   Go to Settings → Automations & scenes → Scripts, create a script, switch to YAML mode, and paste the following configuration. Chapter 10 explains script fields and execution modes.

3. Add the script to a dashboard card

   Add an Entities card to the dashboard and place both Number helpers and the script on it. Enter a value, run the script, confirm that the total increases, and check that the entry resets.

4. Close out the total automatically on the first of each month

   The following automation first copies the current month’s total to “last month,” then resets the current total to zero. Scheduled times follow the time zone configured in Home Assistant.

alias: Record an expense
sequence:
  - action: input_number.set_value
    target:
      entity_id: input_number.expense_month_total
    data:
      value: >-
        {{ states('input_number.expense_month_total') | float(0)
           + states('input_number.expense_entry') | float(0) }}
  - action: input_number.set_value
    target:
      entity_id: input_number.expense_entry
    data:
      value: 0
mode: single

alias: Close out expenses on the first of each month
triggers:
  - trigger: time
    at: "00:05:00"
conditions:
  - condition: template
    value_template: "{{ now().day == 1 }}"
actions:
  - action: input_number.set_value
    target:
      entity_id: input_number.expense_last_month
    data:
      value: "{{ states('input_number.expense_month_total') | float(0) }}"
  - action: input_number.set_value
    target:
      entity_id: input_number.expense_month_total
    data:
      value: 0
mode: single

B. Enter water, electricity, and gas meter readings manually

If your utility provider does not expose readings digitally, enter each meter’s cumulative reading in a Number helper and let Home Assistant calculate usage for each billing period.

If you already have a smart meter, energy sensor, or smart plug that reports energy, skip manual entry and use that sensor as the Utility Meter source.

Example 3: Device maintenance records and automatic reminders

These tasks all follow the same pattern: record the most recent date → calculate the elapsed days → send a reminder when the interval is exceeded. Once configured, the pattern works for filters, aquarium water changes, air-conditioner cleaning, toothbrush-head replacement, and more.

1. Create a Date helper

   Go to Settings → Devices & services → Helpers → Create helper → Date and/or time. Name it “Filter last changed,” enable Date only, and leave Time disabled. Use the entity ID input_datetime.filter_last_change.

2. Create a Template sensor that counts days

   Go to Settings → Devices & services → Helpers, select Create helper, choose Template, then Sensor. Name it “Days since filter change,” paste the template below into the state template, and set the unit of measurement to days. After creating it, change the entity ID to sensor.filter_days_since for the later automation.

3. Create a “Changed today” button

   Create a script that sets the helper to today’s date. After replacing the filter, one press records the change without opening a calendar.

4. Automate reminders

   The automation checks every day at 9 a.m. and sends a notification once 90 days have elapsed. See Chapter 7 for notification setup.

{{ ((now().timestamp()
     - as_timestamp(states('input_datetime.filter_last_change'), 0))
     / 86400) | int(0) }}

alias: The filter has been replaced
sequence:
  - action: input_datetime.set_datetime
    target:
      entity_id: input_datetime.filter_last_change
    data:
      date: "{{ now().strftime('%Y-%m-%d') }}"
mode: single

alias: Filter replacement reminder
triggers:
  - trigger: time
    at: "09:00:00"
conditions:
  - condition: numeric_state
    entity_id: sensor.filter_days_since
    above: 89
actions:
  - action: notify.persistent_notification
    data:
      title: Living-room air purifier
      message: >-
        The filter has been in use for {{ states('sensor.filter_days_since') }} days. It is time to replace it.
mode: single

A Markdown card provides a simple at-a-glance maintenance summary. Its content field accepts templates directly:

type: markdown
title: Maintenance status
content: |-
  | Item | Elapsed | Interval |
  |---|---|---|
  | Air-purifier filter | {{ states('sensor.filter_days_since') }} days | 90 days |
  | Aquarium water change | {{ states('sensor.tank_days_since') }} days | 14 days |
  | AC cleaning | {{ states('sensor.ac_days_since') }} days | 180 days |

Example 4: Notes and a household message board

Text helpers for short messages

A Text helper is enough for a short message such as “Do not run the dishwasher today.” Its maximum length defaults to 100 and can be increased to 255, the hard limit for a Home Assistant entity state. Add the helper to an Entities card so you can edit it directly from the dashboard.

Add a Date and/or time helper to record when the message was changed, using an automation like this:

alias: Record when the message changes
triggers:
  - trigger: state
    entity_id: input_text.family_message
conditions: []
actions:
  - action: input_datetime.set_datetime
    target:
      entity_id: input_datetime.family_message_time
    data:
      datetime: "{{ now().strftime('%Y-%m-%d %H:%M:%S') }}"
mode: single

Use to-do lists, not text fields, for lists

Shopping lists, repair lists, and other changing collections are awkward in a text field, and 255 characters fill up quickly. Home Assistant includes the Local To-do integration. Its data remains on your Home Assistant system and requires no cloud account, but “local” does not mean private from Home Assistant users who can access the list or from anyone who obtains a backup.

1. Add the integration

   Go to Settings → Devices & services → Add integration, search for Local to-do, and follow the on-screen instructions to create a list such as “Shopping list.”

2. Create additional lists

   You can add multiple lists through the same integration. Start with at least two, such as “Shopping” and “Home repairs.”

3. Add a list to the dashboard

   Edit the dashboard, select Add card, find the To-do list card, and choose the list you created. You can add items and mark them complete directly from a phone.

4. Let automation help you add items

   Use the todo.add_item action. For example, the filter reminder can both notify you and add “Buy a filter” to the shopping list.

actions:
  - action: todo.add_item
    target:
      entity_id: todo.shopping_list
    data:
      item: Buy a purifier filter

Other available actions include todo.update_item (edit or complete an item), todo.remove_item (delete an item), todo.get_items (retrieve list contents), and todo.remove_completed_items (remove completed items).

Let the record grow into a chart

Four card types cover most recording needs. The key is to know which data each card accepts.

History graphs: inspect the short term

type: history-graph
title: Water and exercise over the past two days
hours_to_show: 48
entities:
  - entity: counter.water_cups_today
    name: Water
  - entity: counter.workout_count
    name: Exercise

Statistics graphs: inspect the long term

One prerequisite determines whether an entity can appear in a long-term statistics graph:

Use a template sensor to expose the helper’s value with a state class. Although you can create template sensors from the Helpers page, Home Assistant documentation says that the UI offers “a relatively streamlined subset of options” and may not expose every advanced field. The examples here therefore use configuration.yaml for more consistent access to those fields:

template:
  - sensor:
      - name: "Weight record"
        unique_id: weight_record
        unit_of_measurement: "kg"
        device_class: weight
        state_class: measurement
        state: "{{ states('input_number.weight') | float(0) }}"
        availability: "{{ is_number(states('input_number.weight')) }}"

Save the file, open Tools → YAML from the sidebar, and reload Template entities. The new entity will then appear as sensor.weight_record. Starting with version 2026.8, “Developer tools” is named “Tools”; older versions use the former name in the same location. Add the new sensor to a Statistics graph card:

type: statistics-graph
title: Weight trend
days_to_show: 90
chart_type: line
period: day
stat_types:
  - mean
entities:
  - entity: sensor.weight_record
    name: Weight

Markdown: turn several values into a readable summary

type: markdown
title: This month’s summary
content: |-
  ### This month so far

  - Total spending **{{ states('input_number.expense_month_total') | int(0) }}** in local currency
  - Same period last month: {{ states('input_number.expense_last_month') | int(0) }} in local currency
  - Electricity meter: {{ states('input_number.meter_electricity') }} kWh
  - Last meter reading: {{ states('input_datetime.meter_read_date') }}

Process raw numbers into meaningful metrics

Raw values, such as cumulative meter readings or individual weight entries, are not always meaningful on their own. Home Assistant provides several helpers that derive useful metrics without requiring a custom program.

Utility Meter: calculate monthly usage automatically

Utility Meter needs a sensor whose value continually increases as its source. For manual readings, use a Template sensor to expose the input_number value with the total_increasing state class:

template:
  - sensor:
      - name: "Cumulative meter reading"
        unique_id: meter_electricity_total
        unit_of_measurement: "kWh"
        device_class: energy
        state_class: total_increasing
        state: "{{ states('input_number.meter_electricity') | float(0) }}"

Then go to Settings → Devices & services → Helpers → Create helper → Utility Meter and configure these fields:

After creation, you will have an additional sensor such as “Monthly energy” (the exact name depends on your configuration). Add it to a Tile card to display the kilowatt-hours used so far this month. The Utility Meter resets at the start of the next month.

For a bar chart of monthly usage, add the continuously increasing source sensor to a Statistics graph card and use change to calculate each month’s consumption:

type: statistics-graph
title: Monthly energy use
days_to_show: 365
chart_type: bar
period: month
stat_types:
  - change
entities:
  - sensor.meter_electricity_total

For a manual reset or correction, use utility_meter.reset to reset the meter to zero or utility_meter.calibrate to set a specified value.

Statistics helper: average

From the Helpers page, create a Statistics helper and select the required characteristic. Numeric sensors support the mean, median, sum, change, sample count, maximum, minimum, and other characteristics.

Custom dashboards: arrange records to suit your needs

With the data in place, the next step is presentation. New dashboard views default to the Sections layout, which is well suited to this purpose.

How to think about the Sections layout

Think of it as a noticeboard: the view is a grid containing sections, and each section contains cards. Unlike the older Masonry layout, you do not need vertical-stack cards to force cards into groups; each section is already a grouping unit.

A suggested layout for a “Life log” view

1. Add new view

   In the dashboard’s upper-right corner, select Edit, then select + at the right end of the tab bar. Choose the Sections view type, use “Life log” as the title, and set the maximum number of columns to 3.

2. First section: “Today”

   Add a Heading card titled “Today,” followed by a water Counter tile, a workout Counter tile, and a water Gauge. Place this frequently used section at the top.

3. Second section: “This month”

   Add a Heading card titled “This month,” followed by the Entities card for monthly spending, the expense-entry script button, and the monthly energy Statistics graph.

4. Third section: “Maintenance and to-do”

   Add the maintenance-status Markdown card, the shopping To-do list card, and the household-message Entities card.

5. Fourth section: “Trends”

   Add the weight chart and other long-term Statistics graphs. Because this section needs less frequent attention, place it at the bottom.

type: heading
heading: Today
icon: mdi:calendar-today
heading_style: title
badges:
  - type: entity
    entity: counter.water_cups_today
  - type: entity
    entity: counter.workout_count

Conditional cards: hide what is not currently relevant

A Conditional card disappears when its conditions are not met. Supported condition types include state, numeric_state, screen, user, location, and time; combine them with and, or, and not.

type: conditional
conditions:
  - condition: numeric_state
    entity: sensor.filter_days_since
    above: 89
card:
  type: markdown
  content: The filter is more than 90 days old. Remember to replace it.

Phones and tablets see different things

The screen condition accepts a CSS media-query string, allowing detailed charts on large screens and compact alternatives on small screens.

type: conditional
conditions:
  - condition: screen
    media_query: "(min-width: 1024px)"
card:
  type: statistics-graph
  title: Full trend
  days_to_show: 365
  chart_type: line
  entities:
    - sensor.weight_record

type: conditional
conditions:
  - condition: screen
    media_query: "(max-width: 1023px)"
card:
  type: gauge
  entity: counter.water_cups_today
  name: Water today
  min: 0
  max: 8

The user condition can also show each household member a personal record card. Chapter 5 covers user accounts.

Community cards worth installing

Built-in cards are sufficient for most life-log dashboards, so learn them before adding third-party code. If you need capabilities they do not provide, install community cards through HACS as described in Appendix A. The following cards are commonly used, but their maintenance schedules vary widely: some receive monthly updates, while others may go more than a year without a release. “Common” does not mean “guaranteed to work with your version.”

Export and save records

As records accumulate, you may want to analyze them elsewhere or protect them against database failure. Use three layers of protection:

Level 1: Download a CSV

1. Open the History panel

   Open History from the sidebar. This is where you graph and download numeric values. The separate Activity panel—called Logbook in older versions—is an event log showing who did what and when. From version 2026.8, Activity has its own CSV download, but use History when exporting numeric measurements.

2. Select entities and a time range

   Select the area, device or entity you want, and then set the time range.

3. Download the data

   Select Download data in the upper-right corner to create a CSV that you can open in a spreadsheet.

Level 2: Include the database in backups

Home Assistant’s default database is home-assistant_v2.db in the configuration directory, and built-in backups include it. Chapter 9 covers backup settings and restoration. If these records matter, enable a regular automatic backup schedule.

Level 3: Keep a separate copy of important totals

For additional resilience, make the monthly close-out automation write totals to a to-do list or send them in a notification. If the database fails, you will still have a separate written record.

actions:
  - action: todo.add_item
    target:
      entity_id: todo.household_log
    data:
      item: >-
        {{ now().strftime('%Y-%m') }} spending:
        {{ states('input_number.expense_month_total') | int(0) }} in local currency

Troubleshooting

1. A helper resets to zero after a restart

   Number, Text, Dropdown, and Date and/or time helpers normally restore their pre-restart values. Counters also have a restore option, enabled by default. If a YAML-defined helper resets, check for initial: that value takes precedence over restoration and overwrites the saved state at startup. Remove initial if you want restoration. An improper shutdown, such as disconnecting power, can also prevent the latest state from being written.

2. The statistics graph card says there is no data

   The usual cause is adding a helper directly. Helpers have no state class and do not generate long-term statistics. Follow “Let the record grow into a chart” to expose the helper through a Template sensor with state_class: measurement. If the graph remains empty, wait until after the next hourly aggregation for the first long-term statistic.

3. The history chart is empty or has only one straight line

   First make sure Recorder has not excluded the entity. A value that never changes correctly appears as a straight line. If the History range exceeds 10 days, the panel switches to long-term statistics; a helper without long-term statistics then appears blank. To inspect the helper’s raw state changes, keep the range within 10 days and use a suitable hours_to_show value on the card.

4. Cards are cut off or squished on your phone

   Confirm that the view uses Sections, then check whether too many items are packed into one stack. For a long Markdown card, add card_size to reserve enough height. Markdown tables can overflow narrow screens, so use a list rather than a table on mobile layouts.

5. The Template sensor exists in YAML but its entity is missing

   After changing configuration.yaml, open Tools (called “Developer tools” before 2026.8) → YAML and reload Template entities. If the entity still does not appear, run Check configuration and inspect the YAML indentation. Also check whether configuration.yaml already contains a template: block. YAML accepts only one effective top-level key of that name, so add the sensor to the existing block rather than creating a duplicate.

6. Condition cards never show up

   A Conditional card appears only when all conditions are met. For numeric_state, above is strictly greater than: above: 90 does not match a value of exactly 90, so use above: 89 here. For a screen condition, enclose the complete media-query string in quotation marks.

7. The script runs but the total does not change

   Check whether the calculated result exceeds the input_number maximum; Home Assistant rejects values above that limit. Use a conversion with a fallback, such as | float(0), so a temporarily unavailable entity does not make the whole template fail.

FAQ