YAML Templates 2026: The Ultimate Guide to DRY Configs

Last updated on February 8, 2026

In the fast-paced world of IoT and smart homes, clean and efficient code isn’t a luxury—it’s a necessity. If you’re managing configurations for apps like Home Assistant, Kubernetes, or CI/CD pipelines, you know that repeating code is your worst enemy. This is where YAML templates come in, a cornerstone skill in 2026 for any engineer or enthusiast looking to streamline their config files. This article is your definitive guide to mastering them, from YAML’s native code-reuse features to their advanced application in the Home Assistant ecosystem.

The Building Blocks: Native YAML Templating with Anchors, Aliases & Merging

Before we dive into powerful templating engines like Jinja2 (which Home Assistant uses), it’s critical to understand the tools YAML provides right out of the box. These features are the foundation of the DRY (Don’t Repeat Yourself) principle and will help you create far cleaner, more maintainable configurations.

DRY Code with YAML Anchors & Aliases

YAML anchors and aliases are the most straightforward way to reuse a block of code within the same file. An anchor (&) defines a chunk of data with a name, and an alias (*) re-inserts it anywhere else you need it.

Imagine you have a base configuration for several temperature sensors that share the same thresholds and timeouts. Instead of copy-pasting, you can do this:

# First, define a base config using an anchor (&base_sensor_config)
base_config: &base_sensor_config
  timeout: 60
  unit_of_measurement: "°C"
  thresholds:
    warning: 30
    critical: 40

# Now, reuse that config in different sensors with an alias (*)
sensor_living_room:
  <<: *base_sensor_config  # We'll explain '<<:' next
  name: "Living Room Temperature"
  unique_id: temp_living_room_01

sensor_kitchen:
  <<: *base_sensor_config
  name: "Kitchen Temperature"
  unique_id: temp_kitchen_01

With this setup, if you need to change the timeout for all sensors, you only edit it in one place. To go deeper on this technique, I highly recommend my guide on YAML anchors and aliases.

Supercharging Reuse with the YAML Merge Key

In the example above, I used <<: *base_sensor_config. The << symbol is known as the YAML merge key. Its job is to “merge” or graft the keys from the aliased block right into the current map. This allows you to inherit a base configuration while still adding or overriding specific values for each instance.

Let’s see an example where we override a value:

# ... (&base_sensor_config defined as before)

sensor_outside:
  <<: *base_sensor_config
  name: "Outside Temperature"
  unique_id: temp_ext_01
  thresholds:
    warning: 35  # Override the warning threshold just for this sensor
    critical: 45

In this case, sensor_outside inherits the timeout and unit_of_measurement but gets its own custom thresholds. It’s an incredibly powerful way to manage complex configurations.

Going Modular: Splitting Your Configs with `!include`

As your projects grow, especially on platforms like Home Assistant, keeping everything in a single configuration.yaml file becomes a nightmare. This is where the YAML include directive (!include) becomes your best friend, allowing you to split your configuration into logical files and folders.

This is one of the most critical YAML best practices you can adopt. Home Assistant, for example, supports several include directives:

!include file_name.yaml: Inserts the content of the specified file.
!include_dir_list /path/to/folder: Loads each YAML file in the folder as an item in a list.
!include_dir_named /path/to/folder: Loads each file in the folder as a map, using the filename as the key.
!include_dir_merge_list /path/to/folder: Like include_dir_list, but merges the content of each file into a single list.
!include_dir_merge_named /path/to/folder: Like include_dir_named, but merges the content into a single map.

For example, in your main configuration.yaml you might have:

# configuration.yaml
automation: !include_dir_list automations/
script: !include scripts.yaml
sensor: !include_dir_merge_list sensors/

This structure makes your project infinitely more manageable. To truly master this, I’ve written an in-depth guide on advanced YAML techniques that covers includes in detail.

Practical Magic for 2026: YAML Templates in Your Smart Home

Where YAML templating truly shines is in smart home platforms like Home Assistant. The system doesn’t just use native YAML features; it supercharges them with the Jinja2 templating engine, allowing for conditional logic, loops, and dynamic access to entity states.

Real-World Example: A Reusable Notification Script in Home Assistant

Let’s say you want to send custom notifications to different devices with variable titles and messages. Instead of creating a separate automation for every single case, you can build one reusable, templated script.

First, we define the script in our scripts.yaml file:

# scripts.yaml
custom_notification:
  alias: "Send Custom Notification"
  fields:
    target_device:
      description: "The device that will receive the notification (e.g., mobile_app_my_phone)"
      example: "mobile_app_my_phone"
    title:
      description: "The title of the notification."
      example: "Security Alert"
    message:
      description: "The body of the message."
      example: "Motion detected at the front door."
  sequence:
    - service: notify.{{ target_device }}
      data:
        title: "{{ title }}"
        message: "{{ message }}"

Let’s break down the magic here:

fields: This defines the “variables” or inputs our script will accept.
{{ target_device }}, {{ title }}, {{ message }}: These are Jinja2 templates. When we call the script, Home Assistant will replace these placeholders with the values we pass to it.

Now, from any automation, we can call this script cleanly and easily:

# automations/front_door_alert.yaml
- alias: "Front Door Motion Alert"
  trigger:
    - platform: state
      entity_id: binary_sensor.front_door_motion_sensor
      to: 'on'
  action:
    - service: script.custom_notification
      data:
        target_device: "mobile_app_johns_phone"
        title: "⚠️ Motion Alert"
        message: "Motion detected at the front door at {{ now().strftime('%-I:%M %p') }}."

Notice how we can even use a template inside the message ({{ now().strftime('%-I:%M %p') }}) to dynamically insert the current time. This approach is the key to a powerful and scalable smart home system in 2026.

What About Node-RED?

While tools like Node-RED offer a fantastic visual approach to automations, reducing the need to write logic in YAML, don’t think you can escape it entirely. Understanding YAML’s structure and syntax is still fundamental. Node-RED flows are often exported and imported as JSON (which YAML is a superset of), and you will constantly need to interact with Home Assistant services that are defined in YAML. The two worlds are deeply connected.

My Top 5 YAML Best Practices for Clean, Maintainable Templates

To wrap things up, here are the YAML best practices I’ve baked into my workflow over the years, and they’re more relevant than ever in 2026:

Comment Your Code: Use the # symbol to explain the “why” behind your configurations, especially for complex anchors or scripts. Your future self will thank you.
Validate Before You Deploy: Use tools like the built-in Home Assistant configuration check or Visual Studio Code extensions to validate your YAML syntax *before* restarting. This will save you countless headaches.
Embrace Modularity: Don’t let your configuration.yaml become a dumping ground. Use !include aggressively and organize your configs into logical folders (automations, sensors, scripts, etc.).
Stay Consistent with Indentation: The industry standard is 2 spaces for indentation. Never, ever use tabs. Most code editors can be configured to convert tabs to spaces automatically.
Use Descriptive Names: Give your anchors, scripts, and automations clear, descriptive names. &temp_sensor_base_config is infinitely better than &cfg1.

Mastering YAML templates is a skill that transcends any single platform. It’s an investment in building more robust, maintainable, and efficient systems, whether you’re managing enterprise infrastructure or perfecting your smart home.