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

Some teams like to estimate in hours, and other teams like to estimate in “story points”. Other people simply try to break down all work into small tickets and just count the number of tickets completed. Other people don’t estimate at all. Which way is best?

Of course, it always depends on your situation, and people have views and opinions that are all over the place. I’ll give you my opinion and try to accurately represent all viewpoints, but this is just my opinion, so feel free to disagree with me.

Estimating in actual time (hours, days, etc.)

Pros:

• Estimating in hours makes sense to a lot of people, and they’re used to doing it.
• If you’re on a project and the team understands the application, the business, and the subject matter very well, you might be able to accurately estimate how long something will take (especially if you can break it down into small tickets).
• Works well when you can have the people who are going to do the work do the estimating. (This works best when you can estimate tickets shortly before you’re going to work on them so that you know who will be working on them.)

Cons:

• Estimates can vary from developer to developer. One developer who has been on the team for awhile and works quickly might estimate something at 4 hours, but a slower developer who hasn’t been on the team for awhile might estimate 16 hours. Both estimates are correct (for that person). This is OK, but if you don’t know who is going to be doing the work and the 16 hour developer inherits the 4 hour estimate, you’re going to have a problem.
• Doesn’t work well if you don’t know enough about the application, the business, or the subject matter, which makes it really hard to come up with an estimate in actual time that has any chance of being accurate.
• If you track velocity over time, it should be relatively consistent in terms of hours of work completed, but this won’t show if the team is getting faster (or slower) over time because the team’s estimates of a certain type of ticket will decrease over time. If you estimate in story points, a certain type of ticket will always have the same point value and you will see an increase in velocity over time.

Estimating in story points

Story points are arbitrary values that are given to a feature and then all other features are estimated relative to how difficult each task is to the previous tasks that have been assigned a specific story point value. People measure “points” differently depending on who you ask – some people say points are a measure of time/effort and others say that points are a measure of complexity. There’s no one right way, which is the point of this post.

One popular method is to use the Fibonacci sequence numbers as the point values that you can use in your estimates (e.g. 1,2,3,5,7,11,13,17,23). This makes it a little easier because you don’t have to agonize over whether something should be a 13 or a 14.

Pros:

• Works really well if you are estimating a project and you don’t know much about the application, the business, the technology, or the subject matter. In these cases, estimating in hours is a complete stab in the dark, but it’s much easier to compare the effort or complexity of one feature vs. another. (This happens a lot when you work for a consulting company and your company wins a bid for an entire project.)
• People aren’t very good at estimating in actual time, but they’re much better at estimating the size of a task relative to other tasks that have specified point values.
• You might have one developer who would estimate a task at 4 hours and another developer who estimates the task at 16 hours. But both developers might estimate the task as 2 points because they’re measuring the task relative to other tasks.
• Tracking velocity has more meaning. If the team gets faster over time and now a 2 point ticket takes 4 hours instead of 6 hours, you should see an increase in velocity over time, which is good for the team (especially if you’re trying to justify doing Agile in an environment that is new to Agile and is wondering if it’s worth it).

Cons:

• It can be awkward to estimate in story points, especially for new people who don’t know how the points have been allocated in the past. Other people have a hard time thinking in terms of story points when estimating a ticket in hours might seem easy.
• Team members and management tend to try to convert story points to hours, at which point people start to feel like maybe they should just estimate in hours anyway.
• Since a story point is arbitrary, it can become really easy to game the system. For example, management wants the team to increase velocity. Suddenly what would be a 2 point ticket now gets estimated as 3 points! (I realize that you could game the system if you were using hours as well, but it’s a little harder to do with hours since hours aren’t an arbitrary measurement.)
• Management at some point is going to ask for an estimate (read: commitment) where you have to specify a date when you need to be done, so you’re probably going to have to translate points to hours.

Counting tickets

Pros:

• Estimating feels like a waste of time and the estimates are often wrong anyway. If the tickets are all small and relatively close in size, the differences in size all average out anyway so we can just count the number of tickets and it will come out close enough. (This, of course, is dependent on being able to break down the work into small tickets of about the same size, which is hard to do on some projects.)
• No more estimation meetings!

Cons:

• Doesn’t work well if you aren’t able to break down the work into really small tickets.

An alternative way to count tickets is to have a small number of sizes of tickets (e.g. small/medium/large). This is similar to estimating in story points, but it’s less granular. You still count tickets, but each ticket has a point value (for example, small = 1, medium = 2, large = 3).

No estimation

Pros:

• Works well if you just work the tickets as they come to you and you don’t have to do long term planning (e.g. handling production support, ongoing maintenance).
• Works well if a good portion of your work is not known up front and just comes to you when it needs to be done.

Cons:

• Won’t work if you’re working on a project where management needs to know when it will be done.

More on story points

I often hear complaints from people that like story points. They say, “Management keeps trying to translate story points to hours!” My response to that is, what’s wrong with that? If you’re on a story point project, eventually you’ll have enough data to show that a 1 point ticket typically takes X hours on average, and so on. Isn’t that a good thing? Aren’t you better off if you’re able to translate story points to hours? Who wouldn’t want to have that knowledge?

This doesn’t mean that you can’t continue to estimate in story points, but remember, the whole point of estimating is ultimately to tell management or the business when you are going to get work done. There is still value in story points (more meaningful velocity charts, easier to estimate in some cases, etc.), but at some point the translation to hours is probably going to be necessary.

Use your brain

I find that people are very passionate about this topic, and the most passionate ones either think that you should always estimate in story points or never estimate in story points. I don’t like to use words like “always” or “never” because you can always find a situation where it makes sense to do things a certain way.

This is where you come in. You can read all of the books and blog posts that you want, but ultimately you need to use common sense and find the estimation method that works best for your team. There’s no harm is trying something and switching to something else later. The important thing is to do more of what works and less of what doesn’t.

Read the next post in this series, Data analysis.

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 ask people what they think of estimates, they’ll probably tell you that “estimates are always wrong”. But at the same time, management is taking those “wrong” estimates and treating them as a commitment to get work done by a certain date.

In reality, I think both of those things are true. The problem is that they seem so contradictory to each other, and this is where many teams get into trouble.

Many of you probably feel that estimating is a waste of time. It doesn’t make sense that you have to spend time each week estimating tasks when you could be using those hours to get things done.

I would love to live in a world where I didn’t ever have to estimate anything and all I would have to worry about is what I’m working on now and maybe what I have to work on next. Some of you might work in that kind of environment (maybe you’re in a small shop). But most businesses need to know how much things are going to cost, if Team A can complete a project before a certain date because Team B is going to need the functionality in place, if it’s worth it to build custom software or buy something off the shelf, or which consulting company to choose for a project. That’s the nature of smart business.

Or think of it this way – if you were going to build an addition on your house, would you not get several estimates from multiple builders and use those estimates as a major factor in who you picked to do the work? You certainly wouldn’t pick someone who said, “I do good work, so I’ll do the best that I can and then I’ll let you know how much it costs in the end.”

The fact is that if we want to be professionals, we need to be able to give good estimates, and we need to accept the fact that management is really asking for a commitment when they ask for an estimate. The whole reason that we estimate, regardless of the methods we use to do it, is so that we can tell management or the business when are going to get work done. Fortunately there are some things that we can do to come up with better estimates.

Small tasks

It’s much easier to estimate smaller things than larger things. What’s easier to estimate – the distance between your house and the one 3 houses down or the distance between New York and Chicago? You probably wouldn’t get either exactly right, but the margin of error will probably be less on the smaller distance.

The same is true when we’re breaking down a piece of work that we want to estimate. I like to break things down into the smallest unit that makes sense. Now that’s a pretty vague statement, but it really does depend on the situation. Ideally I like to break things down into the smallest testable unit that makes sense. That means that the feature provides some amount of value to someone (the business, IT, the dev team, etc.) and it can be tested and moved to production (or ready to go to production). There are always exceptions though – sometimes the smallest testable unit I can get to is still a week of work for 2 people, so then I’ll break the development down into smaller pieces (e.g. UI layer, business layer code, write some stored proc that is going to take awhile, set up an environment, etc.). Those technical tickets won’t be testable by themselves, but I’ll also have an overarching ticket that represents the testable unit (which is made up of the smaller techincal tickets). This at least lets us estimate smaller things so that we can be more accurate and have a better sense of how the work is progressing.

I’m not going to tell you what the maximum size of a ticket should ideally be, because every project is different. I’ve been on some projects where most tickets are under 4 hours of dev work, and I’ve been on other projects where the estimates were in days or weeks. The goal is to get the functionality broken down into the smallest chunk that makes sense for you so that you can get the estimate to be as accurate as possible.

Story Points or Hours?

There was enough here for it’s own post.

Categorization of work

On our team, we estimate analysis, development, and testing. So what counts as what? How does you categorize time spent by a developer writing automated tests? When a QA person writes a test plan, is that analysis or testing? What about meetings where you’re talking about a feature?

You can come up with your own rules of thumb, but here are mine:

Analysis

• Time spent doing business analysis (this one is obvious)
• Technical design
• Research into how something works, whether this is business-focused or technical
• Time spent by team members in meetings discussing the feature (remember, 5 people in a 1 hour meeting = 5 hours)

Development

• Coding, writing code, thinking about code, talking about the code, etc.
• Writing automated tests (if your QA people are writing end-to-end automated tests without developer involvement, I might categorize time doing that as QA)

Testing

• Manual testing
• Test planning
• Writing up bugs for a feature
• Writing end-to-end tests (see my comment in the Development section)

Other stuff (I might want to track the amount of time spent on these things, but not at a feature level)

• Team meetings not related to specific features (retrospectives, standups, iteration planning, other team meetings)
• Project management

How your team categorizes specific things doesn’t really matter, what’s important is that everyone is consistent and does it the same way so that you can get good data. You might want to check with your management as well because certain activities are capitalizable (like development, technical design, and testing) and others are not (like analysis).

The people doing the work should be the ones doing the estimating

This sounds pretty straightforward, but it’s really important. Let’s say that you know a lot about your application and you can complete feature X in 4 hours. But someone else who hasn’t been on your team as long or maybe isn’t as fast as you might take 16 hours. It’s not fair for you to give the 4 hour estimate and then hand it over to the person who is going to complete it in 16 hours. Maybe in that case you let the person re-estimate it at 16 hours, but that could throw your planning off. (This is another good thing about story points – when you estimate the size of a feature relative to other features, both developers might give the same estimate even though one will take 4 times the hours to complete it.)

I’ve been on some projects where we estimated a good portion of the work up front (because we had to bid on the project). That’s fine, but we never re-estimated anything. That led to lots of situations where a developer got assigned a ticket that they didn’t estimate, and once they had been working the task for as many hours as were estimated and they weren’t done, they started freaking out because they felt like they were behind, and this is when the sloppy code practices start happening. This happened because the people doing the work didn’t get a chance to give an estimate. If I give an estimate and I don’t finish it in time, then that’s on me, and I know it, so I don’t have any room to complain.

Nothing is more demoralizing than having someone else commit you to an estimate that you don’t feel is realistic. This just makes you feel angry, unmotivated, and unempowered. But if I make an estimate, then I’m a lot more likely to want to meet the estimate, even if it turns out that it’s going to take longer than I originally predicted.

Anything can be broken down

Any amount of work, no matter how complex, can be broken down into small, manageable tasks. The most complicated project is nothing more than a collection of simple tasks. The trick, of course, is identifying those simple tasks. But that scary project will become a lot less scary as you identify small units of work that need to be done. This exercise will also give you a better idea of all of the things you’re going to have to do, and you will be able to make better estimates on the small tasks.

This also applies to more nebulous roles like project management. Project managers are typically really busy and have to juggle numerous things at one time, but like anyone else, all of their work can be broken down, prioritized, tracked, and estimated. This will also free your mind because you have a system for keeping track of your work other than trying to remember everything in your mind (which is exhausting).

When to do the estimating

When the estimation happens depends on your team, your project, and how your team prefers to do it. I have a couple tips though.

Do the estimation as late as possible. It usually helps to have the work for the next iteration estimated so that you can do the capacity planning for the next iteration. You might have to estimate it earlier (so that you can plan out a release or bid on a project), but you might want to re-estimate that work when it gets closer to when you’re going to work on it in case the estimates have changed so that you can plan accurately.

Don’t have long estimation meetings. Some teams will have these meetings that last several hours long where the entire team goes through tickets and estimates them. I guarantee you that this will become everyone’s least favorite part of the week. Sometimes you might want to get everyone’s input on certain features, but for most things, you know who is going to do the work, so I would just let that person give their estimate so that you don’t have to tie up the whole team in mind-numbing meetings.

Remember the goal

Remember that however you estimate, the purpose is so that we can tell management or the business when are going to get work done. Use your intuition and come up with the best way that your team can estimate in order to meet this goal.

Read the next post in this series, Comparing estimation methods.

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

The open team workspace, once limited to hardcore Agile enthusiasts, is now becoming more mainstream (dare I say trendy). Tall cube walls are being torn down in favor of short walls, folding tables, rolling desks, and any number of other creative setups. But some people are wondering if it’s a good thing.

I’ve been working in open environments for most of the last 8 years now. I had L-shaped desks, folding tables, low cube walls, no cube walls, and everything in between. I’ve been a huge fan of this sort of setup, but I’ve worked with some people who didn’t like it as much. This is what I’ve got now (which I really like):

Regardless of whether you like open workspaces or not, there are some things you need to learn in order to work in this sort of environment. If your company has an open floor plan, there are definitely some considerations that you should think about.

The #1 complaint I hear from people who don’t like open workspaces is that it is hard to focus. Sometimes when you’re working on a difficult coding problem, you need solid time to focus on one thing and one thing only. This is really important, but thankfully there are many ways to handle it.

Headphones

This one is pretty obvious. I often joke that our IT department sounds like the mall food court. We are by far the loudest department in the company (excluding departments where people are on phone most of the day). All of this is good but you need a way to block out the noise.

Portability

Everyone in our IT department has a laptop. That means that we can work at our desk, or we can go work in the lunch room, the coffee shop, or at home. We have some docking stations set up with monitors in some rooms where you can work by yourself, or collaborate with your friends. We have conference rooms with big screen TVs and whiteboards. We can draw on the windows with dry erase markers. I’ll often go sit somewhere else in the building, which I like to do if I’m going to work on something that requires a lot of creativity just to get a change of scenery. We have rooms that look like this (no this is not a stock photo):

Flexible hours

I have young kids, so I tend to get in a little later, leave a little earlier, and work some at night after the kids go to bed. I can kick off a job at night before I go to bed and it’s ready for me to test in the morning. The flexible hours allow me to do some of my work at home when no one can bother me, and I still have plenty of time with the team. It’s the best of both worlds.

Keep teams together… and separate

I love the collaboration, camaradarie, and togetherness that comes with an open work environment. I’m a people person, so I thrive on the energy. Working from home can be nice but I love seeing people every day. I love that I go into work and people ask me how my weekend was.

At the same time, if you’re going to have an open floor plan with several different teams in the same area, you do have to be careful about putting different teams too close together. We have lots of teams in one area, but I’m friends with most of them, so it’s not a big deal. And while our environment is very open, it’s not like we’re crammed onto rows of folding tables like we’re in a computer lab. I still have my own personal space. I like the sound of my teammates talking and collaborating, but the sound of people that you don’t know is like fingernails on the chalkboard. It can drive you insane.

The common thread

After years of hearing pros and cons of open environments, I think I’ve found the common thread that most people will agree on. We need work environments that meet multiple needs and many different situations. Sometimes you need to collaborate, and sometimes you need to focus by yourself. Sometimes you need to look at code with a group of people, and sometimes you need to draw things out on a whiteboard. Sometimes you need a place that helps inspire creativity. Some people thrive around people, and some people need peace and quiet. Some people like working during the day, and some people like working after midnight. There are ways that we can provide work environments that provide the best of everything and allow people and teams to work in whatever manner works best for them.

I believe in open work environments because we are solving business problems, and the hardest part of every software project I’ve been on has been not having enough communication. Sure, there are difficult technical problems, but those are best solved in the context of the team, even though much of the actual work is done individually. Tall cube walls tend to decrease communication when we usually need to increase communication. In an open environment, the communication barriers are broken down (literally), but I still have ways that I can get away and focus.

We need to remember that people are all very different. What’s good for one person may not be preferable to another, and we need to be aware of that.

There are those who believe that a developer should not test their own code. This may sound logical, but I’m not sure I’m buying it.

This statement typically refers to QA testing, and doesn’t mean that a developer shouldn’t write unit tests. The thinking here is that a second person testing the features that you’ve developed might think of things a different way and find a problem that you didn’t think of when you wrote the code.

There are lots of commonly accepted statements and ideas like this in software development. But I’ve found that in many cases, these ideas are usually based on certain assumptions, and if you can challenge those assumptions, you might open yourself up to things that you didn’t think were possible.

The assumption that I see here is that a developer writing the code is not sufficiently capable of thinking of all of the test cases. Imagine you write code for a feature, and now you have to test it. At this point, you’ve gone through a certain mental thought process when you implemented the feature. This makes it much harder to think outside of the box to come up with the edge cases. Not to mention that when you see that the feature appears to be working overall, it’s really really tempting to do some basic manual testing and then move on to the next feature without really doing your due diligence. A independent QA tester, however, will look at the feature objectively because their thought process isn’t clouded by past experience of having written the code.

OK, so what if the developer figured out all of the tests cases before writing the code? Now their thinking isn’t clouded by the implementation of the feature because they haven’t wrote the code yet. Maybe a QA person helps define the test cases, but this post is about developers testing their own code, so let’s assume that QA people aren’t involved. I would argue that now we’ve removed the main reason that developers are not good at testing their own code (thinking of the test cases after writing the code), so they should be able to think of test cases just as well as a QA tester, and therefore they should be able to test their own code.

Don’t misconstrue what I’m saying there – I’m not saying that we don’t need our QA teams. I’m saying that developers need to be responsible for testing. QA teams can add more testing help, but developers need to be responsible for their own code.

This opens you up to new possibilities. It enables developers to be confident about the quality of their code. It limits the wasted time you incur when you have the back-and-forth that comes with QA finding bugs and developers having to go back and fix things. It can reduce the amount of “checking” that QA people need to do because they might be comfortable knowing that developers are writing quality code.

If you’re a developer, this is some thing you can start doing today. Before you implement a feature, come up with all of the test scenarios before you write your code. If you have a QA team, have them review your test cases to see if you’ve missed anything. Then go write some bug free code!

How much of the responsibility for the software that you are creating falls on your shoulders?

There are two ways of looking at responsibility on a team. One view would be to say that if there are 10 people on the team, then I’m responsible for 10% of the software development process. I don’t need to be concerned with the quality of the requirements because that’s the business analysts’ job. I don’t need to worry about testing my code because we have testers to do that.

The other view is that even in a team environment, I am still 100% responsible for the software I’m creating. That means that I’m not just implementing the requirements, I’m trying to understand the requirements to make sure that they’re correct and that we’re building things in the best way possible that will meet the needs of the business. And that certainly means that I’m never ever going to send code to QA that I haven’t tested just because I think they’re going to test it for me.

I need to be responsible for communicating with my team members the best that I can. I would much rather be clear about who is doing what rather than assuming. If I make an assumption, it’s probably going to be wrong – either I will assume someone is going to do something when they’re not and something will slip through the cracks, or I will assume someone is not going to do something when they are, and now we’ve duplicated effort.

This is what I see happen often on software teams, especially when it comes to testing. Developers assume that QA is going to do the testing, so they give code to QA without completely knowing if it’s working. QA assumes that developers are going to do this and don’t know what was tested and what wasn’t, so they think they have to test 100% of the functionality of the feature. In reality, the developer probably wrote decent code that mostly works, and they probably did test it to some extent (whether manual or automated), so the tester is duplicating some of the effort, but if they don’t know what was already done, they don’t have a choice.

This is where communication is key. If I as a developer am going to write automated tests to prove that my code works, then I want QA to be involved in the writing of the tests (even if that’s just reviewing what I’m doing). That way QA doesn’t have to duplicate effort because they can know that developers have already done some of the testing, and developers can start giving code to QA when they are confident that it works (with actual proof to back it up). QA and developers can work together to decide who is going to test what, what is going to be tested, and how it’s going to be tested.

In this case, everyone is 100% responsible for the quality of the software. Instead of expecting others to cover for us, we work together with others to make sure everything is covered. This requires people to move past their traditional roles, trust each other, and work together. In the end, we won’t duplicate effort and we won’t let things slip through the cracks.