HA Scenes vs Scripts vs Automations: When to Use Each
In Home Assistant, the short version is this: a scene captures a set of device states you want to recall on demand; a script runs an ordered sequence of actions (with delays, waits, and logic) when you call it; and an automation is the trigger-driven layer that decides when something should happen. They overlap enough to confuse newcomers, but each exists to solve a distinct problem. Most well-built Home Assistant setups use all three together — an automation triggers, and it calls a scene or a script to do the work.
What each one actually is
The three concepts sit at different layers of the same system, so it helps to define them precisely rather than by example.
Scenes: a snapshot of states
A scene describes the desired end state of one or more entities — living room lights at 40% and warm white, the thermostat at 68°F, the blinds closed. When you activate a scene, Home Assistant tells each listed entity to move to that state. It does not care what order things happen in, and it has no concept of “wait” or “if.” A scene is declarative: you say what the room should look like, not how to get there. That is why scenes are ideal for “Movie Night” or “Good Morning” presets. You can build them by hand in YAML, or capture the current state of your devices through the scene editor in the Home Assistant UI.
Scripts: an ordered sequence of actions
A script is a named sequence of actions that runs top to bottom. Unlike a scene, a script can do things over time and with logic: turn on a light, wait five seconds, send a notification, wait until a door closes, then lock it. Scripts support delays, wait_for_trigger, choose/if-then blocks, repeats, and variables. Crucially, a script is reusable — once defined, it appears as a service you can call from a dashboard button, a voice command, or any automation. If you find yourself copying the same block of actions into several automations, that block wants to be a script.
Automations: the trigger that decides when
An automation is built from three parts: triggers (what starts it — a motion sensor, sunset, a time, a state change), conditions (optional gates that must be true, like “only after dark”), and actions (what to do). The automation is the only one of the three that runs by itself in response to the world changing. Its actions can be inline, but in a tidy setup they often just activate a scene or call a script. If you're new to writing them, our Home Assistant automations for beginners guide walks through the trigger–condition–action structure step by step.
Side-by-side comparison
| Aspect | Scene | Script | Automation |
|---|---|---|---|
| Core purpose | Recall a set of device states | Run an ordered sequence of actions | Decide when something should happen |
| Runs on its own? | No — must be activated | No — must be called | Yes — fires on its triggers |
| Has triggers? | No | No | Yes |
| Timing / delays / waits | No | Yes | Yes (in its actions) |
| Logic (if / choose / repeat) | No | Yes | Yes |
| Reusable elsewhere? | Yes (activate from anywhere) | Yes (called as a service) | Not typically called by others |
| Best for | Presets and “looks” | Multi-step, shared routines | Event-driven behavior |
How they work together
The reason this comparison matters is that you rarely pick just one. A robust routine layers them. Consider an evening “wind down” flow: an automation watches for the trigger, checks conditions, then hands off the actual work.
Here the automation owns the when, the script owns the ordered how (dim over time, close blinds, then start music after a short delay), and the scene owns the final look of the lights. Splitting responsibilities this way keeps each piece small and testable. You can run the script manually from a dashboard button to check it, and you can activate the scene independently to confirm the states are right — all without waiting for the trigger to occur naturally.
Which should you choose?
Match the tool to the job with a few quick questions.
- Do you just want devices to reach a specific state? Use a scene. If there's no timing and no branching — just “put these lights, this thermostat, and these blinds into this configuration” — a scene is the simplest, most reliable choice.
- Do you need steps in order, with delays or waits or conditional branches, and you might reuse it? Use a script. Anything with “then wait for…” or “if this, otherwise that” belongs here.
- Do you want it to happen automatically in response to an event? Use an automation. It's the only one with triggers, so anything reactive starts here — and its actions can call a scene or script.
- Declarative — you define the end state, not the steps
- No delays, waits, or logic — states apply together
- Perfect for lighting presets and room “looks”
- Procedural — runs actions in order
- Supports delays, waits, choose/if, repeat, variables
- Ideal when the same sequence is reused in many places
Common mistakes to avoid
- Building a “scene” that needs timing. Scenes can't wait or sequence. If you want lights to fade up over 30 seconds before the coffee maker starts, that's a script.
- Putting complex logic inline in an automation you'll copy later. Move shared logic into a script so you maintain it once.
- Expecting a script or scene to run on its own. Neither has triggers. Something — an automation, a dashboard button, or a voice assistant — has to call it.
- Forgetting scenes only set what's listed. A scene changes the entities it includes and leaves everything else as-is; it doesn't turn off lights you didn't add to it.
If you're still deciding whether Home Assistant is the right platform for this level of control, our overview of what Home Assistant is and whether you should use it is a good starting point, and the dashboard setup guide covers adding buttons to activate scenes and scripts by hand.
Frequently asked questions
Can an automation activate a scene or run a script?
Yes — this is the recommended pattern. An automation's actions can activate a scene (via scene.turn_on) or call a script. Keeping the trigger logic in the automation and the work in a scene or script makes each piece easier to reuse and troubleshoot.
Do scenes turn devices off?
Only if the “off” state is part of the scene. A scene applies the states you saved for the entities you included. If you want a scene to switch certain lights off, include those lights in the scene with their state set to off; entities you leave out are untouched.
Is a script the same as an automation without a trigger?
Effectively, yes — a script is a sequence of actions with no trigger of its own, so it only runs when called. That's the key distinction: automations react to the world; scripts wait to be invoked. Both support the same action features like delays, waits, and choose blocks.
Should beginners start with the UI editors or YAML?
The built-in visual editors for scenes, scripts, and automations are a fine place to start and can capture current device states for you. As your routines grow more complex — nested logic, templates, variables — many users switch to editing YAML for finer control. You can move between the two on a given item, though very advanced YAML may not render in the visual editor.
