🌪️ Sierra Nevada Alert Bot — Intel the Moment It Happens

It started as a question, the way these things do: could I even do this? Could one person, with no server and no budget, watch an entire mountain range — every fire, flood, quake, and storm across four hundred miles of the most violent terrain in the Lower 48 — and know about each one the moment it happened, instead of finding out by accident while scrolling?

I did not know the answer when I started. That was the appeal. I wanted to find out how the data actually moved — where the federal feeds lived, what they cost, how fast they updated, whether you could stitch them together into something that watched the Sierra so I didn't have to. The honest shape of the project was a vision quest disguised as a weather bot. I'd pull one thread, learn how a single feed worked, get it posting, and then immediately see the next thread. Seven feeds later, here we are.

The mission crystallized somewhere in the middle of building it. I didn't want a dashboard I had to remember to check. I didn't want to discover a fire near my area of interest because it finally got big enough to trend. I wanted the intel pushed to me — to wherever I already was — the moment the data showed something worth knowing. Near-real-time situational awareness for a place I love, built out of public feeds and a free runner. That became the whole point.

What It Watches

The bot, posting as @SierraNevadaWX, pulls from seven live federal data streams every few minutes on GitHub Actions. Each one answers a different question about whether the mountains are about to do something.

The Sierra bounding box runs from -121.0°W to -117.5°W and 35.5°N to 41.5°N — Lassen in the north to the White Mountains in the south, Central Valley foothills to the Nevada Great Basin. Everything inside that box is fair game. Everything outside it is somebody else's problem.

The Rivers, and the Thresholds That Matter

When the snowpack releases, it all goes somewhere. The flood logic is the part I'm most careful about, because it's the part most likely to either cry wolf or miss the real thing.

Flood stages come from the NWS and the California-Nevada River Forecast Center. The bot stays silent at "action stage" — the watch-it level — and only speaks at minor flood, the point where water starts doing damage. A gauge reading nineteen feet below flood stage is not a tweet. It is just a river being a river. The thresholds are the difference between a feed people trust and a feed people mute.

The Science Tools

Partway through, the project stopped being just a bot. Watching the alerts fire made me want to understand why — to read the atmosphere myself, not just relay its verdicts. So the repo grew a toolkit.

Skew-T Log-P soundings. Twice a day, weather balloons launch from Reno, Oakland, Salt Lake City, and Vandenberg, rising to 100,000 feet and measuring temperature, humidity, and wind every few meters on the way up. A MetPy script pulls that data from the Iowa State upper-air archive and plots a professional Skew-T: temperature and dewpoint profiles, wind barbs showing shear with altitude, the parcel path with CAPE and CIN shaded, LCL/LFC/EL markers, a hodograph inset, and an indices panel.

When Reno shows CAPE near zero and a massive dewpoint depression between 500 and 700 hPa, that's the Great Basin drying out — a classic setup for dry lightning and high fire danger on the eastern slope by afternoon. When Salt Lake City shows negative lifted index with no cap, that instability is heading your way.

That's the payoff: a morning sounding tells you what the afternoon is likely to do, hours before it does it. The eastern Sierra is a dry-lightning machine, and dry lightning is how a lot of the bad fire seasons begin.

NEXRAD Level 2 dual-pol analysis. NOAA puts every NEXRAD radar scan on AWS S3 within seconds of it completing — free, public, real-time. A Py-ART script pulls the latest volume, reads all six dual-polarization fields, and renders a dark six-panel analysis plot with automatic signature detection.

The detector flags three signatures automatically: a tornado debris signature (Z>40 and CC<0.80 — lofted non-meteorological debris, the radar fingerprint of a tornado actually on the ground), a TVS proxy (Z>45 and high spectrum width), and a hail signature (Z>55 with ZDR near zero). When magenta dots light up the CC panel, something is very wrong on the ground below.

A Day in the Life

On June 4, 2026, while I was still building this thing, a severe thunderstorm outbreak fired over north-central Oklahoma. The bot kept watching the Sierra; I pivoted the NEXRAD tool east to see what it could do against real weather.

The KVNX radar near Vance Air Force Base showed a massive bow echo over Alfalfa and Garfield County. The detector flagged 54 pixels of possible tornado debris — CC below 0.80 inside a high-reflectivity core near Enid — and 11 pixels of hail signature. There was a tornado warning polygon active over the same area.

But the signature didn't hold up under scrutiny, and that's the actually interesting part. The CC was 0.75 to 0.79 — not the 0.60 you'd expect from a genuine debris field. The velocity panel was range-folded. Read across all six fields in context, it was a hail-and-rain mixture, not lofted debris. The automatic flag was a starting point, not a verdict.

Signatures must be read in context across all six fields. The detector points; the human confirms. Science in real time — that's the point.

How It's Built

Same pattern as everything else in this collection. Python, one runner, no server, no database.

The whole thing runs on Python 3.12, managed by pixi for reproducibility — the same lockfile-pinned environment locally and on the runner, so a bot that fires unattended every five minutes forever never falls victim to "works on my machine." Deduplication is a SHA cache committed back to posted_ids.json on every run; the repository is the bot's memory, and the commit history is its log. Tweepy handles posting. AirNow needs a free API key; everything else is open public data, no key required.

Total infrastructure cost: zero. GitHub's free Actions tier covers the whole schedule with room to spare. A bad fire day that lights up every feed at once costs exactly the same as a quiet blue-sky Tuesday — nothing. The infrastructure doesn't care how much weather there is.

What This Is Actually About

The bot is the surface. Underneath, this was a project about closing the gap between when something happens and when I find out. The old way — open an app, scroll, hope something relevant surfaces — puts you minutes or hours behind, and behind is exactly the wrong place to be with a fire or a flash flood. The whole exercise was about flipping that: data finds me the instant it changes, pushed to where I already am.

And it taught me the thing I keep relearning with these builds. GitHub Actions is not a CI tool — it is a free, reliable cron server that watches the world for you. Seven federal agencies publish this data, in clean APIs, paid for by the public, because it is a public good. The plumbing to stitch it together and push it somewhere useful should be cheap and easy, and it is. A repository can be its own database. A free runner can watch a mountain range. One person can build a thing that knows, in near-real-time, when the Sierra is about to do something.

It's still growing. More feeds, more analysis scripts, a static dashboard fed by the same polls — the goal is to be able to drop into any situation, anywhere in the area of interest, and read it as it unfolds. It started as a question about whether I could do it at all. The answer turned out to be yes, and the better answer turned out to be: and here is everything I learned on the way.

Live on X at @SierraNevadaWX. Open source at github.com/bdgroves/sierra-alert-bot. Built in Lakewood, Washington, watching the Sierra Nevada.