THE COMPLETE ARCHIVE
Every published transmission from the lab — deep dives, experiments, and honest constraints.
A practical, measured look at running local language models on a Raspberry Pi 5: which model sizes and quantization levels are realistic, what power and thermal limits to expect, and when a mini-PC is the better call.
How to introduce VLANs into a small homelab without turning a hobby network into an unmaintainable maze — plus the recovery steps for when segmentation locks you out.
Building home observability on Raspberry Pi without drowning the SD card: what to collect, what to skip, and how to keep the stack lighter than the workloads it watches.
A measurement-first look at running local language models at home: where quantization helps, what power draw actually looks like, and when the cloud still wins.
I2C works great on a breadboard demo and then starts failing once real cable lengths and motor noise show up. I now treat I2C reliability as a physical-layer problem first and a software problem second.
Battery-powered Arduino projects fail in two ways: unstable wake cycles and hidden current draw. I start by listing every component in active and sleep state, then I budget power in milliamp-hours before writing firmware.
For greenhouse automation, I wanted a protocol that survives long cable runs and noisy environments. Modbus RTU over RS485 is still one of the best options for this type of deployment.
Writing to SD cards looks straightforward until you hit power interruptions. I lost enough logs to treat write integrity as a first-class feature. My format is append-only CSV with periodic file sync.
PID tuning by trial-and-error is slow and inconsistent. I now tune from measured step responses and keep every run logged. First, I characterize the motor and load using open-loop PWM sweeps.
As firmware evolves, stored settings formats change. If EEPROM layout is not versioned, upgrades can silently load garbage and produce hard-to-diagnose behavior.
A kiosk device needs predictable behavior after power cuts and network drops. My Raspberry Pi setup starts from a minimal OS image with only the packages required for display and remote maintenance.
Cloud-only IoT pipelines are brittle during connectivity outages. I prefer running a local MQTT broker on Raspberry Pi and forwarding data upstream when possible.
Timelapse projects become messy when image capture, storage cleanup, and rendering are manual. On Raspberry Pi, I run the whole flow as scheduled services.
Exposing SSH or dashboards directly to the internet is unnecessary risk for small deployments. WireGuard gives a cleaner and safer remote access model.
Once Raspberry Pi projects move from prototype to unattended deployment, process supervision matters more than application code.
Mixed sensor stacks on Raspberry Pi frequently fail because of address collisions and inconsistent voltage assumptions. I now audit every module before wiring.
Small Arduino prototypes often fail when moved into real environments. The cause is rarely one major bug. It is usually the accumulation of power noise, slow memory leaks, missing timeouts, and weak recovery behavior.
Most Raspberry Pi projects run fine until they do not. Without metrics and logs, troubleshooting becomes guesswork. This post describes a minimal but production-like observability stack that fits on Pi hardware.
A gateway service sits between unreliable devices and downstream reliable infrastructure. If the gateway collapses under burst load or network instability, the whole system suffers.
Serial debugging is still central in embedded work, and Rust is excellent for building reliable terminal tooling. I structure serial utilities as pipelines: read bytes, frame messages, parse the protocol, then route structured events out.
A pump controller is not a toy project once water, pressure, and unattended operation are involved. The goal is not just controlling a relay.
Many Pi setups claim to have backups but fail the first real restore. A backup is only valid if recovery has been tested against realistic failure scenarios.
Writing `no_std` Rust firmware requires different habits than server Rust. Memory is constrained, timing is strict, and panic strategy must be deliberate.
Many firmware bugs are actually invalid state transitions. Rust helps by making state explicit and hard to misuse, modelling each controller state as an enum variant with transitions that consume the old state and return the next one.
For small IoT backends, Axum provides enough structure without heavy framework overhead. My baseline service exposes ingestion, latest status, and historical query endpoints.
A common mistake in Rust projects is mixing application and library error styles. I use `thiserror` for typed library errors and `anyhow` for top-level binaries. Libraries expose specific variants so callers can branch by cause.
Cross-compiling Rust is easy to start and hard to standardize across teams. I treat toolchains as part of the project, not local machine state. Target triples, linker config, and environment variables live in versioned project files.
Hardware abstraction layers are where embedded code often becomes difficult to test. I design traits around capabilities, then keep business logic independent from concrete drivers.
Many embedded dashboards look stable only because noise is hidden by aggressive averaging. That is not the same as accurate measurement.
Running AI inference on Raspberry Pi is possible, but stable operation needs careful pipeline design. Most failures come from bottlenecks in capture, preprocessing, or storage, not from the model itself.
RiverSentinel was designed for environmental monitoring teams that need faster incident detection than manual sampling can provide, but also need evidence quality high enough for response workflows.
This project started with a practical question: can a small home lab run like a disciplined microgrid instead of a set of independent devices fighting each other?
Hardware-connected software fails at boundaries: timing edges, flaky links, and rare protocol states. A strong test strategy must combine fast feedback with realistic integration checks.
CNCSense was built to solve a common manufacturing pain: legacy machines fail without enough warning, and maintenance teams are forced into reactive firefighting.
Many ESP32 projects run perfectly on a developer desk and collapse once deployed in apartments, offices, or industrial spaces with noisy Wi-Fi conditions. The main mistake is treating every disconnect as an exceptional event.
BatGuard is an urban biodiversity platform designed for one hard reality: ecological signals are noisy, and policy action requires credible evidence.
AquaForge started as a home-scale aquaponics controller and evolved into a real digital twin platform. The core idea was to move from reactive control to predictive operation: detect chemistry drift early and simulate intervention outcomes.
The quickest way to create a messy smart home stack is to publish raw topics without a clear model. Home Assistant integration works best when device identity, telemetry, and commands are explicitly designed.
Frostwatch is one of the most practical systems I have built: a distributed frost-risk platform for vineyards where timing matters more than dashboards. If you detect frost risk 20 minutes too late, the damage is already done.
LoRa is chosen for range and efficiency, but many nodes still miss battery targets by a large margin. The reason is usually poor budgeting assumptions and missing field validation.
PCB re-spins are expensive in time and momentum. A disciplined pre-fabrication review catches most avoidable failures. This checklist focuses on practical issues seen in mixed embedded boards.
Unstable power is behind a large share of embedded bugs: random resets, noisy ADC values, communication drops, and drifting sensor readings. Good power design is often the highest-leverage hardware improvement.
Outdoor deployments fail more from enclosure mistakes than from firmware defects. A box that looks sealed on day one can trap condensation, stress connectors, and destroy electronics over time.
Edge devices frequently run with broad network exposure and weak maintenance. Security hardening has to be practical, repeatable, and automation-friendly.
MQTT starts simple and becomes chaotic quickly if naming, ownership, and evolution rules are not defined. Topic governance is not bureaucracy. It is how teams avoid accidental coupling and fragile integrations.
Telemetry schema changes are inevitable: new sensors, renamed fields, unit corrections, derived metrics. If evolution is unmanaged, dashboards break silently and analytics lose trust.
OTA updates are high leverage and high risk. A weak update process can brick large parts of a fleet quickly. A strong one reduces support load and security risk while preserving device availability.
Docker Compose is ideal for Raspberry Pi homelabs, but many setups become fragile because of ad-hoc service definitions and weak data persistence planning.
Detailed comparison of Protobuf and JSON in Rust telemetry pipelines across performance, compatibility, and operability.
A long retrospective on how I hardened a Debian 12 VPS for public internet exposure with practical config details and operational lessons.
A detailed retrospective on using Apache2 as a reverse proxy in front of legacy internal applications with TLS, auth, and rollout control.
A long practical report on setting up Nginx edge caching and predictable zero-downtime deployments on a small VPS stack.
A deep retrospective on running Traefik for many self-hosted services with dynamic routing, middleware policy, and safer operations.
A detailed retrospective on building and operating a small k3s Kubernetes cluster in a homelab, including networking, storage, and reliability lessons.
A detailed retrospective on migrating small VPS and homelab hosts to Ansible-managed infrastructure with practical role and rollout patterns.
A long retrospective on building a reliable Proxmox homelab cluster with practical lessons on storage, backups, networking, and operations.
A detailed retrospective on building a safer CI/CD pipeline with GitHub Actions and a self-hosted runner for infrastructure and web deployments.
A long-form retrospective on building an observability stack with Prometheus, Grafana, and Loki, focused on practical alerting and incident response.
A detailed retrospective on backup and disaster recovery drills across homelab and VPS services, including RPO/RTO design and practical runbooks.
A deep retrospective on tuning PostgreSQL performance with query analysis, index strategy, autovacuum adjustments, and connection management improvements.
A practical retrospective on building a reliable WireGuard site-to-site VPN between home lab and VPS environments with routing, MTU, and operational hardening lessons.
A detailed retrospective on stabilizing Terraform workflows for multi-environment infrastructure with safer state handling, drift detection, and rollout governance.
