I’ve been listening to Lean Thinking during my cardio workouts lately. It’s about identifying the flow of value in your system and eliminating wasted time and effort. There’s a lot of overlap with the Theory of Constraints concepts, but it reaches the conclusions from a different angle, following the trail left by Taiichi Ono and other smart people at Toyota since the 1960’s.
Anyway, last night I found myself struggling with a dilemma concerning a support request. I currently have a 30 second timeout rule in place for scripts on my servers, and it was killing somebody’s backup script. On the one hand, it would be quick and painless to whitelist that one script, but that doesn’t really solve the problem in the general case, and other people are sure to have the same issue. On the other hand, if I decide to fix it the right way, I’ve either got to do that project right now or I add it to the project list, which was beginning to feel like a black hole into which ideas vanished without a trace.
So I decided to apply some lean thinking to the problem and identify the value stream. Well, I realized I was actually dealing with the intersection of three different streams:
- the flow of information about his script through the monitoring system
- the flow of this particular issue through the support system for this one customer
- the flow of the “permanent fix” through the project queue
Each of these streams (support, system administration/monitoring, and development) produces value for my customers in a different way, delivering the three things I advertise in the speech bubbles in the comic at cornerhost.com:
- fast, reliable apache web hosting
- friendly help from actual human beings
- an ongoing commitment to making it even better
Every time an issue like this came up, I seemed to be pulled in three different directions: solve the problem immediately for the customer, fix the system, or defer the whole thing because there’s so many other things I need to be doing.
This conflict invariably leads me to the quest for a new project tracking system. I don’t know how many issue trackers I’ve tried to adopt or implement over the past few years. Nothing ever did what I want. This past November, I spent pretty much the entire month grappling with this problem and attempting to implement a system from scratch, but I failed.
So last night, after whipping up a “simple” project database in OpenOffice and then hitting the same brick walls yet again, I decided to apply some lean thinking to the project queue and map out the value stream. Generally it either looks like this:
- identify- a customer makes request or I spontaneously have an idea
- implement- I just do it
- announce - I tell everyone about it on a blog or the mailing list
Or this:
- identify
- wait - I add it to the project list
- (the end)
In other words: most of the time I either did things as they came up or I didn’t do them until the next time they came up, hence the black hole symptom.
When I first read Getting Things Done, I “got religion”, but saw it as a software problem. I had so many projects that keeping the project list and next action list up to date was just an overwhelming task. It was too much for paper (and I tried). It was too much for a database or text file. I was certain that I needed a perfect tool to help me filter and sort the list. I needed to go through and add time estimates and priorties and then code all this special logic for the relationship between tasks when I broke a project down. Basically I felt I needed a huge investment in software.
The thing about Lean Thinking and the Theory of Constraints is that you don’t need a huge investment to make them happen. You just learn to think in a different way and you suddenly find ways to get a whole lot more throughput from older, smaller, and less efficient systems. The Lean Thinking authors go so far as to say that if you think you need to invest a whole lot of capital to make a lean transformation, then you simply don’t get it yet.
Well, I didn’t get it.
So once I had that value stream mapped out, I realized that the real problem was that nothing about the project list was triggering me to act. I did keep up with the the top few urgent things on the list, but mostly I work from my daily to-do list and use the project list as a storage for the future. But my daily list isn’t based on the tasklist, it’s based on whatever’s urgent, which means a lot of valuable ideas just get buried on the list because they’re not urgent. And when I finally did get caught up and work on something that’s important but not urgent, I’d look at the project list and either run away in fear or decide, once again, to find the perfect system to manage all these projects. Prioritizing the list seemed so daunting that nothing about it ever really motivated me to do any of the projects.
So last night I stopped myself and decided to search for a simple solution. I tried to really explore why I felt I needed something more than a simple outline.
Well, it turns out that one of the main issues is the idea of a split between projects and actions. In Getting Things Done, these are two separate lists. You can’t “do” a project, you can only do the next action for the project, but I always had a tremendous amount of trouble separating the lists. As soon as you do this you have to start making sure that each project has a next action on the list, and then there’s prioritizing the two lists, and (to me) it’s just really hard to get a big picture of what needs to be done once you separate the lists. But the only reason I was separating the lists was because David Allen said to, and I drank the Kool Aid. So I merged the lists. I gave the projects short names so I could still have room on the line for the next action. Then detail information about the project or action goes in the body of the outline.
Then came the whole sorting and priority bit. This seemed really important to me, because I wanted three different views of the data. Depending on my mood and the time available, I either wanted to see what was urgent, what was important, or what was quick and easy. I felt the way to handle that was to assign a set of numerical values to each task or project, and have the database sort them. This lead to all sorts of user interface nightmares because I kept envisioning this cross between a tree and a grid, similar to the interface Microsoft Project provides. I spent a good chunk of November attempting to implement this complicated GUI interface idea in python. Now that was a cool project, and I’d like to finish it, but it isn’t a prerequisite for getting my project list in order.
When I made the decision to find a simple solution, I wound up just breaking the top level outline into several sections:
- urgent
- easy
- pending - tasks/projects I can’t do yet because they’re waiting on something else
- general - all other projects / actions
- inbox - new ideas for which I haven’t yet identified a clear next action
Within each section, I put the most important ones at the top.
And that’s it. It’s an emacs outline file, which is just a normal text file with some astersisks to mark the headlines.
Finally, I made separate files for each project-generating role or area:
- cornerhost
- versionhost
- cashflow
- workshop
- personal
- etc…
This means I can plan my week in terms of roles (a la 7 habits), and those roles are driven by next action lists, which will trigger or pull me to act, so there’s a constant flow of value whenever that role is active: I just go to the appropriate list, and work on one thing at a time, one after another until my time for that role is up.
In retrospect, it all seems rather obvious, but I guess sometimes finding the simplest thing takes a lot of hard work.