There’s an interesting hole in the task management and productivity literature. The situation is when you know more or less what needs to be done, but not exactly how to do it, and from where you’re starting, it’s not clear in what order and how long each particular task will be.

And the whole thing needs to be billed.

You have two choices. The first is do what everyone else does and just get ‘er done. The second is to write down everything you do – as you go – and sort it out later.

If you know you’re going to be doing the task in the future, or that you’re going to outsource it or pass it downstream, method two will pay you back.

Edgewall’s Trac is a pretty good tool for untangling a messy project. For example, I’m prepping the Blog Maintenance Challenge for pre-launch, and I have an extensive number of small tasks to accomplish. The normal thing to do is write out a task list up front, then check everything off. In this case, I’m not sure exactly what needs to be done at a task-based level.

Task-based productivity is the notion that at the scale where things actually get done, productivity is linear. The vast majority of people can do only thing at a time, and a task is one of those “things” that get done. Typically, a task should be something taking between 15 minutes to perhaps an hour and a half. If it takes longer than 90 minutes, consider breaking it into two tasks.

As it turns out, implementing what’s described in this blog post is almost multi-tasking.

It is doing two separate tasks in the same billing period, but these tasks are closely related by context.

Given you treat your task lists as intellectual property assets, when you’re faced with a messy set of “things to do,” creating a set of tasks will pay you back the second time you do them.

Untangling

It’s pretty simple:

1. Open your task management system and create a ticket or issue or whatever you call it. In Trac, it’s a new “issue.”
2. Fill out the ticket as best you can, including as many steps as possible.
3. Now start the task. At each step, update your ticket (or issue, etc.)
4. When you’re done, mark down the time it should take to complete the task. This may not be the same as billable time, but that’s a different blog post.
5. Test, if applicable.

Now you have a linear, stepwise procedure for duplicating this activity in the future. You could even make a checklist out of it. Once you have the whole project written out in steps, you’re in a better position to bid for future work. You know, add up all the time for the steps, add in the overhead, multiply by hourly rate, $profit$!

For what it’s worth, this blog post was written while untangling a set of tasks for the Blog Maintenance Challenge. Namely, developing a fast procedure for getting into and out of Paypal for increasing prices (the Challenge starts off at low price, increase price as material is added).

If you found this useful, check these out:

Are you logging your work? If not, why not? If so, what’s the biggest benefit you have found?

Hanging out on Twitter this morning, @jesseblayne made a remark about getting started. I replied with a more or less a blog post’s worth of info packed into 140 characters. This is that blog post.

First, some benefits:

1. Writing makes you think, thinking helps you learn.
2. Having a list of tasks you know took one hour is incredibly valuable, you know what your time is worth.
3. Saves time over the long term. You do your thinking ahead of time allowing yourself to rapidly complete tasks.

I have a system that works really well for me, and could work really well for you. It requires a bit of work, but it’s not hard. And it requires a timer. The work is broken down into hour chunks, and this is non-negotiable. The whole system depends on being able to walk away from a task in an hour.

The system is multi-staged. There is a natural progression from forming an idea to executing it.

Let’s get started.

When I have an idea for something, or I need to get things done, here’s the typical sequence:

1. I write, draw or jot down lists on scrap paper. I have a bunch of B5 paper left over from a previous project, or I’ll fold letter size paper in half, 5 1/2 by 8 1/2. Folding A4 in half is B5 is I recall correctly.
2. These notes are then (or later) entered into a web application task list. I use the Trac system, same as WordPress (just coincidence, Trac is a good system.)
3. The Trac tasks are triaged and refactored into ~1 hr chunks. For example, I’m working on a new chapter for Blog Post Engineering (Repurposing). This was initially entered into Trac as a single task, but that’s too long. I need to spend about 10 minutes and break out all the section of that chapter as separate tasks of about 45 minutes.
4. Execute! Once the tasks are chunked down into small pieces, it’s easy to select something interesting to work on.

Write it down

There is something magical about writing things down. It makes us think at the same time as taking action. Synergy. There’s probably weird neurological changes happening, neurons firing, synapses connecting. Or whatever.

All I know is that when I write it down, I learn it better.

I suspect most bloggers are the same (or they wouldn’t be bloggers).

I use the Trac system.

You can use anything you want. Basecamp is great system if you’re collaborating; I’m using it for a couple of projects.

The key thing is that following up your writing with a little data entry further locks the task into your mind. It makes you think about what you’re doing. In other words, the data entry itself isn’t all that important, it’s the thinking that’s most important, and entering the task into your todo list (or whatever) makes you think.

Triage and refactor into 1 hour chunks

This is what an hour’s work looks like to me:

3. Do the work. This should take between 30 to 45 minutes.
4. Document the work, triage and refactor as necessary. Documentation is best accomplished as you work. It makes it a lot easier to keep track of what got done, and you capture really important details along the way.
5. Task out the next hour. Once your finished with the actual work, you should have 2 or 3 little tasks that get you started into the next hour of work. Write these at the end of your hour summary for review the start of the next hour.

Execute!

I cannot explain in words how phenomenally productive this system has been for me. Once the tasking is down at the hour level, I don’t have to think. I know I can pretty much tackle any task and an hour later, I’m done with it. Or if not done, I’ve made enough progress to feel really good about it.

I suspect it’s not really the exact system that matters. The important part is I’ve found a system that fits how I work, my attention span, allows me to balance the fun stuff (graphics and coding) with maintenance and testing.

Sometimes, a task goes into the system that turns out to be a minor career.

For example, about a week ago, I needed to run rake db:migrate to synch up my data model with the MySQL database for a little Ruby on Rails project.

4 hours later, this has turned into figuring out which of 4 possible combinations of MySQL are installed on the Macbook. Not fun. This task still isn’t factored properly. When it is, there will be a blog post somewhere on how to figure out which of 4 MySQL installations one needs for which purpose.

Ultra-Fast Startup Technology: Bootstrap with free or cheap web applications

So you wanna “do a startup?”

Ok, no problem.

I’ve done a couple myself, and it’s fun. Addictive, even.

Now is a great time, too. Turns out bootstrapping your software startup is dirt cheap compared to what it used to cost 10 years ago. The web has really changed everything: you can handle a vast amount of your business infrastructure on line now.

Any business is going to need some infrastructure, and software startups will need a variety of specialized tools for software development. There’s three main strategies for bootstrapping:

1. Totally free and open source software development to leverage totally free environments such as Sourceforge.
2. Self-hosting your entire project, either with an internal server or purchased server space elsewhere.
3. Mixture of self-hosted and inexpensively purchased services.

If you want a totally free software solution, in the last few years Sourceforge has radically improved it’s offerings. However, freely available Sourceforge accounts require your source code to comply with an Open Source license. If you have need to keep your source code private, you will need to find a different solution.

Host everything yourself

Another option is self-hosting everything you need, ranging from Sugar CRM, Google Documents, through dotproject, wikimedia, a WordPress, Drupal or Joomla driven website, and much, much more.

The primary disadvantage of going completely self-hosting is that someone will have be take charge as a systems administrator. And that’s not a job too many developers or startup founders are going to willingly assume. It’s thankless and tedious. Nobody cares as along as everything “just works,” but people become irate when it doesn’t!

Split the difference: self-host and outsource

In my opinion, based on experience, the best option for a small startup is a mixture of freely available, self-hosted, and free or inexpensive web applications.

1. wush.net: $15/month, the best money you will ever spend. You get a subversion repository with integrated Trac, 2G of disk space, unlimited users and excellent customer service. It’s a very good deal. Wush.net doesn’t have an affiliate program, but I like their service so well I won’t promote anyone else. 2. 37 Signals Basecamp: I’ve used Basecamp for a couple of years. Projects always seem to go smoother with Basecamp than without it. If you are purely developers, you may find Basecamp redundant with Trac capabilities, but the moment you add someone not comfortable with hard coding Trac wiki syntax, your team will be more productive moving all non-coding task management to Basecamp projects. (I know this from experience.) Best of all, you can start with a free account, and if you like it, an account upgrade to a small startup level (15 people) are very reasonably priced at$24 per month.
3. WordPress: Host this yourself, use it to build out your company web site. Even if all you want is a static web site, WordPress gets you a lot of bang for your buck. Easy installation, easy maintenance, easy to add material, all your SEO is magically handled because WordPress is so well structured. Check out Website In A Weekend for more information.
4. Google Documents: free, easy, with just enough power to get a startup well underway. Google Docs is my “goto” solution when I need to collaborate on documentation. It’s much easier to collaborate using Google Docs than with MS Word; merges are easier being handled real time, and you don’t have to worry about passing documents around, and who has the latest or most correct version.

Scaling up

All of the tools I recommend scale well. What’s of more importance is that you plan to for scaling with your business practices. No matter what, if you want to scale, process matters.

And the bigger you get, the more it matters.

Creating task lists to accomplish project requirements should be a given. But there’s more that you can do to get a grip on your processes. For example:

1. Make a practice to keep a log of what got done and when. Checking off tasks is only half of the battle. There’s always crises that pop up unexpectedly. Keep a daily a log that keeps track of these as well.
2. Consider tracking your time very tightly. Use a web application such as Clicktime which will let you connect your task list to the appropriate Quickbooks accounts. Once a month, go back over your time sheets and do a little post-mortem analysis. Did your forecasts pan out? Or did you seriously under- or over-estimate how long tasks would require for completion? Use this information to calibrate forward for the following month’s tasking.

These techniques are probably overkill for very small startups… but get in the habit now, you won’t have to worry about it when you’re under the gun later.

Using Edgewall’s Trac Effectively — Customization is the key

Edgewall’s Trac is an amazingly powerful platform for project management. Don’t be put off by it’s old school user interface, Trac development has concentrated on functionality over dressed-up presentation. Trac’s default set up is oriented towards small to medium sized software development, implicitly consisting of a single “project” or “application.” This is not a difficult limitation to overcome. The administration interface allows defining custom fields, which provide greater flexibility in project and task management.

The main built-in fields for handling projects are Milestones and Components. You’re free to define these however you desire. I’ve found the following definitions to work quite well: