Cycle Time and Thin Vertical Slices

Cycle time is an under-appreciated metric that can provide insight into the effectiveness of a development team. Velocity (aka throughput) is usually the metric that gets all of the attention. However, shifting some of the emphasis away from velocity and onto cycle time will probably increase your velocity anyway, and the customer will benefit as well.

What Is Cycle Time?

Cycle time represents the amount of time it takes for work to flow through a system. To oversimplify some otherwise very interesting math, Little’s Law basically states:

Cycle Time = (Average WIP) / Velocity

A high velocity with a low average work in process means you have a low cycle time. A low cycle time means that once a team begins work on a feature it will generally be completed fairly quickly. A high cycle time means the opposite.

How Do We Improve Cycle Time?

You can decrease your cycle time by increasing your velocity, by decreasing your work in process, or by breaking your work into smaller chunks (although this isn’t as obvious from the formula). Four separate 5-point stories will flow through the system faster than a single 20-point story. Since increasing your velocity is typically difficult to do, decreasing your work in process and breaking stories into smaller units is usually the most practical way of improving cycle time. Imposing limits on the number of stories or points that can be in development will help ensure that the emphasis is on pushing existing stories through the system rather than starting new ones.

Why Is Cycle Time So Important?

Imagine you had a project with 100 well-defined user stories. Would the customer rather have one story delivered per day for 100 days or would they rather have 100 stories all delivered on the 100th day?

In both of these cases the team’s average velocity over these 100 days is the same. However, in the first scenario the team with the low cycle time is able to show constant progress to the customer. A low cycle time also means it is easier for a high priority feature or bug fix to be delivered quickly.

Thin Vertical Slices and Cycle Time

I recently began working with two small development teams that are new to the concept of user stories and thin vertical slices. The teams were mostly used to doing development in the form of thick horizontal layers. In other words, they take a group of features and break the work into data access vs. business logic vs. UI development tasks. They completed all of the work in one layer then move on to the next. The result is usually a very high cycle time and lumpy delivery of features.  It is likely in this model that features will be completed in batches and the hand-off to Quality Assurance (QA) can be overwhelming.

But why should we care? Of course the customer would usually prefer to see progress at frequent intervals but what if the they really only wants to see the final product? Does cycle time matter then?

Yes! The importance of cycle time is intensified when there is a hand-off in your process. An example would be the development team handing off a feature to QA for testing. Another example is QA handing a feature off to the customer for user acceptance. If the development team is doing work in thick horizontal layers they are likely dropping huge bombs of features on QA in sporadic intervals. QA can be left with nothing to do for days or weeks and then suddenly they become the bottleneck. This is wasteful and will decrease the team’s velocity. It can also place unnecessary pressure on QA which can have a negative impact on quality. Likewise, reducing the team’s cycle time will reduce waste, improve quality, and ultimately increase the team’s velocity.


Cycle time is an important metric that can be used to improve a team’s velocity by reducing waste and improving quality. Strive to improve cycle time by enforcing lower work in process limits or breaking down work into thin vertical slices of functionality. Teams with low cycle times can show constant progress to their customers, are more capable of reacting to unplanned work, and perform better all around.

Does your team pay attention to cycle time?

Deliver Solutions, Not Code

While it might sound like a good idea, giving your customers what they ask for might be doing them a disservice.

Often times the customer will come to us with a solution already in mind (“We need a single screen where you can enter your order and do your checkout AND print your receipt!”). Ideally though, the customer would present a problem instead (“There are too many steps to our ordering process and it needs to be less cumbersome”). An experienced development team has probably solved similar problems before and will have ideas that the customer may not have even considered. Usually these solutions end up being better and may even be less work. The development team will also have a broader understanding of the capabilities that technology brings to the table.

Regardless of how the problem presents itself, solving the problem should be a collaborative effort. The development team should be able to propose multiple solutions from which the customer can choose and tweak. Even if your customer(s) always present problems in the form of premeditated solutions, it is a moral obligation of the development team to counter-propose better solutions if one exists. Nobody understands the problem better than the customer; therefore, the customer should ultimately be responsible for selecting (or at least accepting) the solution.

Admittedly, not all development teams are staffed for this model of collaboration. However, development teams should strive to collaborate with the customer to deliver solutions, not just code.

Prioritizing Technical User Stories

As with most software development teams, we struggled with the notion of “technical” user stories early in our Agile adoption. By technical user stories, I’m referring to stories that are difficult to express in the form of a business case that is easily understood by a non-technical person. Usually these stories provide some benefit that isn’t in the form of a new feature. Some types of technical user stories could include:

  • Refactoring code to reduce technical debt
  • Infrastructure or framework upgrades
  • Researching the latest technical hotness

Attempting to write a business case for these stories in the usual fashion often times ends up something like this:

As a Developer I can use the latest version of Java so that I can use it’s cool new features.

— OR —

As a Developer I can refactor the MngrHelperObjectUtil class that was created 9 years ago before we knew what we were doing so that I don’t have to be terrified for my life and take 3 months every time I need to make a change in that godforsaken code.

These business cases aren’t usually very compelling to the product owner as they are difficult to explain and are in direct competition with normal features. So how do these stories ever get worked in?

Not Everything Deserves An Independent User Story

First let me address the problem of stories around refactoring code. It has been my experience that this kind of work usually does not deserve an independent user story. The business case of “so that it’s easier to maintain in the future” is a tough sell unless “the future” means tomorrow.

If you’re already planning on making changes to the code in question then you have a stronger case for refactoring as the payoff will be more quickly realized. As an alternative to creating a new story for this refactoring work, try bundling it with another story that requires you to make changes to this code anyway.

When trying to determine how much refactoring to do, a good rule of thumb is that it should be proportional to the size of the change you are making in the first place. In other words, if you are making a small change then do a small amount of refactoring. This way, you don’t end up with low-value features costing too much; this won’t fly with the Product Owner.

What About Work That Does Deserve An Independent User Story?

As I mentioned already, we struggled with this early on. We tried to take care of these stories under the radar. We didn’t bother prioritizing them with the Product Owner and just understated our capacity so that we would have at least a little bit of time to work on these stories each iteration.

This is clearly the wrong approach for a number of reasons. Your Product Owner needs to be aware of these stories. Some iterations may require more capacity devoted to these stories, and other iterations may not require any technical stories at all. Not accounting for these stories would cause variations in your velocity that make it difficult to plan.

Another approach we tried was just carving out X points each iteration to be devoted to technical stories. This was similar to what we first tried, but at least this way the Product Owner was aware that it was happening and we had a better picture of our velocity. Once again, we found that this approach didn’t work well as the number of points needed for technical stories varies from iteration to iteration. For example, upgrading from Java 1.5 to Java 1.7 probably isn’t going to happen in just 5 points.

After many months of evolving our process we ultimately realized that we just needed these technical stories to be prioritized like any other story. This means that the Product Owner has to understand the benefit of these stories.The development team (or perhaps the Scrum Master) needs to champion these stories and sell them to the Product Owner. It has been my experience that any reasonable Product Owner has no trouble prioritizing these stories.

Going through the prioritization process also has the added benefit of keeping the development team honest. As developers, we have a tendency to want to upgrade to the latest and greatest — but sometimes we need to really think about why and justify taking the time to do it.


Where possible, include technical work as part of a related story rather than making an independent story. Refactor code when you are already modifying code in that part of the application. When technical work warrants its own story, make sure that you prioritize this work with the Product Owner just like any other story. You’ll have a better picture of your velocity and it will help ensure that you only take on work that actually needs to get done.

Still Not Agile? Take Baby Steps

It’s 2014 and you still aren’t Agile. You haven’t had the luxury of upper management taking the lead and you don’t see any signs of that changing. How do you get started with Agile?

If you have management support then bringing in an Agile coach is a really great way to kick things off. You’ll have an expert to guide you and answer all of your questions. You’ll also have someone constructively calling you out on your unproductive habits. However, if you don’t have this option then the second best approach is to gradually work it in from the bottom up.

If you haven’t already, make sure you read the Agile Manifesto and the Principles behind the Agile Manifesto. Spend some time reading up on the purpose of the various ceremonies in Agile Scrum. I recommend Scrum because it’s the most widely practiced flavor of Agile, and it’s fairly prescriptive.

Trying to introduce all of the practices immediately will likely be too overwhelming. Here are three things I recommend you try first as they will add standalone benefit to your process, even if you never adopt all of the recommended practices.

Document Your Work and Make It Visible

Think of everything you are currently working on and will be working on in the coming months. Break that work into reasonably small units, say less than five days of work per item, and document each item on an index card. Write down just enough information that you will know what you are referring to if you look at the card a month from now.  This can be a team or individual effort depending on your situation.

Next, draw three columns on a whiteboard (or something comparable) and label the columns “Backlog”, “In Progress”, and Completed”. Now divide up the index cards into these three self-explanatory categories and tack them on the board. Congratulations. You now have an “information radiator” that broadcasts your current and upcoming priorities. Anyone can walk by and see what you are working on, and what you having piling up.

This is a useful enough tool for keeping track of your own work that it doesn’t necessarily need to be seen by others. However, people will look at the board. If you are lucky, a customer or your manager  will look at the board and ask you a question or two. “What does card XYZ mean? I didn’t know you were working on that.” or “I thought you were working on ABC, is everything OK?” These are good conversations to be having as they can help ensure that you are working on the right thing. Communication is key!

The board is also a useful tool for prioritization. When someone swings by to ask you to work on something you can grab a card, stand up, and have a constructive conversation about which of the things in your “In Progress” column should get moved out. After all, you can only work on so many things at once.

Daily Stand-up Meetings

Having a daily stand-up meeting is a surprisingly effective way to kick off the day. It is also a step in the right direction when it comes to frequent communication! Try to include everyone who is a regular contributor to the project. At a minimum, this should include the other developers and QA. In a perfect situation this will also include the Product Owner or customer, as well as any other cross-functional members of the team (e.g. UX Analysts,  Operations, etc.) that might not be 100% dedicated to your project.

I won’t go into all of the merits of a stand-up meeting as there are plenty of great resources on the topic (see Wikipedia for example). While you should be communicating with your team members in near real-time, a stand-up meeting guarantees you are communicating at least once a day.  This can be especially beneficial for getting some face time with a Product Owner or your customer, who may not be as integrated with the team as you’d like.

Retrospective Meetings

One of the principles behind the Agile Manifesto is that the team should be continuously improving. It states: “At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.” Having a regularly scheduled retrospective meeting provides team members with an opportunity to talk about what is working, and what isn’t. As with stand-up meetings, you shouldn’t necessarily wait until this time to bring ideas to the table, but it does provide a guaranteed time slot to ensure you are devoting at least some time to continuous improvement.

In your first few retrospectives you’ll likely be talking about how to make sure the stand-up is adding value, whether you want to add another column to your board (e.g. “In QA” or “Needs Acceptance”), how to better document your work, etc. Make sure that you have a plan for implementing  at least one or two ideas from each retrospective and reflect on whether your most recent changes were effective.

Before you know it you should be talking about how to take the next steps to becoming more Agile. Perhaps you’ll want to establish a true development iteration. Maybe you’ll want to start estimating your work for planning purposes. Maybe you’ll want to select an unofficial Scrum Master or Product Owner for the team. Whatever you do, keep improving!


Documenting your work on a whiteboard, holding daily stand-up meetings, and retrospecting on your development process are three easy ways to start getting Agile. If you can implement these then you’ll start prioritizing more effectively, communicating more frequently, and you’ll ensure there is a guaranteed mechanism for improvement.

Have more questions about getting started with Agile? I’ve been through the bottom up approach and would be happy to discuss your own unique challenges if you need help getting started. Good luck.

What Does a Development Manager Do?

As a (software) Development Manager myself, I am always pondering exactly what it is that makes someone great at this role. While surely every company has their own take on the role (if they even have the role!), here are my thoughts about what makes a good Development Manager.

As with other members of the development team, the primary responsibility of a Development Manager is delivering software. Obviously this needs to be the right product, with the appropriate level of quality, delivered in an acceptable amount of time. Without directly gathering requirements, doing design work, developing, testing, etc., how does a Development Manager contribute to delivering great software?

Here are what I believe to be the most important responsibilities of a Development Manager that have a direct impact on a team’s ability to deliver effectively:

  1. Ensure your teams are following an effective development process. This should likely include a focus on communication both within and outside the development team(s), a continuous improvement model like frequent “retrospectives”, and some basic mechanism for measuring and communicating progress. This is in large part what being Agile is all about. A hugely important function of a Development Manager could also be drumming up support for Agile if there is a culture challenge within your company.
  2. Do the normal managery stuff. Make sure teams are appropriately staffed and equipped. Mentor the team leads. Train and grow team members. Make sure people are happy. Be accessible. Break down barriers for your teams. Keep your teams informed of what is going on in the business. Participate in the budgeting process. Share responsibility for failures and shield your teams from politics and drama.
  3. Keep upper management informed. Upper management should know what your teams are about. Let them know about your teams’ successes and opportunities on a regular basis. The only way you can grow your teams and get the resources you need is if the company understands and believes in what you are doing. This responsibility would ideally be shared with the Product Owner(s).
  4. Understand the business and advocate technology solutions. As with a Product Owner, I believe a good Development Manager needs to have command of the company’s strategy and major initiatives. This understanding coupled with a strong grasp of technology and your teams’ capabilities puts the Development Manager in an excellent position to advocate solutions which can be delivered by your teams. Of equal importance can be understanding what is not a good fit for your teams. For example, don’t commit to building an enterprise chat system when there are perfectly good packages that could be purchased instead.
  5. Help wherever it is needed. A Development Manager needs to have a strong technical background and needs to understand all of the roles of the cross functional team. I believe a good Development Manager should be able step up and provide hands on help when the team really needs it. This could be anything from doing actual development to manual system testing to requirements refinement and gathering, or anything else that might be blocking the team. If this is happening frequently then it is a sign of a bigger problem, but occasional help at this level is appropriate.

What do you think are the most important functions of an effective Development Manager?