A Raspberry Pi is not a toy. It's a $35, 4-watt Linux machine with root access, a GPIO header, and network connectivity — everything you need to build automation that would cost $20/month on a VPS. I've been running a Pi 4 as my personal automation server for over a year now, and it has quietly become the most useful computer I own.
Here are seven setups — call them hacks, projects, or workflows — that made the biggest difference. All of them run headless, all of them survive reboots, and none of them required more than an afternoon to build.
1. The Network Watchdog That Reboots My Router
My ISP's router hangs roughly once a week. Instead of noticing the outage and fixing it by hand, the Pi notices for me. A cron job pings a couple of reliable hosts every five minutes; if both fail three times in a row, it toggles a smart plug via a local API and waits for the router to come back.
# watchdog.py — runs every 5 min via cron
import subprocess, requests, time
def internet_ok():
for host in ["1.1.1.1", "9.9.9.9"]:
try:
subprocess.run(["ping", "-c1", "-W2", host],
check=True, capture_output=True)
return True
except subprocess.CalledProcessError:
continue
return False
fails = int(open("/tmp/watchdog_fails").read() or "0") if True else 0
# ... persist fail count, trip smart plug at 3 consecutive failures
Since deploying this, my household has had exactly zero "internet is down and nobody knows" moments.
2. An Ad-Hoc DNS Sinkhole for the Whole LAN
Install Pi-hole on the Pi, point your router's DHCP DNS at it, and every device on the network gets ad blocking for free. That's the standard setup. The hack part: I feed it a cron job that merges community blocklists with my own — any domain that appears in my web server access logs more than 50 times a day from bots gets auto-blacklisted. The Pi defends its own attention budget.
3. The "Digital Tripwire" With a Webcam
An old USB webcam + OpenCV gives you a motion-detecting security camera in about 30 lines. The trick that makes it actually useful: instead of streaming video, the Pi only wakes fully when motion crosses a threshold, captures a burst of frames, and pushes them to me via a Telegram bot. Idle power stays low, and I get a photo instead of a firehose.
import cv2
cap = cv2.VideoCapture(0)
prev = None
while True:
ok, frame = cap.read()
if not ok: continue
gray = cv2.resize(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY), (64, 48))
if prev is not None and cv2.absdiff(gray, prev).mean() > 25:
send_snapshot(frame) # Telegram bot API call
prev = gray
4. Overnight AI Recon on a Schedule
This is where the Pi stops doing chores and starts doing knowledge work. Every night at 2am, a cron entry kicks off an agent loop that checks my inbox, reads RSS feeds, scans security advisories for software I actually run, and writes a morning briefing as markdown. I read it with coffee; the Pi did the reading at 2am.
The agent plumbing — LLM client with retries, checkpointing so a crash resumes instead of restarting, structured JSON outputs — is the exact stack that ships in my AI Agent Toolkit ($9, one-time). You can absolutely hand-roll all of it, but if you want the boring parts pre-built so you can focus on what the agent actually does, that's what it's for. It runs happily on a Pi 4 with 2GB of RAM because the heavy lifting happens in the cloud — the Pi just orchestrates.
5. Automated Backup Sentry
The Pi runs my restic backups to two destinations: a USB drive and an offsite B2 bucket. The hack isn't the backup script — it's the verification job. Weekly, it restores a random file from last week's snapshot and checks the hash. Backups you've never restored are just optimistic fiction; this turns mine into tested fact. Failures (and successes) land in the morning briefing from hack #4.
6. Bug Bounty Recon on a Timer
Security researchers know the drill: subdomain enumeration, port scanning, screenshot capture. Doing it manually is a waste of a human. My Pi runs the same four-stage pipeline every night against targets I'm authorized to test — asset discovery, passive fingerprinting, change detection against yesterday's results, and a diff report. New subdomains show up in my inbox before breakfast.
The full pipeline, with every script and config, is documented step by step in my Bug Bounty Automation Kit — a $15 tutorial + toolkit. The Pi's low power draw matters here: recon is a waiting game, and a machine that costs pennies per month can afford to be patient.
7. The Pi That Monitors Itself
Meta, but essential: a tiny daemon logs CPU temperature, memory, disk usage, and every cron job's exit status to SQLite. A nightly query flags anything anomalous. My Pi has warned me about a filling SD card and a runaway script twice now — both times before anything broke. If you run any of the above, build this first.
The Bigger Picture
Every one of these follows the same pattern: cheap hardware + cron + a little Python beats paying for a service or doing it by hand. The Pi isn't powerful, and that's the feature — it forces lean, focused automation, and it never sends you a bill.
All of the source for these setups lives in my agent store repo, and the two kits linked above are the deepest dives if you want to go further.
Which one are you building first? I'd start with #1 or #5 — both take under two hours and pay off immediately.
Top comments (0)