This post is a part of a series of posts about iteration management. If you want to start from the beginning, go here.

As an iteration manager, it’s your responsibility to make sure that everyone on the team has what they need in order to do their job and complete the work assigned to the current iteration. This can be tricky, but I find that it’s the fun part of the job.

Get people talking

Once of the biggest hindrances to success is a lack of communication. I’m sure you can think of examples where a lack of communication hurt the team. Maybe a developer reinvented the wheel because he didn’t know about the existing way to do it. Maybe your testers had issues testing some functionality because they didn’t know how to use the app correctly when a developer could’ve quickly showed them exactly how to do it. Maybe the users were confused or uncertain about some of the changes that you were making because they had questions that needed answers.

Someone needs to make sure that people are talking. This doesn’t mean that you have to do all the talking, you just have to make sure that you get the right people communicating so that everyone is on the same page.

An easy way to do this is to get the team members to sit together. This sounds obvious and many teams have at least part of the team sitting together, but it really helps having the BAs, developers, and QAs in the same area. Yeah, we might have email or instant messaging or phones, but people communicate so much better when their working in the same area. Plus, it increases team camaraderie, which helps communication even more (and it’s fun).

Be the unblocker

It’s your job to be the unblocker. This doesn’t mean that you just remove blockers for people, you also need to be able to see when people might be stuck and help them to get unstuck again. What complicates this is that many people don’t want to ask for help. They might think that they should be able to figure it out on their own, or maybe they don’t want to inconvenience people.

Whatever the excuse, there are usually some telltale signs that you can spot. Maybe you don’t see progress on something that should be moving along, or maybe you hear people sounding frustrated and complaining that they’re having trouble with something. This is where your intuition comes in.

Your job is to do whatever you can to allow people to focus on the work that they need to get done, which is what people tend to want to do anyway. But sometimes someone needs to see that there’s a problem and get the right people in the room to talk about it.

Sufficient requirements

I’ve been on projects that have really well defined requirements and many others that didn’t, and let me tell you, it makes a huge difference. If your requirements are only 80% complete, then your developers are probably going to get it 80% right. When QA goes to test, they have questions about the requirements just like the developers did, and they either write up bugs or get in arguments with developers about how things should be.

When the requirements are well defined, you don’t have as many of these problems. In fact, you probably shouldn’t start working on a feature until you’ve all talked through it and make sure that everyone agrees on the requirements (which include the acceptance criteria).

What counts as “sufficient requirements”? That’s up to you. There are some cases where I feel like I need to write part of the code so that I can find all the things that I’m not thinking of. If I do that, at some point I’ll have a better understanding of what the requirements should be, and then we can meet about it.

What I don’t want are people not knowing how something should work, or people feeling like they need to make assumptions or decisions about how things should work, or people having to wait for requirements clarification. When things are well defined, everything tends to go smoothly because people don’t have to worry about not having all of the requirements and they can just work.

Keep things flowing

You can only move as fast as the slowest part of your process. Here’s how this often happens: management wants to get things done faster, so they come to you and say, “Let’s get more developers!” That’s great, but if you don’t have someone to write requirements for that developer or help test their work, things aren’t going to move any faster (or maybe they will at the expense of quality).

If even you aren’t in that situation, it’s virtually impossible to always have perfect balance of analysts, developers, and testers, especially on smaller teams. What do you do if you have 1 analyst, 3 developers, and 2 testers, but suddenly you really need 2.4 testers? The only way to get 0.4 of a tester is to have someone else on the team that is not in tester role help out with testing. This is where it’s extremely valuable to have people that can do several different roles well so that you can eliminate bottlenecks in the process and keep things flowing.

This especially applies to developers, because often times the bottlenecks happen when developers get work done faster that QA can test it (and many teams have a shortage of testers anyway). I like to encourage developers to learn how to do other tasks, like analysis and testing. This can help eliminate bottlenecks, and it makes developers better contributors in general. In some smaller teams, the developer is also the analyst and the tester and needs to know how to do these jobs.

Finding the bottlenecks

How do you find the bottlenecks in the process? This is exactly why we have big visible boards for tracking work items instead of just using online tools! It also helps if you break your tickets down into smaller tickets so that you can actually know when things get stuck. If all of your work items take a week long and three days in your developer doesn’t really have much to show for it, are they really behind or do they just need to hook everything up so that you can see it work? You don’t really have a good way to tell (other than asking and hoping that the developer can accurately and honestly give you the right answer).

We also want to find waste in the process. Usually this comes in the form of waiting. For example, waiting for answers from the business on requirements questions, waiting for testing environments to get fixed so that testing can start, waiting for management to make decisions, or any number of other problems. It’s impossible to eliminate all of these, but we can try to reduce them by communicating and finding creative ways to make things move better.

Finishing

Think of the end of the iteration like a release date. Maybe you will actually be releasing to production. Either way, the goal is that functionality that goes into the iteration gets done. And by done, I mean all the way done. That means, that it’s developed, tested, and the users want to sign off on it. If you have another definition of done, you might be lying! When management hears “done”, they think that you don’t have to do any more work on it. So if you still have more work to do, that’s time that they aren’t accounting for in their mind, so now you’re in a tough spot.

As you get towards the end of the iteration, you need to make sure that everything that is going to be developed this iteration also can be tested by the end of the iteration. If you want to get a feature done by the end of the iteration, you can’t have developers checking in changes on the last day of the iteration if QA needs 2 days to test it because they won’t have enough time. On our two week iterations, usually we are cutting off checkins a day or two before the iteration ends, depending on how QA is doing. Developers might even help test if QA gets behind and can’t get it all done. Typically that doesn’t happen, so developers can keep working, but maybe they don’t check their code in until the iteration is over (or check it into a branch). This ensures that the QA team has enough time to test everything that is going into the iteration.

Be creative!

Every project is different, and every project will have it’s own unique set of problems, many of which you have never encountered before. At this point, your intuition needs to take over. Don’t underestimate the value of intuition and common sense! You can read all the books and blog posts that you want, and many of those will have good ideas, but it’s up to you to apply the ideas and tailor them for your situation.

Read the next post in this series, Estimates.

This post is a part of a series of posts about iteration management. If you want to start from the beginning, go here.

One thing that you’ll find on pretty much every Agile project is some kind of card wall where features are tracked.

When I started working on Agile projects several years ago, I didn’t quite understand the purpose of the card wall. I thought, wouldn’t you rather just track everything in some online tool?

While tracking things in an online tool is still a good idea, the Agile card wall gives you a level of transparency that it’s difficult to get from an online tool. With a good card wall, you can easily see what everyone is working on, what still needs to be worked on, how long the remaining work might take, and what’s blocking your progress. There is so much to keep track of on a software project, and it really helps when you have a visual aid that can help keep everything in front of you so that you don’t have to juggle everything in your mind (or some online tool).

The trick is to tweak your card wall to give you the most transparency as possible. Here are some things that I’ve found help me get the most of my card wall.

Everything is a task

Everyone puts development tasks on their card wall. However, not everything that your team does could be categorized as a deliverable feature. In fact, there are lots of other things that you might have to do:

• Write up documentation on a wiki
• Onboard a new team member
• Set up a CI build
• Get ready for a demo

These are all tasks that are completed by development team members that take a measurable amount of time. So why not create a card and put them on the board? Maybe you use a different color card to indicate that it’s an internal task. This gives you two benefits — you know what people are working on and you can use the estimate to gauge how much work is left to be done.

Make card walls for your entire team

If our development card wall can help us track what developers are working on and how much work is left, why not create card walls for the entire team? You could have a card wall for BA requirements gathering, QA creating test plans, project management tasks, or some mini-project that you want to track separately. You get the same benefits that you get with a development card wall — you know what people are working on, you can easily see the status of the effort, you can prioritize the backlog, and it can help you get an idea of how much work is remaining.

Make problems obvious

Your card wall should alert you to any problems and blockers as soon as possible, so that you can remove any blockers and constraints that could keep your team from being able to do their job. Some ways that you can do this:

• Create a separate section of your card wall for blocked items
• If something is blocking a feature, put a post-it note on the card and write what the blocker is
• Structure your card wall so that you can see problems immediately just by glancing at it

Let’s look at some examples of some simple card walls and we’ll interpret what we see.

Example #1

In this example, we can easily see that we are either developing things faster than we can test them, or things are getting stuck in testing due to bugs. We may need to assign more people to testing or work on reducing bugs.

Example #2

There are a lot of features that are blocked. We should try and address the blocking issues and look and see if there is some greater problem that is causing things to get blocked. Maybe we need to write better features, or maybe we need to get more time from people in the business who can answer questions.

Example #3

We don’t have much in our backlog, so the developers are going to be out of stuff to do really soon. We may need to get more people working on requirements gathering.

Example #4

Things are flowing pretty smoothly. We have a good sized backlog, no blockers, the work is evenly distributed, and we’re getting a lot done.

The key is that we want to see problems as soon as possible so that we can take the necessary steps to correct the problem and keep things moving.

Address technical debt as part of the process

As much as we hate to say it, sometimes it makes sense to shove in lower quality, untested code in order to meet a deadline. I don’t like having to do this at all because of the risks, but when this happens, keep track of all technical debt that will need to be fixed and create separate cards for fixing it. Make these cards a different color so that they stick out. Then use your board to explain to your manager or project sponsor that you’re going to need some time to go back and fix the technical debt. Many managers want to pretend that the work is done once you release and will convince themselves that they can just move on without addressing the technical debt. You know better, and it’s your job to state that case and show why it’s important.

Refactor your card wall

Your card wall is yours. You create it, you manage it, and it belongs to you. Don’t be afraid to rearrange and refactor your card wall so that it can better meet your needs. Don’t make excuses like “we’ve always done it this way” or “we read a book that said to do it this way” or things like that. Your process and tools need to serve you not the other way around.

Read the next post in this series, Managing the iteration.

This post is a part of a series of posts about iteration management. If you want to start from the beginning, go here.

OK, if we’re going to talk about something called “iteration management”, we first should discuss what an “iteration” is. Turns out there are lots of different ways to deal with iterations, so I’ll go over some of the common ones.

Time boxed iterations (the Scrum way)

When most people think of an iteration, they think of a set period of time in which you perform a series of activities and then you do it all again in the next iteration. This is what you usually find in Scrum-based agile environments (doesn’t mean that you have to do textbook Scrum). In a Scrum-based environment, an iteration usually goes something like this (more or less):

1a. Capacity planning – determine how much work we can get done in the iteration
1b. Sprint planning – meet with the business and the team to figure out what to work on, maybe estimate tickets
2. Do the work
3. Demo/UAT
4. Maybe release to production, or at least say that a set of features are complete
5. Retrospective – team meets and talks about what went well, what didn’t, what to change, etc.

The length of an iteration is up to you. I’ve seen people do anything from one week to a month. The shorter the iteration, the less time you’ll have between production releases (if you’re releasing to production each iteration). With longer iterations, you often fall into the trap of doing a bunch of work and then trying to test it all at the end, which ends up being a testing nightmare (now you’re Agile team is just doing mini-waterfalls).

My favorite is a two week iteration. Sure, it would be nice to release to production every week, but I’ve found that the business likes the two week cadence of the process, and they get used to being involved at certain points in the process every two weeks. It also gives you more time to get the work done instead of having more meetings dictated by the process (since you only have those meetings every two weeks).

In the iteration-based model, your metrics are usually measured by the iteration. (For example, how much work can we get done in each iteration?) This model works well when you have a project that you need to complete by a certain time. You need to know if you’re on track, if you need to devote more (or less) people to project to get it done on time, you need to estimate work to know how long it’s going to take, etc.

Continuous flow (the Kanban way)

In this model, you don’t have time-boxed iterations. You just have a backlog where work comes to the development team at any time and they just work on whatever is most important. You might release to production on a regular schedule, or you might release whenever you feel that you have something significant to release. Some teams might even release to production multiple times a day.

The goal in the iteration-less model is not to see how much work you can get done in a certain amount of time. The goal is to see how quickly you can move a ticket through the process (we call this “cycle time”). The idea is that we want to minimize the time between when a business person has an idea and it becomes a reality.

This model works really well for teams that are doing maintenance work or production support (i.e. you aren’t working on a project where people need to know when the project will be done). Things like capacity planning and estimation start to feel like cruft in a situation like this, and it’s much simpler to just bring work to the team and do whatever is most important. You can still have regularly scheduled activities (e.g. demos every 2 weeks), but the process is much more fluid and free-flowing.

Which is best for you?

Only you can answer that! There are no rules on how to do this. I encourage you to think outside the box and come up with whatever works best for you. Regardless of the method, here are some things that I think are important that you should consider:

• How can I most quickly diagnose problems?
• What works best for the stakeholders, management, and the business?
• What allows us to best handle (and even encourage) changes in priorities?

Most of the rest of this series is going to focus more on the time-boxed iteration method of developing software. Many of the ideas will still apply to the flow-based approach, but the time-boxed method is more involved and has a lot of interesting nuances that are worth talking about.

Read the next post in this series, Card walls.

This post is a part of a series of posts about iteration management. If you want to start from the beginning, go here.

If you haven’t heard of iteration management before, maybe you hear the word “management” and you think “project management.” It’s similar, but not really. Here’s how I distinguish the two – project managers manage projects across iterations and maybe across multiple teams. An iteration manager manages the work done by one team within an iteration, although there might be some coordination with other teams.

An iteration manager helps to optimize the efficiency of the team. People on software development teams tend to like to focus on their tasks. They will strive to limit distractions and do whatever they can do get their work done, and sometimes this even comes at the expense of the team. In a way, this is good, because if you give someone a task to do, you want them to get it done efficiently. But in order for this team to truly function like a team, we need someone whose head is not in the weeds who can look at the bigger picture and make sure that the team is working in the most optimal way. This is where you come in.

An iteration manager is an unblocker. If team members are blocked by something, the iteration manager should try and get it resolved for them. An iteration manager should be proactively searching for blockers before people raise an issue because some people will either spend too much time trying to figure things out on their own or just not tell anyone that they are blocked.

You might have to be creative with how you do this, but you will learn to see the signs of someone being blocked. If you have a board/wall/online site/etc. where you have the iteration’s tickets, watch for things piling up in a certain status (whether it’s analysis, development, or testing). If you have people on the team that are working on multiple tasks at once, it could be because they can’t finish the first task until they get an answer from someone, so they’ve moved onto the second task. Or maybe you just notice that a certain feature isn’t getting done as fast as you thought it should and it causes you to ask a question.

Overall, your task is to help the team work as efficiently as possible. This doesn’t just mean “fast” (although that’s certainly part of it), it also means that you ensure that software is going to meet the needs of the business and the people that use the software. In order to do this, we’re going to use everything at our disposal, including data analysis, communication, and lots of intuition.

What I love about iteration management is that it allows you come up with creative ways to achieve the goal, and there’s no one right way to do it. The rest of this series is going to give you a bunch of tools, tips, and tricks to get the job done, but ultimately you’ll have to use your own intuition to do it well.

Read the next post in this series, What’s an iteration anyway?

Iteration management is the art of managing the estimating, planning, and execution of a software development project over a short period of time, whether this is done individually or in a team environment. I call this activity an art, because while there certainly is a scientific element to it, it requires excellent communication skills and a strong intuition. You need to understand what is realistic for your team while getting things done.

For some of you, this might be a new career path that you didn’t know about. Many people assume the next step from being a developer, tester, or analyst is to move into some sort of traditional management. Iteration management allows you to stay closer to the team and probably continue doing the work that you’ve been doing while providing value in a new way.

What’s coming

This topic is way too big for one topic, so I’m splitting it up into a series of posts:

• What is iteration management?
• What’s an iteration anyway?
• Card walls
• Managing the iteration
• Estimates
• Comparing estimation methods
• Data analysis
• Consistency
• Personal iteration planning
• Metrics
• Burndown charts
• Capacity planning
• Involving stakeholders
• Keeping up