A running journal of home-lab builds, side projects, and the occasional over-engineered solution to a problem nobody asked me to solve.
I'm James Huschle. This is where I write up the stuff I build for fun — hybrid cloud/home-lab systems, edge AI running on microcontrollers, and whatever else seemed like an interesting way to spend a weekend. None of it pays the bills. All of it is more fun than most things that do.
I spent years in enterprise technology — the kind of work that pays well and rarely comes up in conversation. This site isn't that. It's the stuff I build because I want to, on my own time, usually because I got curious about how something works and couldn't let it go until I'd built it myself.
I came to technology through an unusual door — English and Computer Science, for reasons that made sense at the time. That combination still shows up in how I write about these projects: I'd rather explain why something works than just show that it does.
The projects here span home-lab infrastructure, edge AI, and cloud architecture, with the occasional detour into whatever new tool just came out. I don't optimize for polish. I optimize for learning something I didn't know before I started.
If you want to see how any of it actually works, the write-ups below go deeper than they probably need to.
These projects represent hands-on work from the last few years — built independently, architected from scratch, and deployed to real infrastructure. I'm releasing them publicly over the next month or two as I get each one to a standard I'm comfortable putting my name on. Two are live. One is open source with no hosted demo. One is coming.
Serverless ML-powered learning — built to understand meaning, not match strings.
A web application that turns terminology-heavy subjects into interactive learning experiences. Users define a knowledge domain and its terms; the system evaluates answers semantically — understanding what you meant, not just what you typed — using a custom cross-encoder model quantized for low-latency inference without a PyTorch dependency.
The architecture is a six-stack AWS CDK deployment — network, database, auth, backend, frontend, and monitoring — each independently deployable. Auth runs through a custom Cognito registration gate with pre-signup Lambda approval. CI/CD via GitHub Actions includes security scanning on every push: Bandit, Checkov, TruffleHog, and pip-audit.
If you'd like to explore it, you can register for an account at the link below. Accounts aren't provisioned automatically — registration lands in a review queue and access is granted manually. Why the gate? Two reasons, both honest: bots are a real nuisance, and the free-tier cost model depends on keeping traffic predictable. Automated signups solve neither problem and create new ones. So a human reviews each request. If you're a real person who wants to poke around, you'll hear back.
Paste text. Get an audiobook. The API is serverless in Oracle Cloud Infrastructure (OCI); the GPU is a home-lab box — wired together by a WireGuard tunnel and a webhook.
A hybrid cloud/on-premises audiobook service. The interesting part isn't the conversion — it's the architecture that makes a serverless cloud function and an on-premises GPU cooperate seamlessly across the internet. When a job is submitted, an OCI Function stores it and immediately POSTs a webhook to a worker running in a home-lab Kubernetes (k3s) cluster, delivered over a WireGuard VPN that routes through an OCI ARM instance. The worker claims the job, chunks the text, and runs inference locally using an open-source English Text-to-Speech (TTS) model (Qwen3-TTS-12Hz-1.7B-Base at 1.24% WER on the Seed-TTS benchmark, for those who care about such things). The result lands in OCI Object Storage as a downloadable Opus file.
Push for speed, poll for reliability. The webhook wakes the worker immediately; a 10-second polling loop runs as a fallback in case the webhook is missed. Either path arrives at the same place.
JSON Web Token (JWT) verification happens inside the OCI Function without an outbound network call — Cognito's public keys are embedded directly in the function, which matters when running in a private subnet with no internet gateway. Text preprocessing strips the artifacts PDF extraction leaves behind (citation brackets, DOI strings, footnote markers) before chunking, so the audio sounds like a human read it.
Same account gate as Know-It-All Tutor — and the same account works for both. Registration lands in a review queue and access is granted manually. If you're a real person who wants to try it, register once and you're in on both apps.
A distributed IoT and edge AI system — inference runs where the data is, not in the cloud.
63 milliseconds end-to-end — from motion detected to alert delivered — on local hardware with no cloud service in the loop. The cloud alternative is 500ms to two seconds and roughly $100/month per camera at scale, with your video stream on someone else's infrastructure. Edge AI makes that happen.
The system is three tiers. ESP32-S3 microcontrollers handle the camera layer: custom firmware manages JPEG streaming, MQTT (Message Queuing Telemetry Transport) control over TLS, and over-the-air (OTA) firmware updates. A Jetson Orin Nano handles inference — YOLOv8n person detection at 8ms per frame on CPU, InsightFace face recognition at 15ms per frame on GPU. A workstation runs the command module: FastAPI, LangGraph state-machine orchestration, and PostgreSQL with pgvector for face embeddings.
The IoT engineering is where the depth is. Cameras self-register on boot — no manual provisioning. Commands carry nonces with an 8-minute replay window, so the cameras can't be spoofed by a replayed packet. Over-the-air updates use versioned firmware channels per board type; cameras poll on boot and every five minutes, checksum-verify before applying. The same patterns you'd build in an industrial deployment, on $200 of hardware.
One interesting engineering lesson actually came in the form of a failure. The original design ran TFLite inference on each ESP32-S3 as a detection gate — true AI at the bleeding edge in the microcontroller layer, only transmitting frames when something was moving. That didn't survive contact with the hardware and only delivered 0.6 fps — too slow for a gate. The solution was to move that inference to the Jetson. The lesson: edge AI isn't about pushing inference as close to the sensor as possible. It's about matching the compute requirement to the hardware that can actually deliver it. Microcontrollers handle networking and streaming. The Jetson handles computer vision. That's the right split.
There's no live demo — the production system runs on my home network with my family's biometric data. That's the point. The code is the portfolio piece.
A local-first knowledge pipeline with anonymous search, LLM-assisted triage, and human review — wired via Model Context Protocol.
Source available on GitHub at release.
These are the problem spaces I keep coming back to — the ones where a project stops being about finishing it and starts being about seeing how far I can take it.
The opportunity isn't chatbots. It's systems that act — that reason across tools, data sources, and workflows in ways that actually change how work gets done. What draws me to this space is the genuine novelty of it: for the first time, the distance between "what a system can do" and "what a business needs" is being closed by language, not by more code. The problems here are mostly still unsolved, which is exactly why I keep building.
Large language models are the first technology in a long time that rewards curiosity as much as engineering skill. That combination is why I can't leave this space alone.
Serverless and distributed systems design appeal to me partly for the technical elegance, but mostly for what they force: you have to think clearly about boundaries, ownership, and failure modes before you write a line. Most of what's on this site runs on AWS or OCI for exactly that reason — the only way to have real opinions about infrastructure is to run it yourself.
There's a specific kind of satisfaction in getting a WireGuard tunnel, a Kubernetes cluster, and a $200 microcontroller to cooperate reliably. Most of the interesting engineering happens at the boundary — where cloud infrastructure has to hand off to hardware sitting on a shelf in my house, and everything still has to work when nobody's watching it.
Not selling anything, not looking for a role — just enjoy talking about this stuff with anyone who's into the same weird corners of engineering.