Why I Keep a Daily Log of What Went Wrong
I don't keep a file of what my business does well. I keep a file of every place it rubbed, and that's the file I open first each morning. Wins tell me what to protect, and friction tells me what to build next. #CompanyOfOne #OperatingModel #OperatorToBuilder
From Operator to Builder: The Friction Log That Runs My Operating System
My move from operator to builder didn't happen the day I wrote my first automation. It happened the day I stopped tracking wins and started tracking friction. The switch sounds small, but it changed which file I trust most.
The File I Open First
Every morning I open one file before I look at anything else. It's a plain text log of every place my business rubbed in the last few days, and it sits ahead of the revenue chart and the task board.
Last month a friend asked to see my dashboard. I turned my screen and showed him a text file with sixty-odd lines, and none of them was an achievement. He looked genuinely confused, because he'd expected numbers going up and I was showing him a list of things that scraped. That file is the closest thing I have to a real map of the business.
Why Wins Are a Trap
For most of my operating years I measured output: deals closed, tasks shipped, systems moved to live. It felt like progress because the numbers grew. The trouble was that those numbers were honest about the past and said nothing about what would go wrong next.
Wins are comfortable for a reason. They confirm a decision I've already made and ask nothing more of me, so I read them, feel a small warmth and move on. A logged friction does the opposite, because it sits there with a hook in it. In effect it says that the same thing will happen again unless something in the structure changes, and I can't read that and feel finished. That discomfort is why the file is worth keeping.
What Counts as Friction
I keep the definition narrow so the file stays useful. Friction is any moment where the system needed me, or needed luck, to get through a step it should have handled on its own. Some real entries from my own log, in the plain words I write them in:
- A handoff between two subsystems that needed a manual nudge to move.
- An agent that returned a confident answer after reading only half of its input.
- Two parts of my personal operating system reaching for the same resource, with neither aware of the other.
- A weekly report that shipped on time and told me nothing I could act on.
None of these was a disaster, and that's deliberate. I log the near-misses and leave the fires to take care of themselves, because by the time something is on fire, the friction behind it has usually been visible for weeks.
How I Actually Keep It
The mechanics are deliberately dull. It's one plain text file with no tags, no categories, no scoring and no tool to maintain. Each rub gets one line, written the same day, with the date in front of it, and that's the entire method.
I chose the dullness on purpose. The first version I built had columns, a severity score and a neat little status field, and I stopped opening it inside a week, because it had become one more system that needed feeding. A log that has to be maintained gets abandoned, while a log that costs ten seconds a line survives.
I don't try to solve anything at the moment I write the line, because capturing and fixing are two separate jobs. If I try to fix a problem while I'm capturing it, I write down far less, since fixing is slow and I'm usually in the middle of another task. So my rule is to see the rub, name it in one line and keep moving. The fixing happens later, when I read the file back with a clear head.
One Entry, Start to Finish
An abstract description doesn't land, so I'll walk one real entry all the way through.
The same line showed up in my log three weeks running: a lead had been marked qualified without anyone reading the brief attached to it. My first instinct was the operator instinct, which was to open the case, read the brief myself and correct the record before the end of the day.
The friction log stopped me, because the same line was already in it twice, and that repetition is the signal. This was a pattern rather than a one-off slip. One part of my system was making the call on incomplete information every time, because it only ever read the body of a message and the brief always arrived as an attachment.
The operator fix is to catch the mistake each time it happens. The builder fix is to change the structure so the call can't be made until the brief is actually in view. I made that change once, and the line hasn't come back since. Without the log I'd have fixed the same thing by hand every week and called it diligence.
The Central Rule
If I lost everything else in this piece, this is the rule I'd keep. Wins tell me what to protect, and friction tells me what to build next. Of the two, only the friction points somewhere I haven't been yet.
A highlight reel works like a museum, because it preserves what already happened. A friction log works more like a building site: each line points at the next thing that needs a proper structure, so the business stops depending on someone heroic to catch it.
The Complaint Log Trap
There's a wrong version of this habit, and it's worth naming so nobody drifts into it. A friction log records structures, while a complaint log records feelings, like a difficult client, a heavy week or someone who dropped a ball.
The test is whether the line points at a structure I can change. "The vendor was slow again" is a complaint. "New vendor payments have no owner, so they wait until I chase them" is a friction entry, because it names the missing structure. The first line makes me feel better for a second, and the second tells me what to build.
A log that fills up with feelings drains the person keeping it, and a log of structures gives that person direction. So every line has to point at something I can actually fix.
What Changed When I Started Logging
The first change was speed. Problems I used to rediscover every quarter now get caught in the week they first rub. The second change was quieter and mattered more: I stopped blaming people, myself included, and started reading friction as a signal about structure.
When the same handoff shows up in the log three times, I treat it as a missing connection between two parts of the system rather than a discipline problem. The log turns a vague sense that something is off into one specific line that keeps repeating, which I can point at and fix. From the inside, this is what moving from operator to builder actually feels like, because an operator fixes the single instance while a builder reads the pattern in the log and changes the structure so the instance stops appearing.
The Part Nobody Likes
I'll be honest about why most people don't keep a file like this. It's unflattering, and opening a list of everything that scraped, first thing every morning, isn't how anyone wants to start the day. I'm not fully at peace with it myself, and there are mornings I'd rather look at the wins.
But the wins have never once told me what to do next, and the friction log tells me every time. For anyone who builds in public, as I try to, it's also the most honest record available. It separates saying the system works from knowing exactly where it doesn't.
Principle and Punchline
The principle is simple enough to keep in my head: track what rubs, and read each rub as a gap in the design rather than as a failure. The org chart shows who reports to whom, and the friction log shows where the business actually hurts.
What's the one friction in your operation this week that you noticed, shrugged at, and didn't write down anywhere?