How to Time Your Smart Home Cooling for Heat Waves

Useful smart home cooling tips for a heat wave start before anyone touches the thermostat: close the right glass before the sun hits it, bring in outdoor air only when it is actually cooler than indoor air, and allow AC or fans to run only when the safety gates make sense. The copyable recipes below use that sequence, but they are not stamped as reproduced lab results. Each one lists hub, protocol, verification date, and NestGrid status. Until NestGrid has reproduced the full chain on that hub, the honest label is Investigating.

The starting model comes from a July 2026 Home Assistant heat-wave workflow: heat-wave mode turns on when outdoor temperature is at least 30°C or the living room is at least 26°C; free-cooling alerts fire only when outside is at least 1.5°C cooler than inside; shutters close by façade-specific sun azimuth ranges; and AC is gated by heat, occupancy, and closed windows. Those are useful starting points, not laws of physics for every house on every block. The same source is very clear on the sensor problem: an outdoor sensor in full sun can report 50°C or more, so the recommended placement is shaded, north-side, and protected from direct radiation before that reading is trusted for cooling decisions.[1]

The automation order that matters during a heat wave

A heat-wave cooling automation suite should not begin with “lower the setpoint.” By the time the indoor sensor is begging for cold air, the house has already absorbed heat through glass, walls, attic, and air leaks. The more reliable sequence is:

1. Detect heat-wave mode from trustworthy indoor and outdoor temperature inputs.
2. Shade each façade when the sun angle actually threatens that façade.
3. Free-cool only when outdoor air is meaningfully cooler than indoor air.
4. Run AC or fans only when occupancy, windows, device ratings, and comfort goals allow it.

That order is also easier to debug. If the shades misfire, you look at sun position and cover state. If free cooling misfires, you look at the indoor/outdoor delta and sensor placement. If AC misfires, you inspect occupancy, window sensors, thermostat state, and switch ratings. A single all-in-one “cool my house” automation may look elegant until a stuck contact sensor leaves someone sitting in a hot room.

Automated shading is the one part where vendor claims sound tempting. Somfy says automated sun protection can keep homes 4–7°C cooler and reduce AC use by up to 70%, but the cited figures come from a 2010 French Building Federation study and 2021 Carbone 4 simulations commissioned by Somfy. Treat that as vendor-commissioned context for why shading deserves attention, not independent proof that your retrofit will hit those numbers.[2]

Place the outdoor sensor before you trust the outdoor number

The outdoor temperature sensor is the load-bearing sensor in this whole stack. It decides whether heat-wave mode starts. It decides whether the free-cooling delta is real. If that sensor is baking on a south wall, the automation will make confident bad decisions.

Use a shaded north-side placement where possible, under an eave or shielded from direct sun and radiant wall heat. Then sanity-check it during the first hot afternoon: compare it with a nearby weather station, a shaded manual thermometer, or another known-good outdoor sensor. Do not tune your free-cooling delta until the outdoor reading behaves like outside air rather than a solar collector.

Recipe: Home Assistant heat-wave timing suite

This Home Assistant version expresses the July 2026 workflow in NestGrid recipe form. Replace every entity ID before enabling it. Keep the automation disabled until the template sensors show sensible values for at least one normal day and one hot afternoon.

template:
  - binary_sensor:
      - name: Heat Wave Mode
        unique_id: heat_wave_mode_nestgrid_investigating
        state: >
          {{ states('sensor.outdoor_temperature_shaded') | float(0) >= 30
             or states('sensor.living_room_temperature') | float(0) >= 26 }}
      - name: Outdoor Cooler For Free Cooling
        unique_id: outdoor_cooler_for_free_cooling_nestgrid_investigating
        state: >
          {{ (states('sensor.living_room_temperature') | float(0)
              - states('sensor.outdoor_temperature_shaded') | float(0)) >= 1.5 }}
      - name: All Cooling Windows Closed
        unique_id: all_cooling_windows_closed_nestgrid_investigating
        state: >
          {{ is_state('binary_sensor.living_room_window', 'off')
             and is_state('binary_sensor.bedroom_window', 'off') }}

automation:
  - alias: Heat wave shade east facade by sun azimuth
    id: heat_wave_shade_east_facade_nestgrid_investigating
    mode: single
    trigger:
      - platform: state
        entity_id: binary_sensor.heat_wave_mode
        to: 'on'
      - platform: numeric_state
        entity_id: sun.sun
        attribute: azimuth
        above: 60
        below: 130
    condition:
      - condition: state
        entity_id: binary_sensor.heat_wave_mode
        state: 'on'
      - condition: numeric_state
        entity_id: sun.sun
        attribute: azimuth
        above: 60
        below: 130
    action:
      - service: cover.set_cover_position
        target:
          entity_id: cover.east_shutters
        data:
          position: 25

  - alias: Heat wave shade south facade by sun azimuth
    id: heat_wave_shade_south_facade_nestgrid_investigating
    mode: single
    trigger:
      - platform: state
        entity_id: binary_sensor.heat_wave_mode
        to: 'on'
      - platform: numeric_state
        entity_id: sun.sun
        attribute: azimuth
        above: 140
        below: 220
    condition:
      - condition: state
        entity_id: binary_sensor.heat_wave_mode
        state: 'on'
      - condition: numeric_state
        entity_id: sun.sun
        attribute: azimuth
        above: 140
        below: 220
    action:
      - service: cover.set_cover_position
        target:
          entity_id: cover.south_shutters
        data:
          position: 25

  - alias: Heat wave shade west facade by sun azimuth
    id: heat_wave_shade_west_facade_nestgrid_investigating
    mode: single
    trigger:
      - platform: state
        entity_id: binary_sensor.heat_wave_mode
        to: 'on'
      - platform: numeric_state
        entity_id: sun.sun
        attribute: azimuth
        above: 230
        below: 310
    condition:
      - condition: state
        entity_id: binary_sensor.heat_wave_mode
        state: 'on'
      - condition: numeric_state
        entity_id: sun.sun
        attribute: azimuth
        above: 230
        below: 310
    action:
      - service: cover.set_cover_position
        target:
          entity_id: cover.west_shutters
        data:
          position: 25

  - alias: Notify when outdoor air is useful for free cooling
    id: notify_free_cooling_window_nestgrid_investigating
    mode: single
    trigger:
      - platform: state
        entity_id: binary_sensor.outdoor_cooler_for_free_cooling
        to: 'on'
        for: '00:10:00'
    condition:
      - condition: state
        entity_id: binary_sensor.heat_wave_mode
        state: 'on'
    action:
      - service: notify.mobile_app_your_phone
        data:
          title: Free-cooling window open
          message: Outdoor air is at least 1.5°C cooler than the living room. Open selected windows if air quality and security are acceptable.

  - alias: Allow AC only when hot occupied and windows closed
    id: allow_ac_hot_occupied_windows_closed_nestgrid_investigating
    mode: restart
    trigger:
      - platform: state
        entity_id:
          - binary_sensor.heat_wave_mode
          - binary_sensor.someone_home
          - binary_sensor.all_cooling_windows_closed
      - platform: numeric_state
        entity_id: sensor.living_room_temperature
        above: 26
    condition:
      - condition: state
        entity_id: binary_sensor.heat_wave_mode
        state: 'on'
      - condition: state
        entity_id: binary_sensor.someone_home
        state: 'on'
      - condition: state
        entity_id: binary_sensor.all_cooling_windows_closed
        state: 'on'
    action:
      - service: switch.turn_on
        target:
          entity_id: switch.window_ac_rated_plug

  - alias: Turn off AC when a cooling window opens
    id: turn_off_ac_when_window_opens_nestgrid_investigating
    mode: single
    trigger:
      - platform: state
        entity_id: binary_sensor.all_cooling_windows_closed
        to: 'off'
        for: '00:02:00'
    action:
      - service: switch.turn_off
        target:
          entity_id: switch.window_ac_rated_plug

Two details are easy to miss in that YAML. First, the shutter position of 25 means the covers are mostly closed only if your cover integration reports 0 as closed and 100 as open. Some integrations invert or abstract this differently, so test one cover manually before letting all façades move. Second, the free-cooling automation sends a notification instead of opening windows automatically. Motorized window control is a different risk profile; air quality, rain, security, pets, and sleeping rooms matter.

If you already use NestGrid’s heat-wave temperature alert setup, keep that alert as the human-facing layer and let this suite handle the mechanical timing. The 26°C living-room trigger appears in both places, but here it is a starting threshold for automation logic, not a comfort promise.

What to verify locally in Home Assistant

• Confirm that sun.sun azimuth values match your house orientation. A façade that is called “west” in your head may not be aligned with the example 230–310° range.
• Watch the first shutter event in person. Stop using the recipe if a cover stalls, reports the wrong position, or closes onto an obstruction.
• Log indoor and outdoor temperatures before trusting the 1.5°C free-cooling delta. A small sensor offset can erase that margin.
• Make the AC action reversible. The matching “window opened” shutoff automation is not optional when a window sensor is part of the logic.

Sun-azimuth shading: the cleanest automation in the set

Shading by clock time is a blunt tool. Shading by sun azimuth lets the same house behave differently in the morning, midday, and late afternoon. The July 2026 workflow uses approximate azimuth windows of 60–130° for east, 140–220° for south, and 230–310° for west, with shutters around 70–80% closed to block most radiation while keeping some daylight.[1]

Those ranges are good enough to copy as a starting template, then they need a ladder, a notebook, or at least an afternoon of looking at where the sun actually lands. A deep porch, neighboring building, deciduous tree, reflective driveway, or west-facing glass door can move the useful range. The recipe’s job is not to prove geometry; it is to stop the house from becoming a greenhouse while everyone is at work, asleep, or tired of babysitting blinds.

Do not make every cover follow the same command. Bedrooms may need privacy behavior. Sliding doors may be emergency exits. Some shades tolerate daily partial movement better than others. If a motor has weak position reporting, use a conservative command and a notification rather than a silent full close.

Free cooling: useful only when the delta is real

Free cooling sounds like the easiest automation in the world: open windows when outside is cooler. The hard part is deciding when “cooler” is meaningful. The Maison et Domotique example waits until outside is at least 1.5°C cooler than inside before sending the free-cooling notification.[1]

That 1.5°C margin is a practical guard against noise. If your indoor sensor reads high because it sits above electronics, or your outdoor sensor reads low because it is close to an irrigated garden, the automation can invite in the wrong air. Start with a notification, not automatic window control. If the alert feels late, lower the delta slightly after you have data. If it feels early or the room gets muggy, raise it or add humidity and air-quality conditions.

The action can also be room-specific. A downstairs cross-breeze may help without opening a sun-baked upstairs bedroom. A sleeping household may prefer a quiet notification in the morning and an audible one in the evening. The delta gives permission to consider outdoor air; it does not decide which window is safe to open.

AC and fan gating: where automation has to be polite

The AC gate is the part most likely to punish a household member for a bad sensor. The reference workflow allows AC only when three conditions are true at the same time: the home is too hot, someone is home, and windows are closed.[1] That is the right shape. It is also the shape that needs the most local checking.

For a window AC on a smart plug, remember what the plug can and cannot do. Wirecutter’s 2020 window-AC smart-plug guidance is still useful on the core point: a smart plug provides on/off control only, not temperature, mode, or fan-speed control, and it must be rated for the AC’s amperage draw.[3] If the unit does not resume safely after power loss, or if the plug rating is unclear, do not use this recipe for that AC.

Fans belong behind presence and time gates. A fan can make a person feel more comfortable, but it is not cooling the room itself. CNET’s heat-tech roundup treats fans, filter maintenance, and weatherstripping as supporting tactics rather than a substitute for cooling equipment.[4] That is the right weight for them here: run a fan when someone is in the room or for a short post-arrival comfort burst, then shut it off.

If you are using plugs for fans or window ACs, cross-check NestGrid’s senior heat-safety smart device compatibility notes for the plug-rating and fail-safe side of the decision. A heat-wave automation that turns off the only cooling appliance because a contact sensor fell off the frame is not a smart-home win.

Recipe: Hubitat Rule Machine translation

Hubitat’s translation should be built as several small Rule Machine rules, not one heroic rule. Use Hubitat variables or virtual switches for the shared state so that you can see what the hub believes before it moves anything.

Hubitat users should be especially careful with “someone home.” Presence can be a phone, a key fob, a mode, a motion pattern, or a virtual switch set by another system. Do not let a flaky phone presence rule decide whether cooling is allowed in an occupied house. If the household includes children, older adults, pets, or anyone who may be home without a tracked phone, make occupancy conservative or leave AC control manual.

Recipe: SmartThings routine translation

SmartThings can express the logic, but the exact menu path depends on which capabilities each device exposes. Do not assume a shade driver supports a true percentage position, or that a thermostat exposes the same cooling controls as a switch. Build the routines in layers:

1. Create a Heat Wave Mode virtual switch or scene trigger. Turn it on when the shaded outdoor sensor reaches your outdoor threshold or the main room reaches your indoor threshold.
2. Create separate east, south, and west shade routines. Each routine should require Heat Wave Mode and the appropriate time or sun-position proxy available to your setup. If true azimuth is not available, use conservative time windows and verify them visually.
3. Create a free-cooling notification routine if SmartThings can compare the two temperatures directly. If not, compute the delta in another service or keep this part as a dashboard tile and manual notification.
4. Create an AC permission routine requiring Heat Wave Mode, home/room occupancy, and all relevant windows closed.
5. Create a separate window-open routine that turns off the AC switch or revokes cooling permission after a short delay.

The SmartThings version is least portable at the screen-tap level. A copied condition list can fail quietly if one device reports “open/closed,” another reports “contact,” and a third exposes only a cloud scene. Test with the AC unplugged or the thermostat action disabled first; watch the virtual switch and notifications before you allow physical cooling control.

Recipe: Zigbee2MQTT device-state layer

Zigbee2MQTT is not the whole automation brain in this recipe. It is the device-state layer. The cooling logic should live in Home Assistant, Node-RED, or another engine that can compare temperatures, evaluate sun position, and apply multi-condition gates. What Zigbee2MQTT gives you is inspectable device state and command topics.

# Example topic map only. Replace with your actual Zigbee2MQTT friendly names.
# Use these topics in Home Assistant MQTT sensors, Node-RED, or another automation engine.

zigbee2mqtt_topics:
  outdoor_temperature_shaded: zigbee2mqtt/outdoor_temp_shaded
  living_room_temperature: zigbee2mqtt/living_room_temp
  living_room_window: zigbee2mqtt/living_room_window
  bedroom_window: zigbee2mqtt/bedroom_window
  living_room_occupancy: zigbee2mqtt/living_room_occupancy
  east_shutters_set: zigbee2mqtt/east_shutters/set
  south_shutters_set: zigbee2mqtt/south_shutters/set
  west_shutters_set: zigbee2mqtt/west_shutters/set
  ac_plug_set: zigbee2mqtt/window_ac_plug/set

example_commands:
  mostly_close_east_shutters_payload: '{"position":25}'
  turn_on_ac_plug_payload: '{"state":"ON"}'
  turn_off_ac_plug_payload: '{"state":"OFF"}'

Before building the automation, open the Zigbee2MQTT state page or subscribe to the topics and watch every device change. Confirm which payload means open, closed, occupied, unoccupied, online, and offline. A retained stale “closed” window state is a bad foundation for AC permission.

If your Zigbee shades support percentage commands, test one shade at a time and confirm whether 25 means mostly closed or mostly open. If they support only open/close/stop, the safer translation is a timed partial-close scene that you observe and adjust, not a made-up percentage.

Starting thresholds, with the parts you should change first

For thermostat schedules, setback claims, and pre-cooling tradeoffs, use the companion NestGrid pages instead of folding that whole debate into this recipe. The claim-checked cooling overview is Verified Smart Home Cooling Tips to Beat Summer Heat; the savings comparison is at smart thermostat savings comparison. If your real problem is a central-system schedule during extreme heat, see cooling schedule for a 115-degree heat wave and smart thermostat heat-dome settings.

Demand-response events are adjacent, not the center of this recipe. If your utility can change setpoints or request load reductions, check demand-response-compatible smart devices before letting a heat-wave automation and a utility program fight over the same thermostat.

Keep the Investigating label on your copy until you have watched it on your own hub, with your own sensors, during your own hot afternoon.

References

1. Heatwave and home automation: turn Home Assistant into a heat shield, Maison et Domotique, July 2026.
2. Automated sun protection: how to keep your home cooler during heatwaves, Somfy, May 2024.
3. How I Made My Window ACs Smarter Than Central Air, Wirecutter, 2020.
4. 10 Home Tech Hacks to Cool Down While Still Saving Money on Energy Bills, CNET.