How to Build a Multi-Stage Intrusion Alarm with Escalating Responses in Home Assistant

Let's be real. The standard security alarm is a drama queen. One door opens after midnight? It goes from zero to DEFCON 1, shrieking like a banshee and scaring your cats. It's a single, blunt instrument. But a break-in isn't a binary event. It's a sequence. A window rattles. A door opens. Movement in the hallway. Your defense should be just as smart. Here's how to build an alarm that thinks, judges, and escalates.

Designing the Escalation: From Whisper to Shout

You need rules of engagement. We're building three distinct tiers. Stage one is silent awareness. A sensor trips. Your phone gets a gentle, silent notification. "Hey, the garage door just opened. Probably you coming home from the bar. But maybe not." Stage two is active alert. A second, unrelated sensor triggers within two minutes. Now the system assumes something's up. Lights in the house flash twice. A spoken TTS alert plays on your Google Nest: "Motion detected in the living room." Stage three is full-blown, no-holds-barred alarm. A third trigger, or motion in a critical zone like the bedroom. This is when the sirens (real and virtual) go off, lights strobe, and an emergency notification is sent. It's contextual. It's scary-smart.

Get Your Sensors & Helpers Talking the Same Language

First, gear. You need sensors. Door/window contacts, motion detectors, maybe a camera with person detection. All linked to Home Assistant. Next, we create the brain's short-term memory: Helpers. Create an Input Boolean called `alarm_armed`. That's your master switch. Then, create another called `alarm_triggered`. This is the system's internal state. It's not the siren; it's the decision *to* sound the siren. This separation is everything. It lets you build logic *around* the alarm state, instead of the alarm being the only logic.

Writing the Automations: The If-This-Then-That Ballet

This is where the magic happens. You're not writing one automation. You're writing a little orchestra of them. Automation one: When `alarm_armed` turns on, reset `alarm_triggered` to off. Clean slate. Automation two (Stage 1): If `alarm_armed` is on, and a door sensor opens, send a quiet notification to your phone. Set a timer for 120 seconds. Automation three (Stage 2): If, during that timer, a motion sensor triggers, that's your escalation condition. Now, you flash the lights, speak the alert, and set `alarm_triggered` to ON. Automation four (Stage 3): If `alarm_triggered` is ON and *another* sensor goes off—boom. Activate your siren entity (a smart plug with a siren, an Alarmo integration), strobe every light, and send a critical push notification with a snapshot. It's a beautiful, terrifying chain reaction.

Seeing is Believing: The Alarm Panel Dashboard

All this logic is useless if you can't control it with a panicked, half-asleep thumb. Build a dedicated dashboard. A huge, friendly button to arm and disarm. A clear visual status: "Armed. Stage 1 Active." Live status of every sensor. Maybe a map of your home with red/green dots. This is your command center. It turns a complex web of automations into a simple, "Oh, I see what's happening" interface. Use picture-elements or Mushroom cards. Make it idiot-proof. Because at 3 AM, you're the idiot.

Now Go Test It (And Scare Your Partner)

Arm the system. Open a door. Check your phone. Wait. Walk in front of a motion sensor. Your lights should flash. The house should tell on you. It's unnervingly cool. This isn't just an alarm. It's a system that perceives intent. It buys you time, information, and a terrifying advantage over anyone who shouldn't be there