Short Answer: Find Why Home Assistant Is Not Re-Rendering It

A Home Assistant template sensor is not a spreadsheet cell that recalculates continuously. It updates when Home Assistant can see that something relevant changed. An entity is the named sensor, switch, light, helper, or other object Home Assistant shows in dashboards and automations. For a normal state-based template, the usual update reason is that an entity state inside the template changed. For a template that uses now(), Home Assistant re-renders on a minute cadence. For a trigger-based template, the template updates only when one of the triggers you wrote fires.

So the fastest fix is this order: prove the template renders in Developer Tools > Template, check whether the real entity has a log error, decide whether it is state-based or trigger-based, then add the missing update source. If it only changes after Reload template entities, Home Assistant probably has no watched state or trigger telling it to run again. If it shows unknown or unavailable, the template probably hit a missing entity, a bad attribute, or a numeric conversion error. If it disappeared after a recent update, check the 2026.6 legacy template syntax removal before rewriting the math.

That sounds technical, but the house-level meaning is simple: Home Assistant needs both a correct formula and a clear reason to run that formula at the right time.

What the Symptom Usually Means

Symptom Most likely cause What to do first
Works in Developer Tools but dashboard value is stale The editor proves the expression can render once. It does not prove the entity has an update trigger. Check whether the template reads a real entity state, uses now(), or has explicit triggers.
Only updates after reloading template entities No watched state changes, or a trigger-based template is missing the trigger that should update it. Add a state, time_pattern, event, homeassistant start, or manual update trigger that matches the real need.
Shows unknown or unavailable An input entity is missing, unavailable, or a filter such as float received text it cannot safely convert. Print the raw inputs, add has_value() or an availability check, and use numeric defaults intentionally.
Stopped after Home Assistant 2026.6 Old sensor: - platform: template style YAML no longer loads for legacy template entities. Move the entity to the modern top-level template: syntax, then restart and read logs.
Updates too slowly for history or Grafana The value does not change often, so Home Assistant does not create new state rows just to repeat the same value. Decide whether you need a real state change, a statistics helper, or a trigger-based sensor with a sane interval.

State-Based vs Trigger-Based Templates

A state-based template sensor is the right default for simple household values: average room temperature, a combined door state, a power calculation, or a display-friendly version of another sensor. It watches the entity states it reads and updates when those states change.

A trigger-based template sensor is for cases where you want to decide exactly when the template runs. Home Assistant's template integration docs are clear that trigger-based template entities do not automatically update just because a referenced state inside the template changed. The triggers are the schedule. That is useful, but it also means a missing trigger makes the sensor look frozen.

Use this rule of thumb:

  • Use state-based when the template reads normal entity states and should update when those entities change.
  • Use trigger-based when the source is time, events, startup, MQTT payloads, calendar changes, button events, attribute-only changes, or helper functions that Home Assistant cannot infer reliably.
  • Do not mix them casually. Adding a trigger changes the mental model. Once you make it trigger-based, the listed triggers control updates.

The First Five Checks

  1. Open Developer Tools > Template. Paste only the state expression. Print each raw input first, then add filters and math one piece at a time.
  2. Open Settings > System > Logs. Search for the template entity name and the exact error. Home Assistant's template error docs list common messages such as undefined variables, missing attributes, text-number math, and bad YAML quoting.
  3. Check the input entities in Developer Tools > States. Make sure the entity IDs are exact, the entities are not unknown, and the values are changing when you expect.
  4. Check Repairs after a version update. Home Assistant 2026.6 removed legacy template entity syntax after a six-month deprecation period. If the entity no longer loads, update syntax before debugging update cadence.
  5. Decide whether the update source is visible. If the template reads no state and has no trigger, it may render once at startup and then sit there.

Working Patterns to Copy

Simple state-based template

This is the boring path. It watches the listed states and updates when they change.

template:
  - sensor:
      - name: "Upstairs Average Temperature"
        unique_id: upstairs_average_temperature
        unit_of_measurement: "deg F"
        state: >
          {% set bedroom = states('sensor.bedroom_temperature') | float(0) %}
          {% set hallway = states('sensor.hallway_temperature') | float(0) %}
          {{ ((bedroom + hallway) / 2) | round(1) }}

This is fine if zero is a safe fallback in your situation. For temperature, zero is usually not a safe hidden value, so the next pattern is better.

Safer numeric template with availability

Availability means the template honestly reports unavailable when the inputs are not trustworthy. That is better than making a room look like it is zero degrees because a battery sensor dropped offline.

template:
  - sensor:
      - name: "Upstairs Average Temperature"
        unique_id: upstairs_average_temperature
        unit_of_measurement: "deg F"
        availability: >
          {{ has_value('sensor.bedroom_temperature')
             and has_value('sensor.hallway_temperature') }}
        state: >
          {% set bedroom = states('sensor.bedroom_temperature') | float(0) %}
          {% set hallway = states('sensor.hallway_temperature') | float(0) %}
          {{ ((bedroom + hallway) / 2) | round(1) }}

Use this for HVAC, freeze alerts, water shutoff logic, comfort rules, and anything that could mislead an automation if the input disappears.

Trigger-based template for a scheduled update

Use this when the value is time-shaped or when the template needs to run even if the input state did not change.

template:
  - triggers:
      - trigger: time_pattern
        minutes: "/5"
      - trigger: homeassistant
        event: start
      - trigger: state
        entity_id:
          - sensor.washer_power
          - input_boolean.laundry_mode
    sensor:
      - name: "Washer Running Summary"
        unique_id: washer_running_summary
        state: >
          {% if states('sensor.washer_power') | float(0) > 8 %}
            running
          {% elif is_state('input_boolean.laundry_mode', 'on') %}
            waiting
          {% else %}
            idle
          {% endif %}

The schedule is the point here. If you remove the triggers, Home Assistant will try to infer update sources from the template. If you keep the triggers, they are what drive the sensor.

Why the Template Editor Can Mislead You

The Template editor is still the right first tool. It shows the output live, points at syntax errors, and lets you test against real entity data. The trap is assuming a successful editor result means the entity will keep updating forever.

The editor answers one question: Can this expression render right now? The entity has a second question: When should Home Assistant run it again? If the template uses this, trigger, events, attributes, device areas, or helper functions that do not produce normal state-change tracking, the editor can look perfect while the real entity stays stale.

When that happens, add temporary debug output. Print the raw value, the converted value, and the branch the template chose. Once you know the data is right, move the update logic into a state-based or trigger-based pattern deliberately.

The 2026.6 Legacy Syntax Caveat

As of Home Assistant 2026.6, legacy template entities under old per-domain platform keys have been removed. This affects legacy template sensors and several other template entity types, including binary sensors, covers, fans, lights, locks, switches, vacuums, weather entities, and alarm control panels. YAML is Home Assistant's text configuration format, so this caveat matters most if you maintain template entities in configuration files instead of only in the UI.

Plain English version: old YAML like this may no longer load after 2026.6:

sensor:
  - platform: template
    sensors:
      old_style_sensor:
        value_template: "{{ states('sensor.example') }}"

Move it to modern syntax instead:

template:
  - sensor:
      - name: "Old Style Sensor"
        unique_id: old_style_sensor
        state: "{{ states('sensor.example') }}"

After migrating, restart Home Assistant, check configuration, and read the logs. A reload can refresh templates, but a syntax removal problem needs a valid configuration first.

Do Not Let a Stale Template Control Risky Devices

Templates often sit between raw devices and important automations. That is useful, but it can also hide a bad assumption. Do not let a stale or guessed template directly unlock a door, open a garage, disable an alarm, change HVAC aggressively, shut off water, or suppress a camera notification without a safe fallback.

For those routines, use conservative rules:

  • Make unknown input stop the automation or send a notification, not take the risky action.
  • Use availability checks so the dashboard shows that the data is bad.
  • Keep a manual override for locks, garage doors, HVAC, and water valves.
  • Test with notifications for a few days before allowing control actions.

How Tara Handles This

Tara treats template sensors as supportable infrastructure, not clever one-off code. In a local smart home, the best template is usually boring: clear entity IDs, a visible update source, unavailable handling, and a small number of branches. If a room depends on the value, the template should fail loudly enough that the homeowner can see the issue.

That is why a Tara install favors simple local entities first, then templates only where they make the home easier to understand: room comfort summaries, presence confidence, device health, quiet-hours behavior, and household notifications. Templates should reduce confusion, not move it into YAML that nobody wants to touch later.

FAQ

Why does my template sensor only update once a minute?

If it uses now() or utcnow(), Home Assistant's current debugging docs say those templates re-run on a minute cadence. If you need a different cadence, use an explicit trigger-based template, but be careful with very fast intervals.

Why does my template sensor not update when an attribute changes?

Attribute-only changes are a common source of confusion. Start by checking what event or state actually changes. If Home Assistant is not watching the change you need, use a trigger-based template with an explicit state trigger or event trigger.

Should I call homeassistant.update_entity from an automation?

Sometimes it helps for integrations that support polling, but it is usually not the first fix for template sensors. A template entity that has no reliable update source should be rewritten with the right state references or triggers.

Why is my template sensor missing after an update?

Check Settings > Repairs and Settings > System > Logs. If the YAML still uses old platform: template entity syntax, migrate it to modern template: syntax. If the syntax is current, look for entity ID, availability, or conversion errors.

Can I make a template sensor update every second?

You can write fast triggers, but most homes do not need that. If the value goes into history, graphs, or automations, very frequent updates can add noise and database load. Use the slowest interval that still makes the room behave correctly.

If this template feeds an automation, read why automations do not fire and why automations run twice. If the input entities disappear after restarts, start with unavailable devices after restart. Before a major Home Assistant upgrade, use the safe update checklist.