Skip to content
← Back to writing

August 17, 2025

The first container that actually worked

Two weeks after getting fired, I deployed a real Docker container from software I wrote. it-tools, port 8082. That was the moment.

The problem nobody tells you about

The real server/cli-bridge.js at commit 8df1659 (Aug 17, 2025, the day this post describes): the spawn('docker-compose', ...) call that replaced Dockerode.

When you start building software for the first time, there's a gap between "it runs on my machine" and "it does something real." I'd been living in that gap for three days. The Node.js backend could list Docker containers and the frontend could display them, but the thing couldn't actually deploy anything. It was a dashboard for looking at stuff, when what I wanted was a tool for doing it.

The blocker was Windows. HomelabARR was being developed on my Windows desktop (AMD Ryzen 9 3900X, 64GB RAM, the whole setup), and the standard Docker library for Node.js, Dockerode, couldn't talk to Docker Desktop through Windows named pipes. Every attempt to connect through the Docker socket failed silently or threw cryptic errors about docker-modem.

The ugly solution that worked

I stopped trying to be clever. Instead of using the Docker SDK like a proper developer, I reached for child_process.spawn() and called the Docker CLI directly. Build the argument array, spawn the process, parse the output. It was the programming equivalent of opening a jar with a wrench, technically wrong but it got the lid off.

The deployment function was maybe forty lines of JavaScript. It took a container config, mapped it to Docker CLI arguments (docker run -d --name it-tools --network proxy -p 8082:80), and spawned the process. No SDK, no library, just the binary that was already on the machine.

I know what real developers think about this. Spawning processes from a web server is a security problem, parsing CLI output is fragile, and there are a dozen other reasons not to do it this way. But I wasn't a real developer. I was a project manager who'd been fired two weeks ago, and I needed something that worked before I could afford to care whether it was elegant.

The moment

I clicked "Deploy" in my UI. The spinner appeared, the logs showed the Docker pull happening, and then the container showed up in my dashboard: running, healthy, port 8082 mapped correctly.

I opened http://localhost:8082 in Chrome and it-tools loaded, a real application deployed by software I wrote.

It sounds trivial. Every junior developer has deployed a Docker container. But I hadn't deployed a Docker container. I'd built a tool that could deploy Docker containers, and that is a different thing. The container wasn't the product; the tool that deployed it was.

Three days earlier my Node.js app could only read data, and now it could reach out and change something in the world.

What it proved

That MVP proved three things at once. First, a PM who'd never written production code could build working software with AI assistance. I was using Claude, prompting it with specs written in the language I knew (user stories, acceptance criteria, technical requirements), and it was writing the code. My PM skills weren't useless in this new world, they were the interface.

Second, the spawn approach actually solved the cross-platform problem. Windows named pipes were a dead end, but every machine with Docker installed has the docker CLI on the path. By going through the CLI instead of the socket, I accidentally made the thing work everywhere. That same shape, a server-side bridge that shells out to the Docker CLI, is still how HomelabARR deploys containers today.

Third, the HomelabARR community project, the thing I'd helped rebuild after PGBlitz imploded, could become real software. Not shell scripts stitched together with hope. Actual software with a frontend, a backend, and deployment capabilities.

The ugly parts

The MVP had 65 YAML files with syntax errors. The authentication system was barely functional, and I had to wire in a bypass just to test deployments. The container naming was inconsistent. The error handling was "log it and pray." It showed 252 applications in the UI but could only actually deploy a handful of them.

None of that mattered yet. In two weeks I'd gone from "I don't know how to code" to "I wrote a thing that deploys Docker containers." The YAML errors, the auth, the inconsistent naming, all of it could be fixed later. The one thing I needed proved, that I could build software that does things, was done.

I documented everything in Confluence that night. Jira ticket HL-76. Every decision, every workaround, every hack. Not because I thought anyone would read it, but because my PM habits insisted on it.

homelabarr.com