Home automation

A small, deliberately abstracted view of the kind of dashboard that sits across the whole setup. Climate per zone, solar production, and the device grid that lets every switch and sensor be operated from one screen.

Home Assistant sits at the centre and orchestrates every connected thing in the house. The interesting bit isn’t any single integration. It’s the patterns that emerge when they all talk to each other.

• Climate. One controller runs the ducted air-con from two sensors in the room that matters, because the unit’s own sensor read up to 6 °C out on hot days. Before the free midday power window, the forecast decides whether to pre-cool, pre-heat or hold. Blinds stay shut on hot-forecast days. A change made from a dashboard holds for two hours instead of being fought.
• Energy. Solar, battery, grid and the big loads are metered. The grid reading is corrected against the network’s revenue meter and priced on the real tariff, supply charges included. The battery grid-charges in a free midday window and a few flexible loads run then too; peak import fell from 13.4 to 8.0 kWh a day as that ramped up. Gas and water are metered and priced the same way.
• Lighting & switches. The largest single group of automations, with Adaptive Lighting keeping rooms dim and warm at night.
• Presence. Phones give per-person presence, about 13 Bluetooth scanners give room-level tracking, and small beacons ride on a pet collar and key tags.
• Voice. Four of the five satellites run a fully local pipeline: local speech-to-text, a local 35B model on Home Assistant’s built-in LLM API, and replies in a clone of my voice. Keeping the prompt small and static, so the model server can reuse it from cache, cut one test question from 66 seconds to under 3.
• Water, cameras, misc. The water meter’s pulse counter catches leaks down to about half a litre to a litre an hour, and floor sensors alert with no conditions attached. A dozen-plus cameras record around the clock on a local NVR with its own detection. An old business tablet and a 2014 Chromebook were recycled into dashboard panels that double as voice satellites.

A few automation shapes turn up over and over. Once these land, the house gets meaningfully calmer to live in.

• If-this-and-that-and-also-the-other. The valuable automations are almost never single-trigger. They’re combinations of conditions that, taken together, mean something specific. “Sunset AND someone’s home AND nobody’s currently watching a movie” is a different automation than “sunset.”
• Conservative defaults with manual override. The house guesses; people can disagree. Every “automatic” thing has a clear way to be told off (a physical switch, a voice command, a timeout) and the system actually respects it.
• Long-term history beats real-time. The dashboards optimised for value aren’t “what’s the temperature right now.” They’re “how has the temperature trended for the last 6 months, and what does that say about insulation, run-time, and the air-con’s wear curve?”
• Custom firmware where the vendor app is the bottleneck. Plenty of cheap smart devices have great hardware ruined by a cloud-only app. A few minutes flashing ESPHome cuts the cloud out entirely and gives Home Assistant native control.

The real one that runs at noon, lightly simplified. Declarative, readable, kept in version control, and ordered so the most fragile step goes last:

# Noon: the plan's free window opens. Charge the battery and run the
# loads worth running on free power. The most fragile step goes LAST.
alias: Free window - battery charge and soak loads
triggers:
  - trigger: time
    at: "12:00:00"
actions:
  - action: number.set_value          # firmware writes a window of now -> now + N h
    target: { entity_id: number.home_battery_charge_hours }
    data: { value: 4 }                # 12-16: three free hours plus one cheap one
  - action: number.set_value
    target: { entity_id: number.home_battery_charge_power }
    data: { value: 90 }               # % of the inverter's rating
  - action: switch.turn_on
    target:
      entity_id:
        - switch.home_battery_charge_from_grid
        - switch.exhaust_fan
        - switch.portable_ac
    continue_on_error: true           # one offline plug must not cancel the rest
  - alias: LAST - the most failure-prone load; a failed call cannot veto the charge
    action: switch.turn_on
    target: { entity_id: switch.discretionary_load }
    continue_on_error: true
# The 15:00 branch turns the loads off in the same order: the most
# failure-prone call goes last, and only if that load is on.

The order matters. Once, a failed switch-off call to a device that had never come on aborted every later step, and the air-con ran past the free window until someone switched it off by hand. Multiply that care by 183 automations and the house handles its own routine while leaving the decisions that need a human. How it ties into the pantry, the paperwork and the email robots is on the household stack page.

The same architecture scales down for a unit and up for a larger home or a small office. The work I’d do is roughly:

1. Sit down and listen. What annoys you about the house right now? What do you find yourself doing every day? That list is the brief.
2. Survey what you already own. Plenty of smart devices can be integrated even when the vendor app pretends otherwise. Anything that needs replacing gets replaced deliberately, not because the catalogue says so.
3. Stand up the brain. Home Assistant on hardware you own, with offsite backups, observability and a path to come back from any failure. No vendor lock-in.
4. Build the first ten automations. Ship the highest-payback ones first so you feel the difference in the first week.
5. Hand over. Documentation in plain English. A dashboard your family or staff can use. Optional ongoing support; optional full-handover where I never touch it again.