It's exciting to start working on a new project. Everyone on the team is tempted to just dive in and start coding, designing, and creating. But as a project manager, it's your solemn duty to make a game plan first.
Planning can be tedious and unglamorous - but if you skip it, you'll end up wasting a lot of time on trial and error instead of devising a strategy and working smart. Even if a plan proves useless, the act of planning is indispensable because it clarifies the goal and sets a starting point.
Give me six hours to chop down a tree and I will spend the first four sharpening the axe.” ― Abraham Lincoln
Where to Begin Organizing 1,000 Tasks?
Before you start planning to-dos, time, and people, you need a consistent way to organize your work. Projects have a lot of tasks and you have several options by which you can group them:
Progress: Backlog, Next, In-Progress, Review, Done
Type of Work: Design, Marketing, Development, QA
Time: Today, This Week, Next Week, May 2016, To Be Determined
Product: Website, Mobile App, Desktop App, Blog
Feature: Homepage, Contact Us, Header, Footer, Shopping Cart
Priority: Low, Routine, Normal, Priority, Critical, DEFCON 1
Complexity: Quick Fix, Minor Improvement, Big Feature, Security, Tech Debt
Hybrid: a mix of the above
The way you group tasks depends on the project. For continuous projects that have no beginning and no end (like developing your own product), it's best to organize tasks by progress and projects by product. Small-scale projects (like website development) can be grouped by feature, while bigger projects (like a complete rebranding) are commonly grouped by type of work.
There are two approaches on how granular you want to go when grouping tasks: you can use simple segmentation and complex segmentation.
When in doubt, go with the most flexible approach and see how it works. Over time, you'll know which tasks are the most frequent and you’ll know when to use which principle. For example, if you complete tasks as soon as you start working on them (there are no complicated processes, just simple to-dos), grouping them by progress is useless; what you then need is to group by time or priority.
If your workflow is good, but you occasionally come across a task that demands its own category, just add a column where you’ll put all the odd jobs. You can also use the hybrid approach: if you categorize by complexity, feel free to add the In-Progress column. But don't overdo it. It can be confusing if you use more than one principle: for instance, does a new bug go into Backlog, Hot Fix, Development, or Feature A?
The problem of segmenting tasks more granularity is addressed by using swimming lanes, but they bring more confusion than clarity because they make the flow non-sequential. For example, you need to segment both design and development phases into Planning, In-Progress, and Review. But with swimlanes, it's hard to track work items and a developer doesn’t know what tasks he can pull next.
A better solution is to break a task list into several task lists so the flow is straight and manageable.
When deciding on how you want to organize tasks, keep in mind all the tools you have at your disposal and how you can retrieve information.
ActiveCollab offers a solution for this - a task has several information fields by which you can filter them. It practically means you don't have to organize task lists by time or assignee because you can always get those dimensions automatically.
If you need more to segment tasks using more dimensions (eg. want to mark task as a bug that’s in-progress with a high complexity), use labels in addition to task lists. Labels are like tags and can be anything you want; one task can contain multiple labels. You can communicate a task’s complexity, type of work, priority, or anything else by using them. This way, task lists don't have to do so much work.
For example, if you organize task lists by feature, you can use labels to indicate progress. When you start working on a task, just switch the label to In-Progress; when you’re done, switch the label to Review.
Recap: use task lists to group tasks by one principle (usually stage of progress or type of work), and add labels if you need more information. You can always filter tasks by assignee and date automatically when needed.
If you're interested what workflows designers, freelancers, and software developers use, check out our Kanban ebook. It delves deeper into the subject.
What to do with completed tasks?
When deciding on columns, keep in mind that ActiveCollab automatically gives you a Done column for each project, only it's not in the form of a column.
Every time you complete a task, it disappears from the main view. But, you can always access it by looking at your completed tasks. So in a way, it doesn't matter if the task is in the Done column or hidden somewhere out of sight - you still have a place where it ends its life.
Tasks are on a separate screen because if a task is completed, you don't need to see it every time you open a project.
But if you have the kind of workflow where you want to see completed tasks (eg. a client wants to see what's done), then don't complete them.
Instead, create a Done task list and move the tasks there. Or, if you want to keep a task in its task list, put a checkmark (✓) at the start of the task’s title to indicate it's completed. This way, you can organize tasks by type of work (as opposed to the stage of progress), and keep them in the view but visually separated from the rest.
Keeping completed tasks on display is a great motivator for your team. It's easy to forget how much you've accomplished and get lost in day-to-day activities. Keeping finished tasks in sight may clutter the view, but it's great visual reminder of the progress you've made. It also helps you reassure your clients and make them appreciate of all the work you've done.
Work Breakdown: Planning the "What"
How do you eat an elephant? By breaking the act into several discrete pieces which you can accomplish one at a time. Same way with projects.
You first break work into several discrete units, then you break those units further, and so on until your tasks become doable (but not so small that you end up accomplishing 50 of them a day).
For example, you start breaking down "Web redesign" into several big tasks and those into smaller tasks and so on.
This doesn't have to be an exhaustive list of all work - it should be a comprehensive list on which you can start working right away and update as you go. At this point, it’s enough just to specify what needs to be done - you’ll think about how and when after that.
Project Timeline: Planning the "When"
Some projects have fixed end deadline, some have deadlines for milestones, some have soft deadlines, and some don’t have deadlines at all.
When you orient your project by an end deadline, the best way to plan the timeline is to start planning tasks start and end dates by going backwards. This is a deadline-driven planning and it’s most often used in event planning where you have a date for an event that can’t be moved so you plan everything around it.
On the other hand, if you’re not constrained by a deadline and need to focus on quality of work, use quality-driven planning. Software companies who continuously work on a product use this approach because it’s more important to get the feature right than to meet an arbitrarily set deadline and ship.
When estimating, you can first approximate start and end date for task lists. For instance, estimate how long Design should last and, based on that, you know how much time you have for individual tasks within the list. Be careful, though: this estimate can delay your whole project if you’re too optimistic with estimates.
To lessen your unwarranted optimism, add an estimate for each task BEFORE you start working with dates. If a task is estimated for 6 hours and you see the assignee has other tasks that same week, you'll be less tempted to set the duration of one day.
Incorrect estimates make project planning more difficult, but they are harmless when compared to the biggest enemy here - an indecisive client. Clients often don't know the exact features they need in the early project phase, but usually find out during the project. This can derail your whole plan. But it’s not a bad thing. It'll mess up your perfect plan, yes - but it also means your project scope just got bigger, which means more money and a chance to revise the project scope agreement.
That's why you need to include triage periods in the plan. In every project, you're going to have periods of rough patches and smooth patches. Usually, the rough patches correspond to important milestones when the team has to decide how to move forward with new information in hand. These periods require extra time for communication, reflection, and getting on the same page. At times like that, a team might get a feeling that a project isn't going great. It’s normal. You just need to anticipate those moments and add buffer zones in your timeline for them.
Add one triage padding after the research, because after research, the team knows what they have to work with so they can plan better. Add another triage padding once the design moves from sketch to mockup, because once the design becomes "real", clients and others on the team experience all kinds of reactions, and they can change the direction of the project.
Don't forget to account for time lag when you plan a task's end date.
A 7-hour task can actually take up 6 work days to complete (or 2 weeks) - operating under an assumption that the client does their job on time. The point is, a task might need 7 hours of actual work, but that work can be distributed over several days due to time lag.
It’s important to communicate the project plan to your team and the client. Make the project plan easy for others to see and access so they can better understand how they fit in the grand scheme of things. This doesn’t mean you need heavy documentation - just the opposite. Present the timeline to your team, ask what they think, and improve
The Gantt-like timeline on each project in ActiveCollab is great for this.
You have to monitor how a project interacts with your other projects. If your projects share resources (like time and people), they can overlap so your team members end up with too much on their plate, which will disrupt the whole project plan.
To see who works on what and when, run a Project Timeline report in ActiveCollab before you start planning a new project. It'll give you an overview of all your projects and their tasks so you can see which dates are the busiest and should be avoided. You can even plan and tweak projects directly in the report.
Task Assignment: Planning the "Who"
Each team member needs to know what to work on. They expect from a project manager to assign them tasks for each day and keep them busy. This is a project manager's job because they have the complete overview of the project (not to mention the responsibility for time and budget).
Most tasks aren't discrete work units that require a team of one. Most of project work is collaborative, and there are several types of collaboration.
Some people work on the task, some need to offer their advice, and others merely have to be informed of the progress because it impacts their own work. The best approach to this is to use Responsibility Assignment Matrix (RACI).
RACI matrix defines four roles a person can have on a task:
- Responsible - owns the task, works on it, and their duty is to see it gets completed
- Accountable - must approve the work and sign-off before it can be completed
- Consulted - has the necessary information without which a task can't be completed
- Informed - needs to know the final outcome, but doesn't need to be consulted
So for example, a project manager holds a designer responsible for finishing a wireframe. A client is accountable because they must approve work before a designer can complete the task. Marketing should be consulted because they know what the main call to action should be and what content they have; the information architect needs to be consulted too because he created the sitemap. A front-end developer only needs to be informed of the final result so they can start coding the layout.
RACI matrix used to be done in a spreadsheet, next to the work breakdown structure, but ActiveCollab is better suited because of its interactive nature:
If your team works on multiple projects simultaneously, you'll have to make sure their responsibilities on other projects don't overlap. That's where the Team Timeline report comes in handy.
Team Timeline report lets you see a timeline all the responsibilities a team member has across all their projects.
With it, you can see what a person has to work on each day so you can better plan their time. For example, while planning a project, you can quickly see all the tasks someone has on other projects. You can then tweak tasks (on the existing project or the new one) and rearrange them so they don’t get overbooked.
With the Team Timeline, you can create more realistic project plans because you'll know how busy each team member is. You can even determine when to start a new project based on this information (or if you have the resources to start it at all).
If a team member finishes all their assignments and has leeway, it’s a good idea to always have tasks in a backlog for just the occasion: a task list from which a person can pull work once they finish all their assignments. In software development, there’s always a curated backlog full of bugs (arranged by priority), so when a developer finishes working on a feature, they can work on bugs while waiting for the review.
Once you've planned one dev project, you've planned them all. Save time by using an existing plan as a basis for future projects. You do this by creating a project template, filling it with common tasks (and all their details), files, team members, discussions, and notes.
So when you get a contract for a new project, you just create a new project from the template, update it with specific details, and you're ready to go.
Recurring tasks are another time-saver. They are common tasks that you create often, like every day, week, or month. They're perfect for services you provide each week/month. You define them once, set how often they should be created, and don't worry about creating them manually later.
For example, if you want your assistant to send direct mail campaigns on the first of every month, you create a recurring task and it'll pop up on that day. Your assistant will see it under his to-do in My Work and send the campaign.
Here are some tasks you can put on auto-pilot:
- Daily standup meeting
- Monthly progress meeting
- Client meeting
- Review contracts with a lawyer
- Check team performance every week
- Create a projects report every Monday
- Perform backup each week
- Check unpaid invoices
- Pay office bills
- Invoice work at the end of the month
- Contact an old client to keep in touch
Project planning doesn't have to be complicated. Once you've broken up work into tasks, planned start and end dates, and assigned people, all you have to do is manage the delivery. Next, we'll talk about keeping projects on the right track.