A complete beginner’s guide to Home Assistant 2026.10.2 – from your first trigger to reusable scripts, scenes, blueprints and reliable automations.

Version and scope. This edition is based on Home Assistant 2026.10.2 and the official documentation available on 22 October 2026. Patch 2026.10.2 contains bug fixes; the functional automation changes arrived in the 2026.10 release. At the October 30, 2026 review, 2026.10.4 was the latest published patch in the 2026.10 series; the examples have not been retested on that version. Consult current release notes if the interface differs. You do not need to know YAML to get started: first you learn the visual editor and its logic. YAML is included as learning and reference material.

The building blocks

1. The five building blocks: what goes where?

Several Home Assistant tools overlap. Beginners should first understand the role of each component. The official documentation distinguishes automations, scripts, scenes, blueprints and helpers as five tools often used together.

Component What is it? Use it when…
Automation Steps started automatically by a trigger Something should respond automatically to a change
Script Saved sequence of steps without its own trigger The same routine should be startable from multiple places
Scene Saved set of states for several entities You want to set several devices to a desired state at once
Blueprint Reusable template with input fields You want to reuse an existing automation, script or template
Helper Virtual entity that stores a value, status or setting Automations need memory or adjustable parameters

Beginner tip. Usually start with an automation. Create a script when you want to reuse the same actions or start them manually. Use a scene for a fixed atmosphere or device state, and helpers for settings or memory.

2. Scenes: a saved state

A scene records how several devices and entities should look at a particular moment. Think Movie night: ceiling light off, accent light at 20%, blinds closed. A scene is therefore not a step-by-step plan; Home Assistant tries to apply the desired states.

Scene, script and automation side by side
Figure 2 – Scene, script and automation side by side.

Create a scene through Settings > Automations & scenes > Scenes > Create scene. The scene editor uses Live Edit: changing the state of an added device applies that change to the actual device while you create the scene.

You can activate scenes with Activate scene. Home Assistant also supports actions to apply a set of states directly without a saved scene, create a temporary scene, delete that temporary scene again, and reload YAML scenes.

Simple scene in YAML

scene:
  - name: Movie night
    entities:
      light.woonkamer_plafond:
        state: "off"
      light.woonkamer_sfeer:
        state: "on"
        brightness: 55
      cover.woonkamer:
        state: "closed"

3. What can scenes do in 2026.10?

Activate scene is the main action for beginners. But the current Scenes integration offers more. These options become useful when you build more advanced flows.

Feature What it does Typical use
Activate scene Activates a saved scene Movie night, Good night, Cleaning
Apply scene Applies states directly without saving a scene first One-off or dynamic presets
Create scene Creates a temporary scene at runtime Remember the current state for later restoration
Delete scene Removes a runtime scene Clean up a temporary snapshot
Reload scenes Reloads YAML scenes After manual YAML changes
Scene activated trigger Responds when a scene is activated Link another automation to scene use

Useful pattern. Want to remember the current lighting, turn everything up for cleaning, then return to the previous state? A temporary scene can be very useful.

4. Scripts: a reusable sequence of steps

A script is a saved list of steps that runs only when you start it. You can start one from a dashboard, through Assist, from an automation or from another script. A script therefore has no trigger of its own.

Use a script mainly when the same routine is needed in multiple places. For example, an Arrival routine can be started by a presence automation, a dashboard button and Assist.

Script: arrival routine

alias: Arrival routine
mode: single
sequence:
  - action: light.turn_on
    target:
      entity_id: light.hal
    data:
      brightness_pct: 70
  - action: climate.set_temperature
    target:
      entity_id: climate.woonkamer
    data:
      temperature: 20.5
  - delay: "00:00:10"
  - action: media_player.turn_on
    target:
      entity_id: media_player.woonkamer

Automations and scripts use the same action building blocks, so almost everything you can put under Then do in an automation can also go in a script’s Sequence.

5. Scripts can do much more than a simple macro

Scripts in the current Home Assistant version can have input fields. In the editor, choose Menu > Add fields. A field can be an entity, number, selection list or text. That lets a script run the same routine with different values.

Script with fields

alias: Temporary lighting
mode: restart
fields:
  lamp:
    name: Light
    selector:
      entity:
        domain: light
  minutes:
    name: Minutes
    default: 5
    selector:
      number:
        min: 1
        max: 60
sequence:
  - action: light.turn_on
    target:
      entity_id: "{{ lamp }}"
  - delay:
      minutes: "{{ minutes | default(5) }}"
  - action: light.turn_off
    target:
      entity_id: "{{ lamp }}"

Scripts can also return response data to the automation or script that calls them directly. This is useful when a script first gathers information and the calling automation then uses that result.

Important difference. If you call a script directly as an action, the calling automation waits until the script finishes and can receive a response. With Turn on script (script.turn_on), the script starts in the background and the automation continues immediately.

6. Automations: WHEN → AND IF → THEN DO

An automation starts on its own. The current visual editor has a simple structure: When contains the trigger, And if the optional conditions, and Then do the actions.

Trigger, condition and action in the Home Assistant editor
Figure 3 – Trigger, condition and action in the Home Assistant editor.

A trigger is a moment when something changes or happens. A condition starts nothing; it only checks whether something is true when the automation runs. Actions are the steps Home Assistant then executes.

Crucial distinction. A trigger responds to a transition or event, not to something remaining true over time. A door that is already open does not trigger again until it closes and then opens again.

Triggers, conditions and actions

7. Triggers: what can start an automation?

Home Assistant 2026.10 offers both device/entity-specific triggers and general triggers. Beginners are usually best served by the specific trigger offered in the editor, such as Door opened or Temperature crossed threshold. Home Assistant can, for example, compare compatible units automatically.

Important general trigger categories include:

  • State changed: an entity changes state or an attribute.
  • Numeric state crossed threshold: a measured value crosses a limit.
  • Time and time pattern: a fixed time or repeating pattern.
  • Sun: sunrise, sunset or sun elevation.
  • Zone entered / Zone left: a person or tracker enters or leaves a zone.
  • Tag: an NFC tag is scanned.
  • Home Assistant: start or shutdown events, for example.
  • MQTT: a message on a topic.
  • Webhook: an HTTP call to a secret webhook URL.
  • Template: a template changes from false to true.
  • Manual event / events: respond to particular events.
  • Sentence: respond to a custom phrase through Assist.
  • Geolocation: respond to geolocation entities where relevant.

Many integrations also add their own human-friendly triggers. As a beginner, you therefore often do not need to know technical state values.

8. Multiple triggers and Triggered by – easier in 2026.10

An automation can have multiple triggers. Each trigger can start the same automation. Home Assistant 2026.10 makes it much easier to select different actions afterwards according to which trigger fired.

Add a Choose block under Then do and use a Triggered by condition. In the UI, select the relevant triggers directly. Home Assistant manages the required trigger IDs behind the scenes. YAML users can still set an id themselves.

YAML concept: different actions for each trigger

alias: Hallway motion and clear
triggers:
  - trigger: state
    entity_id: binary_sensor.hal_beweging
    to: "on"
    id: motion
  - trigger: state
    entity_id: binary_sensor.hal_beweging
    to: "off"
    for: "00:03:00"
    id: clear
actions:
  - choose:
      - conditions: "{{ trigger.id == 'motion' }}"
        sequence:
          - action: light.turn_on
            target:
              entity_id: light.hal
      - conditions: "{{ trigger.id == 'clear' }}"
        sequence:
          - action: light.turn_off
            target:
              entity_id: light.hal

In the visual editor you usually do not have to write these IDs yourself: select the trigger in the Triggered by condition.

9. Conditions: when may an automation continue?

Top-level conditions appear under And if. If one of them is false, the actions do not run. Conditions can also appear within a sequence; if such a condition fails, the rest of that sequence stops.

Common condition types for beginners:

  • State: for example, a person is home, an input_boolean is on, a door is closed.
  • Numeric state: temperature above or below a limit.
  • Time: only between certain times or on certain days.
  • Sun: before or after sunrise/sunset.
  • Triggered by: execute only the path belonging to a particular trigger.
  • Template: custom Jinja logic when standard conditions are insufficient.
  • AND / OR / NOT: combine conditions logically.
  • Integration-specific conditions: an alarm or Z-Wave state, for example, when the integration offers it.

Trigger versus condition. Use the trigger for the moment when the automation should start. Use the condition for the situation that must be true at that moment.

10. Actions and targets: what should Home Assistant do?

An action does something: turn on a light, set a thermostat, activate a scene, start a script, send a notification, control media, change a helper, fetch calendar data and so on. The current Home Assistant catalogue includes actions from almost all integrations.

An action usually has three concepts:

Component Meaning Example
Action Which command? light.turn_on
Target Which entity/device/area? light.woonkamer or the living-room area
Data/options Which settings? brightness_pct: 40

Simple action with an area target

actions:
  - action: light.turn_on
    target:
      area_id: woonkamer
    data:
      brightness_pct: 40

Some actions return response data. For example, calendar.get_events can return appointments in a response variable, which you can use in a template in a later step.

Building blocks and run modes

11. Building blocks: the real power of scripts and automations

Home Assistant calls the logical steps between ordinary actions building blocks. Automations and scripts use the same blocks. They determine whether, when and in what order steps run.

Building block Purpose Example
Condition Stop or continue only if something is true Continue only if nobody is home
Delay Wait a fixed time Wait 5 minutes
Wait for trigger Wait for an event Wait until the door closes
Wait template Wait until a template becomes true Wait until power < 3 W
Choose Select the first matching route Day / evening / night
Repeat count Repeat N times Flash a lamp 3 times
Repeat while Repeat while a condition is true Keep trying while offline
Repeat until Repeat until a condition becomes true Try until a device turns on
Repeat for each Iterate over a list Handle several lights one by one
Parallel Run groups at the same time Start lights and media together
Stop Stop the sequence; optionally return a response/error Finish a script and return its result

12. Delay, wait and restart behavior

Delay is simple: it pauses the sequence for a fixed time. Wait for trigger waits for a new event. Wait template waits until a template becomes true. With waits you can set a timeout and then decide whether the sequence should continue.

An important beginner detail: restarting Home Assistant stops automations and scripts that are currently in a delay or wait. For critical scheduling, prefer helpers, timers or timestamps that can be evaluated again after a restart.

Classic motion timer with restart mode

actions:
  - action: light.turn_on
    target:
      entity_id: light.hal
  - delay:
      minutes: 5
  - action: light.turn_off
    target:
      entity_id: light.hal
mode: restart

With mode: restart, every new trigger starts the run from the beginning, so the five minutes are counted again from the last motion.

13. Choose, repeat and parallel – when should you use them?

Choose is like if/elif/else. Home Assistant executes only the first option whose conditions all match; if none match, a default route can run. Repeat has several forms: a fixed number of times, while something is true, until something becomes true, or for each item in a list.

Parallel is useful when independent groups of steps may begin at the same time. Do not use it thoughtlessly for the same device, because two parallel routes can contradict one another.

Choose: night or normal

actions:
  - choose:
      - conditions:
          - condition: state
            entity_id: input_select.house_mode
            state: Night
        sequence:
          - action: light.turn_on
            target:
              entity_id: light.hal
            data:
              brightness_pct: 10
    default:
      - action: light.turn_on
        target:
          entity_id: light.hal
        data:
          brightness_pct: 70

14. Run modes: single, restart, queued and parallel

The mode determines what Home Assistant does when an automation or script is started again while its previous run is still in progress. This becomes essential as soon as you use delays, waits or long routines.

Mode Behavior Good example
Single Does not start a new run; issues a warning A routine that must never run twice
Restart Stops the previous run and starts a new one Motion light with an off timer
Queued New runs wait in order Commands that must be processed in sequence
Parallel Starts a new independent run alongside the existing one Independent notifications or tasks

For queued and parallel you can also set limits for the number of simultaneous or queued runs.

Beginner rule. If you do not know which mode you need, start with single. Use restart deliberately for timers that must begin again. Use queued or parallel only when you understand why.

Working together and reusing logic

15. How scenes, scripts and automations work together

Sensors and events flow through an automation and reusable scripts or scenes to devices
Figure 4 – Sensors/events → automation → script/scene → devices.

A maintainable structure does not have to be complicated. The automation decides when something happens and under which conditions. The script contains a reusable routine. A scene sets devices to a fixed final state.

A short automation that reuses existing building blocks

alias: Coming home after sunset
triggers:
  - trigger: state
    entity_id: person.dennis
    to: "home"
conditions:
  - condition: sun
    after: sunset
actions:
  - action: script.arrival_routine
  - action: scene.turn_on
    target:
      entity_id: scene.evening_downstairs
mode: single

16. Calling a script: wait or continue immediately?

The current Home Assistant documentation clearly distinguishes two ways to start a script.

Method What happens? Use it when…
The script itself as an action Automation waits until it finishes; response possible Later steps depend on the script
Turn on script Script starts in the background; automation continues immediately Routines may run independently

Two ways to start scripts

actions:
  # Wait for completion
  - action: script.arrival_routine
  # Start in background and continue immediately
  - action: script.turn_on
    target:
      entity_id: script.muziek_routine

This distinction is especially important with longer scripts, error handling and response data.

17. Small features that make a big difference

The editor and building blocks include several features that beginners often discover only later:

  • Rename / alias: give each step a clear name. It also appears in traces.
  • Disable: temporarily turn off triggers, conditions and actions without deleting them.
  • Continue on error: let subsequent steps continue when a non-critical action fails. This does not ignore configuration errors.
  • Variables: temporarily store values for templates and later actions.
  • Response variable: save data returned by an action.
  • Set conversation response: let an automation started by Assist provide a custom spoken or text response.

Home Assistant 2026.10 also shows more important details directly on editor rows, such as thresholds, for durations, sun offsets and wait timeouts. You therefore need to open each row less often.

18. Blueprints: reuse without building everything yourself

A blueprint is a reusable template for an automation, script or template entity. Its author leaves some parts open as inputs; you select your own motion sensor, lamp and timeout, for example.

Blueprints are interesting for beginners because you can use a well-designed automation without writing all the YAML yourself. You can reuse one blueprint with different devices.

Go to Settings > Automations & scenes > Blueprints. Blueprints can be imported from GitHub, GitHub Gists and the Home Assistant Community, among other sources.

Important. A blueprint is not a standalone running automation. You create your own automation from it, using your chosen inputs. Blueprint updates take effect when automations are reloaded.

Testing and practical examples

19. Test one thing at a time

The best way to learn Home Assistant is to test components separately. Test an action first, then a script or scene, and only then the full trigger logic.

A practical sequence:

  1. Can Home Assistant control the device manually?
  2. Does the isolated action work from the editor or Settings > Tools > Actions?
  3. Does the scene or script work manually?
  4. Does the trigger respond when you reproduce the real event?
  5. Are all conditions true when the trigger fires?
  6. Does the selected run mode make sense?

In the automation editor, you can duplicate, copy, cut, paste, rearrange and temporarily disable rows. That makes experimentation safer than repeatedly deleting configuration.

20. Traces: your main troubleshooting tool

Each automation run can produce a trace. It shows which trigger started it, which conditions were checked, which Choose route was taken and where the run stopped or failed.

Home Assistant 2026.10 visually redesigned traces to align them more closely with the automation editor. When an automation "does nothing", the trace is usually the first place to look.

Caution when using Run actions. Manually running only an automation’s actions does not automatically test the real trigger or top-level conditions. Always simulate the real situation for the final test.

21. Six practical examples for beginners

Six examples: good night, bathroom fan, washing machine, arrival, vacation mode and morning routine
Figure 5 – Six common applications.

The examples below show which tools usually fit best.

Scenario Best foundation Why
Good night Scene + script + automation Scene for states; script for routine; automation for automatic start
Bathroom fan Automation / possibly script Sensor trigger and run-on time
Washing machine finished Automation + helper Detect power and notify only once
Arrival routine Script + automation Reuse routine from presence/dashboard/Assist
Vacation mode Helper + automations + scenes Central house state controls several flows
Morning routine Script + automation Several steps, possibly based on time/presence

22. Practical example: hallway light after the last motion

This is a perfect beginner example for restart mode. The automation starts on motion, turns the light on, waits five minutes and turns it off. Every new motion restarts the run, so the timer begins again.

Simple but robust motion automation

alias: Hallway - motion lighting
mode: restart
triggers:
  - trigger: state
    entity_id: binary_sensor.hal_beweging
    to: "on"
actions:
  - action: light.turn_on
    target:
      entity_id: light.hal
  - delay:
      minutes: 5
  - action: light.turn_off
    target:
      entity_id: light.hal

In the current UI you can often select a specific Motion detected trigger instead of a general State changed trigger. The specific trigger is usually clearer for beginners.

23. Practical example: bathroom fan without unnecessary complexity

For a first version, a numeric threshold may be enough. Later you can extend this with hysteresis, relative rise, absolute humidity or your own template sensor.

Beginner bathroom ventilation

alias: Bathroom - high humidity
mode: restart
triggers:
  - trigger: numeric_state
    entity_id: sensor.badkamer_luchtvochtigheid
    above: 70
actions:
  - action: switch.turn_on
    target:
      entity_id: switch.badkamer_ventilatie
  - delay:
      minutes: 20
  - action: switch.turn_off
    target:
      entity_id: switch.badkamer_ventilatie

Why restart? If the automation triggers again during its run-on time, that run-on time starts over. For a truly good shower automation, you can later examine humidity trends or the difference from a reference sensor.

24. Practical example: washing machine finished

A smart plug with power measurement can infer an appliance state. Since a washing machine may also use a little power while idle, a helper is useful for remembering whether a cycle was actually running.

Power detection + helper

alias: Washing machine - finished
mode: single
triggers:
  - trigger: numeric_state
    entity_id: sensor.wasmachine_power
    below: 3
    for: "00:03:00"
conditions:
  - condition: state
    entity_id: input_boolean.washing_running
    state: "on"
actions:
  - action: notify.mobile_app_telefoon
    data:
      title: Washing machine
      message: The washing machine has finished.
  - action: input_boolean.turn_off
    target:
      entity_id: input_boolean.washing_running

Adjust the exact power threshold and time to your appliance. Use History to inspect its real power profile.

25. Practical example: temporary scene for restoring state

Sometimes you want to change the state of devices temporarily and then return. For example, turn every living-room light fully on for an alarm test, then restore the original lighting.

The Scenes integration can create a scene from current states at runtime. You then apply other states. When you finish, activate the temporary scene to return. This is more advanced than a standard scene but very powerful.

For beginners. Start with ordinary scenes. Use runtime scenes only when you deliberately need a "snapshot and restore" pattern.

Reliability and reference

26. Reliability: for, delays and Home Assistant restarts

A common mistake is assuming every waiting period survives a restart. It does not. A Home Assistant restart interrupts an active delay or wait. for periods on state/numeric triggers are not simply continued from the old runtime context after a restart either.

For actions that absolutely must happen later, helpers such as Timer or Date/time can be a better foundation. After a restart, you can then reassess the desired state and schedule.

Design principle. Use delay mainly for short, non-critical waits. For important scheduling over hours or days, save a time/status in a helper and make your automation recoverable.

27. Advanced triggers beginners should still know about

You do not need to use them immediately, but Home Assistant can do much more than time and sensor states.

  • Webhook: an external system can start an automation over HTTP. Keep the webhook ID secret; leave local_only on when internet access is not needed.
  • MQTT: start on a message or payload from an MQTT topic.
  • Sentence: let Assist respond to a custom phrase.
  • Tag: start a flow with NFC tags.
  • Event: respond to Home Assistant events.
  • Zone: people/trackers enter or leave a location.
  • Template: create a custom calculated trigger when standard types are insufficient.

Use external webhook triggers very cautiously for safety-critical actions, such as unlocking a door or opening a garage door.

28. Best practices for beginners

  • First write the logic in plain language. For example: "If motion is detected and it is dark, turn on the hallway light for five minutes."
  • Use specific triggers when the editor offers them; they are often clearer than raw states.
  • Give automations, scripts and scenes descriptive names.
  • Give important steps an alias or name. This makes traces much easier to read.
  • Avoid duplication. If the same sequence of actions recurs, create a script.
  • Use scenes for states, not for timing or decisions.
  • Choose a mode deliberately, especially when delays/waits are involved.
  • Test each component separately.
  • Use helpers for memory and adjustable values.
  • Make critical automations recoverable after a restart.

29. Common mistakes

Mistake Consequence Better approach
Everything in one huge automation Difficult to read and debug Split reusable routines into scripts
Scene as a step-by-step plan No control over order/waits Use a script
Script for every tiny command Unnecessary abstraction Keep a simple action in the automation
Single mode with timer New motion does not reset the timer Use restart mode where appropriate
Test only Run actions Trigger/conditions remain untested Simulate the real event and examine the trace
Long critical delay Disappears on restart Store scheduling in a helper/timestamp
No helper for appliance status Duplicate alerts or incorrect status Store a virtual state
Share a webhook ID Security risk Use a unique secret ID and local_only where possible

30. GUI or YAML?

For beginners, the visual editor is the best starting point. Home Assistant 2026.10 displays triggers, conditions and actions more clearly and can manage the underlying trigger IDs for Triggered by.

YAML remains valuable for:

  • complex templates;
  • copying and sharing examples quickly;
  • keeping configuration under version control;
  • advanced variables and templated values;
  • understanding what the editor stores behind the scenes.

A useful recent feature: in many cases you can copy YAML snippets from the official documentation directly into the visual editor, and Home Assistant converts them to the editor structure.

Advice. Learn the logic through the GUI first. Then use YAML as a tool, not an entry requirement.

31. Which tool should you use when?

Question Use
Should something start automatically when a value changes? Automation
Should I be able to start the same steps both manually and automatically? Script
Should I set several devices to fixed states at once? Scene
Should I reuse an existing generic solution? Blueprint
Should Home Assistant remember a state/choice/number? Helper
Should an automation choose different routes? Choose + conditions / Triggered by
Should a sequence restart on new activity? Mode Restart
Should events be processed in order? Mode Queued
May independent runs execute together? Mode Parallel

The simple memory aid still works: Scene = state | Script = routine | Automation = decision. Thinking from these three ideas makes Home Assistant much easier to understand. Blueprints and helpers add to that core as your setup grows.

32. Conclusion

Scenes, scripts and automations are not three competing ways of doing the same thing. They complement each other. A scene records how devices should be set. A script stores a reusable sequence of steps. An automation decides when and under which conditions those steps should run.

Home Assistant 2026.10 makes the visual automation experience easier to access again, particularly by integrating Triggered by and trigger IDs more effectively into the UI. Beginners can therefore build increasingly powerful logic without having to write YAML immediately.

Start small: a motion-light automation, a Movie night scene and a simple Arrival routine script. Once those three work well, you understand the core. Then gradually add helpers, fields, choose, waits, repeat, response data and blueprints.

Version: Home Assistant 2026.10.2 – checked on 22 October 2026.

Sources and version check

This guide is based on the official Home Assistant documentation and the 2026.10 release notes. The principal pages consulted are:

Home Assistant documentation changes with new releases. Before leaving this article published for a longer period, it is worth briefly rechecking screenshots and terminology after major monthly releases.