The ESP32 as a Home Lab Workhorse: 5 Jobs It Does Better Than a Pi

When you do not need a full Linux box.

I have a drawer full of Raspberry Pis. Pi 3s, Pi 4s, a Pi 5 that runs hot enough to warm my office. I love them. But over the last two years, I have quietly replaced almost half of them with $7 ESP32s and I have not looked back.

A Pi is a full Linux computer. That is great when you need Linux. For a lot of always-on home lab jobs, you do not need Linux. You need something that boots in less than a second, survives a power cut without corrupting an SD card, sips power, and costs less than lunch.

That is the ESP32.

Here is where it actually wins in a real home lab, with real power and cost numbers, and how I run each one today.

The Real Cost Difference No One Talks About

Let us skip the spec sheet and talk about what you pay every day.

A Raspberry Pi 4 or 5 idling with a decent SD card and power supply pulls about 3 to 5 watts. Under load it is closer to 8 to 12. Leave it on 24/7 and that is roughly 35 to 45 kWh per year. Depending on where you live, that is 5 to 12 dollars per device per year, just to keep it on.

An ESP32 devkit idling with Wi-Fi on pulls about 0.15 to 0.25 watts. With deep sleep between readings, my average is 0.08 to 0.12 watts. That is 0.7 to 1 kWh per year. About 30 cents to a dollar per year. You can run ten ESP32s for less power than one idle Pi 4.

Cost up front is similar. A Pi with a good SD card, power supply, and case is 45 to 80 dollars. An ESP32 devkit with a case is 6 to 12 dollars. The difference is not just money. It is maintenance. Pis need updates, they need SD card replacements, they need 20 to 45 seconds to boot after a power cut. An ESP32 boots instantly, has no OS to patch in the traditional sense, and you can literally unplug it while it is writing and it will come back.

If the job does not need Docker, Python with heavy libraries, or video processing, the ESP32 is almost always the calmer choice.

1. BLE Proxy for Home Assistant

This is the easiest win.

If you have any BLE devices, Switchbot meters, Xiaomi temp sensors, plant moisture sensors, Switchbot locks, cheap beacons, you know Bluetooth range is short. You need proxies in different rooms.

I used to run Pi Zero Ws as Bluetooth proxies. They worked, until they did not. The Bluetooth stack would hang, the SD card would die in the summer heat, and I was running a full Linux box just to forward a temperature reading.

Now every room has an ESP32 running ESPHome as a BLE proxy. You flash it once and forget it.

esp32:
  board: esp32dev

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

api:
bluetooth_proxy:
  active: true

Add it to Home Assistant and it immediately starts forwarding every BLE advertisement in that room. No bluetoothctl, no pairing, no scripts that crash at 2am.

I run four of them. One in the living room, one in the bedroom, one in the office, one near the front door. Combined power draw is about 0.6 watts. Less than a single Pi 4 on idle. Uptime is 11 months and counting without a single reboot. A Pi Zero W fleet could never do that. Each Zero was 25 dollars plus an SD card and about 1.2 watts. Each ESP32 is 7 dollars and basically disappears on your network.

If you use Home Assistant, start here. Flash one, put it where your BLE devices are flaky, and watch them become reliable.

2. Presence Detection That Does Not Need a Camera

There are two versions of presence detection I actually trust, and both are better on ESP32.

First, BLE presence. Your phone, your watch, a little Tile on your keys. They broadcast BLE. ESP32s in each room listen and report signal strength. Home Assistant tools like Bermuda or ESPresense use those signal strengths to figure out which room you are in. Lights follow you, the office does not turn off when you are sitting still, no cloud needed.

Second, mmWave with an ESP32-S3. This is the real upgrade. A small mmWave radar module like the LD2410 or C4001, about 10 to 14 dollars, paired with an ESP32-S3, can detect a person sitting still and breathing. PIR sensors fail the moment you stop moving. mmWave does not. It can even tell you if someone has fallen, which is why I put one in my hallway for my parents when they visit.

A Pi can do this, but you end up running Python, managing a Bluetooth stack that loves to crash, and burning 4 to 5 watts to answer a simple question: is someone in this room.

My setup is simple. An S3 plus LD2410 in the office keeps the lights and desk fan on as long as I am at the desk, even if I am not typing. An ESP32 BLE proxy in the bedroom handles the phone-based presence so the bedroom goes dark two minutes after I leave.

Total hardware for the mmWave node was 18 dollars. Power is about 0.2 watts. The Pi version of the same job would be 65 dollars with a relay hat, 4 watts, and you would still be writing the Python yourself and babysitting it.

3. Serial Bridge and Remote Console

This is the unsexy one that saves you the most walking.

You have devices that only speak serial. A 3D printer mainboard, a managed switch, an OPNsense box, a router console port, or another microcontroller you are debugging. You need to reach that serial port from your desk.

I used to keep a Pi next to my printer running ser2net. It worked until the SD card died mid-print. Twice.

Now I use an ESP32 as a Wi-Fi to serial bridge. You can power it from the host device itself, it boots instantly, and it never corrupts.

With ESPHome, you can expose a simple service to send commands:

uart:
  id: printer_uart
  tx_pin: GPIO1
  rx_pin: GPIO3
  baud_rate: 115200

api:
  services:
    - service: send_gcode
      variables:
        cmd: string
      then:
        - uart.write: !lambda 'return cmd + "\n";'

Or flash esp-link if you want a raw TCP to serial bridge you can telnet into. I have one permanently soldered inside my 3D printer, one on my network switch console port, and one on a breadboard as a field tool I can clip onto anything.

Why this is better than a Pi: a Pi needs its own power brick, its own SD card, and it cares about clean shutdowns. The ESP32 does not. I power mine from the 5V rail of the printer itself. When the printer turns off, the ESP32 turns off. When it turns on, the ESP32 is already ready. No filesystem to fix, no waiting.

Cost: 7 dollars. Power: effectively zero because it rides on the host. A Pi solution is 40 dollars plus a power brick and a place to mount it.

4. Local Matter Controller and Smart Switch Logic Node

Everyone bought Matter devices for local control. Then they realized they still needed something to run the automations locally.

You do not need a Pi to control your lights if the logic can live right at the switch.

I have a single ESP32-S3 behind a 4-gang switch plate in my kitchen. It reads four physical buttons, drives four relays, and exposes itself as four Matter lights. Apple Home, Google Home, and Home Assistant all see it locally over Wi-Fi. If Home Assistant is down for an update, the physical buttons still work because the logic is on the ESP32 itself, not in the cloud and not on a Pi.

The newer ESP32-C6 and S3 boards support Matter and Thread natively. Espressif's Matter SDK has gotten actually usable. You can build a Thread border router or a Matter bridge for 9 dollars that lives inside a wall box.

Here is the simplified ESPHome version I use for the kitchen:

binary_sensor:
  - platform: gpio
    pin: GPIO4
    name: "Kitchen Button 1"
    on_press:
      - light.toggle: kitchen_light_1

light:
  - platform: binary
    name: "Kitchen Light 1"
    id: kitchen_light_1
    output: relay_1

output:
  - platform: gpio
    id: relay_1
    pin: GPIO10

The big win here is family approval. If your lights depend on a Pi and the Pi SD card dies, your kitchen switches stop working and everyone in the house is annoyed. If the logic lives on the ESP32 at the switch, it keeps working even if your entire home server is off.

Power: about 0.2 watts. Cost: a relay board with ESP32 is about 12 dollars. A Pi with a relay HAT is 55 dollars, uses 4 watts, and makes your lights dependent on Linux booting.

5. Battery-Powered Environmental Logger You Actually Keep Running

A Raspberry Pi cannot do this job on battery. An ESP32 can do it for months.

The pattern is simple. Deep sleep for 10 to 15 minutes, wake up, read a sensor, send the reading over Wi-Fi or ESP-NOW, go back to sleep. On a single 18650 cell, that is 3 to 6 months of runtime. With a tiny 5V solar panel, it runs forever.

My balcony logger has been outside since last summer:

• ESP32 devkit plus BME280 for temperature, humidity, pressure
• 18650 cell with a TP4056 charger plus a small solar panel
• Sleeps 15 minutes at a time
• Wakes, publishes to Home Assistant over MQTT, sleeps again

Average draw is 0.09 watts. Total build cost was 14 dollars. I have three of these now. One in the server closet to catch heat spikes, one with the plants, one in the garage to warn me if it gets too cold.

The loop is about as simple as it gets:

void loop() {
  readSensors();
  sendMQTT();
  esp_sleep_enable_timer_wakeup(15 * 60 * 1000000ULL);
  esp_deep_sleep_start();
}

It recovers from power loss by itself. No fsck, no corrupted database. It just wakes up and keeps logging.

A Pi version would need a large battery, a proper charge controller, and you would still be burning watts to keep Linux alive just to read a sensor every 15 minutes. Outdoors, heat kills SD cards fast. I lost two Pi loggers that way before switching.

When You Should Still Use a Pi

Use a Pi or a mini PC when you actually need Linux. Home Assistant main instance, Frigate for camera detection, Pi-hole with large blocklists, a database, Docker containers, or anything with video or heavy Python libraries. That is not what the ESP32 is for.

The ESP32 is for everything else that is always on, low data rate, and needs to be reliable. The glue jobs. The jobs you forget about until they fail. Those are the jobs where a Pi is overkill.

If you have a home lab, try this. Pick one Pi Zero job that is just forwarding data or reading a sensor. Replace it with an ESP32 running ESPHome. Watch how much simpler that corner of your network gets. Then do another one. That is how I ended up replacing five without really planning to.

---

Build notes and templates from this post

I keep all the firmware, wiring diagrams, deep sleep templates, power measurements, and the 3D printable cases I use in the field in two guides I update regularly:

1. ESP32 Stealth Kit Guide - the complete builds from this article including BLE proxy fleet setup, mmWave presence with LD2410, serial bridge flash files, Matter relay nodes, and the battery logger with solar. Includes STLs, BOMs, and ESPHome configs I run at home. Available at numbpilled.gumroad.com

2. 100 Python & Bash Automations - the helper scripts that keep these nodes alive. MQTT to SQLite logger, battery life calculator, auto-discovery for Home Assistant, health checks that ping me on Discord if a node goes silent, and the cleanup scripts for logs and SD cards. Also at numbpilled.gumroad.com

Both come with lifetime updates. I push new configs every few weeks as I find better low-power tricks or cleaner ways to do presence.

If you build one, start with the BLE proxy. It is 20 minutes and you will immediately see why I stopped using Pis for this.