The CMMS Saga, The Home CMMS Grows Up
When I last wrote about this back in July, I owned up to a slightly embarrassing truth: I’d abandoned perfectly good software and built my own home CMMS from a blank Python file. It tracked about a hundred assets across six locations, ran on my own network, and looked like a spreadsheet and a website had a fight in a dark alley and neither walked away happy. I signed off promising the next step was planned maintenance — recurring jobs that generate their own work orders when they fall due.
Reader, I did the planned maintenance. And then I kept going. Rather more than I meant to.
The thing has a name now, at least on screen. Gofal — Welsh for “care”, as in taking care of things, which felt about right for a system whose entire job is nagging me about boiler services and drone firmware. Under the bonnet it’s still plain old CMMS. But my partner shouldn’t have to log into something called cmms_ui, so Gofal it is.
The bit I promised
Planned maintenance landed, and it turned out to be the most satisfying part of the whole project. You set up a plan against an asset or a location, give it a “heartbeat” interval, and then layer tiers on top — the every-service job, the annual job, the every-fifth-time job — and the largest one that’s due wins. Each tier gets its own list of steps and its own list of parts. When a plan comes due, Gofal spits out a work order with the steps already written into it. There’s even a “Materials Due” screen that looks ahead at what’s coming, works out which parts each service will use, checks that against what’s actually on the shelf in the workshop, and flags what I need to buy before the job starts. That, right there, is why I wanted a CMMS in the first place, and watching it work for the first time was worth every hour invested.
The bit I did not promise, and probably didn’t need
Here’s where honesty is required. Once planned maintenance worked, I could have stopped, but rather predictably I didn’t.
Gofal now has a full parts inventory with stock levels and low-stock alerts. It has vendors as proper linked records rather than free text I’d inevitably spell three different ways. It has a purchasing module that lets me record what I bought, charge each line to an asset or a job or a location, and only counts the cost once the thing has actually turned up. Work orders grew from a simple status list into something I’m genuinely proud of — a Kanban board you drag cards across, a calendar view, cost tracking, logged labour hours, parts issued straight from stock, and an edit screen laid out around the phases of an actual job rather than the shape of the database tables. There are projects with tasks that depend on each other, so a task stays “blocked” until everything it’s waiting on is done. There’s a little robot that ARP-scans my network twice a day, notices when something new appears, and offers to turn it into an asset — and when a device that should be online goes quiet, it quietly flags the kit as needing attention.
Somewhere in all that, the boring-on-purpose plumbing got serious too. Automated, integrity-checked backups that copy themselves to the NAS and email me if they go stale. A proper migrations system so I can change the database without losing three months of records. CSRF protection and a security audit doc after I lived one too many horror stories in my previous IT career. None of it is glamorous. All of it is the difference between a toy and something we might actually trust to look after the house.
A hundred and fourteen commits, if you’re counting. I try not to.
The AI in the room
I need to address something, because it would be dishonest not to, and because I’ve written on this blog about exactly this.
In July I wrote a piece grumbling about the temptation of the tidy answer — how a search engine shows you the argument and an AI just hands you one confident conclusion, and how much we quietly lose when we stop interrogating it. I stand by every word. So it would be a bit rich of me to pretend I built all of this alone in a shed by candlelight.
I didn’t. A large chunk of Gofal was built alongside an AI, back and forth, evening after evening. There’s a working-notes file in the repo that’s essentially a diary of those conversations.
The thing is, the tidy-answer problem and the pair-programming reality aren’t actually in conflict — they’re the same lesson seen from two sides. The danger with an AI answer is accepting it without thought. Writing software with one is almost the opposite: it becomes a running discussion. It proposes, I examine and question the why and the how; sometimes I suggest something and it points out that this is illogical. It has confidently told me things about the structure of my own database that were simply wrong. I push back, we investigate, and we end up somewhere better than we started.
The great thing about software is that it provides a useful reality check. The code has to work. The server either starts and runs or it throws a stack trace at me. “Right” isn’t a matter of how convincing the explanation sounds. I catch the AI being wrong, sometimes repeatedly, but it also catches me when I’m about to write or have created something clumsy or overcomplicated. That review process is the important bit. The moment I stop questioning it is the moment I’ve become the person my July post was worried about.
And the human still matters. The ideas, the purpose and the decisions about what Gofal should actually do are mine. Not everything that got added was scope creep; much of it was discovering, through building and using the system, what it actually needed to accomplish to become useful for me. The AI helped me explore those ideas and turn them into working software, while I learned a considerable amount along the way.
Is AI as good as some of the brilliant programmers I’ve had the good fortune to work with? Hell no. Not even close. Is it a brilliant tool that has enabled me to build a CMMS in months rather than a year? Absolutely.
So: built with help, understood by me, owned by me. I can still explain every table and the code behind it, because when the AI suggested something daft, I understood what we had built well enough to challenge it.
Which brings me to the awkward part
In July I had a go at SuperCMMS for dangling the promise of releasing their code and never once delivering. Fair criticism, I thought.
Gofal’s code carries a GPL-3.0 licence. The repository is private.
Yes. I’ve noticed. It’s hard not to, having lobbed that particular stone from inside a fairly transparent glasshouse. A GPL licence on a repo nobody can see is a promise made to a locked room.
So consider this the public commitment I clearly need. I want to open it up. There’s tidying to do first — a security dependency to bring up to date, secrets to make sure I’ve kept out of the history, a setup guide good enough that someone who isn’t me can actually run the thing on a fresh machine. But the goal now is a public repository, GPL as promised — one for anyone who considered the home CMMS options, felt the urge to build their own, but wisely resisted vanishing down that particular rabbit hole.
If that’s you, watch this space. And maybe disable your editor’s HTML autoformatter before you start. Trust me on that one. 😉