I recently read a fascinating article in a farm journal that made me think about software engineering. You are likely thinking that there’s not much that farming and software engineering have in common and, for the most part, you’re right. However, in this particular instance, the story relates directly to typical practices in the software industry today.
The article told the story of a group of research scientists who had spent years working with bell peppers. The scientists embarked on a program to cultivate peppers that were more disease resistant, could flourish under sub-optimal conditions such as poor soil, limited water, & lack of full sun, and that would also produce greater numbers of peppers than the original.
After quite a bit of time, effort, and funding they managed to achieve some moderate success. Then someone suggested that they take some of their latest crop of peppers to a local restaurant and get some input from one of the chefs. While the article didn’t go into specifics about the chef’s reaction, it was clear that the reaction was akin to throwing the pepper in the garbage and suggesting that the scientists could have spent their time better elsewhere. The one thing that mattered most to the chef – the taste of the pepper itself – had not even been considered as one of the criteria to be taken into account by the research scientists. The scientists got caught up in their own little world of science and totally forgot that peppers were food and not specimens.
This immediately reminded me of the software industry and how so many teams have forgotten why they’re creating software. It’s not to simply write code, or execute test cases, or try out some new tool, or deploy a capability to a website – the software should ultimately meet customers’ needs. And the best way to do that is to work directly with customers as the capabilities are being created to ensure what’s being developed meets their needs.
Fortunately, the move to Agile and DevOps is making it much easier to work with customers due to the practices of continuous development and continuous deployment, as well as an intense focus on customer engagement and the monitoring of customer usage of the offerings.
The moral of the story…? Don’t forget the customer! J
Modified on by ScottWill
Just like the drip, drip, drip of a leaky faucet, we lose productive time by being regularly distracted. Some distractions can't be eliminated, but many can... I recently wrote an article for InformIT that was adapted from one of the chapters in the book that Leslie and I co-authored entitled Being Agile. The article discusses a pervasive form of regular distractions that many people have taken for granted nowadays. I thought I'd pass along a link here:
I hope you enjoy the article and that it provides some food for thought... As always, comments and questions are welcome. Thanks!
Modified on by LeslieEkas
When teams complain that they “do not have enough people”, that may be a sign the team composition has not resulted in an agile whole team. Agile’s mandate for working software requires that teams be composed of the right set of people to deliver on this goal. That generally means developers, testers, writers, user experience experts and so forth. That also means that there are team members from each of the component technology disciplines so that, as a team, they can deliver end-to-end functionality.
Large teams moving to agile often have to form several smaller agile teams with each team delivering completed user stories. Teams that have traditionally been organized by technology or by discipline, are reluctant to move to a cross functional structure because there may not be enough technical and domain knowledge in each of the resulting teams. What they discover quickly is the majority of the knowledge and skills in the team resides with very few people.
The solution to this problem is to cross train the team members so that they are better able to deliver product capability with the right set of skills and domain knowledge. Many teams resist this solution because it requires upfront costs and will slow the team down for a while. In fact many teams are so convinced this will not work that they do not make any effort to cross train and end up with teams that cannot deliver working software. This is what leads them to believe that they “don’t have enough people”.
It is a very hard sell but cross training your teams so that they can deliver a greater range of product functionality is well worth the upfront costs. Software engineers usually have a product area in which they prefer to work or a technology that they favor. But good software engineers have the skills to learn new technologies as required. And it benefits a team when engineers do expand their skills because not only are they able to help complete additional work, but their expertise and perspectives are beneficial when building new software and solving problems.
It is important to let management know there will be a short-term slow down (maybe as much as several months) when cross training team members. But when teams are willing to cross learn in a results oriented way, they become more productive and tend to move faster.
There are ways to cross train and continue to move forward at the same time. Pair programming is a great way to introduce a developer to a new technology or a new area of the code. Developers can also try to fix defects in an area outside of their domain, and then request a code review of the completed fix before it gets checked in. Figuring out how to fix a problem really forces one to learn about how the code works. Engineers can also test and write test code outside their current domains so that they learn additional areas of the product. There are no doubt many other ways you can come up with and we would love to hear your ideas. But teams that are not willing to take this step will struggle to make agile stick, and will continue to complain that they “do not have enough people”.
Modified on by ScottWill
Scott and I are thrilled to tell you about our new book called Being Agile: Eleven Breakthrough Techniques to Keep You From Waterfalling Backward. You can click on the link below to get access to the book or use the handy link in the Links section of this page.
Our goal for the book is to help teams that have adopted the standard practices and call themselves agile, but have not gained the real benefits that agile promises. We believe that adopting agile requires a change in thinking, not just adopting a set of practices. When teams don't get immediate results, they often fall back into old habits that will reduce their chances of success. Our book offers eleven breakthrough techniques to help overcome reflexive thinking so that you will start to respond with an agile mindset that prioritizes delivering customer value, ensuring high quality, and continuously improving.
The book consists of eleven chapters that focus on some of the critical topics for agile success. In each chapter we discuss the basic principles that are the foundation for the topic followed by the corresponding practices. Each chapter closes with a breakthrough technique to help teams achieve the real benefits of the aspect of agile covered in the chapter. It was not our goal for the book to be an agile primer or even to cover all of agile thoroughly as there are much better references for that. Our goal was to focus on principles critical to agile adoption with which teams struggle and for each area, give them the means to succeed via using an agile mindset.
Scott and I have both had our breakthrough moments and so have the teams that we have le
ad and coached. We share experiences from those teams to provide a real world context to the ideas. Most of what we have learned came from working with numerous teams and it is our hope that we continue the conversation with you. Please share your "A-ha!" moments on our blog so that we can all continue to learn together.
Being Agile (IBM Press)
Modified on by ScottWill
The goal of the Being Agile blog is to discuss what it means to be agile and help each other achieve the benefits that agile promises. Scott Will and I each were each introduced to agile software development in early 2007 when IBM hired Mary and Tom Poppendieck to train a few lucky groups in Software Group. Since then we had the opportunity to both practice and coach agile.
We learned that being successful with agile is no easy feat because agile requires continuous discipline, it requires focus in order to get something done, really done, and it requires that you work in a productive, interactive team environment to be productive. To succeed with agile we have learned that you have to think differently about planning and executing software projects, as well as reacting to problems. You can never become complacent and you must relentlessly look for ways to improve.
Modified on by ScottWill
Ever since our days in elementary school, we’ve been taught to fear failure. How many of us ever looked forward to going home on the day we received our report card and showing our parents the “F” we received for one (or more ) of our classes? Hopefully none of you ever experienced that, but was it because of the fear of failing that you did everything you could to ensure that you passed the classes you were taking?
Now think back to the days of the waterfall methodology in software development. Was there ever much worry amongst developers regarding failure of the project they were working on? Hardly… Most developers just did what they were told to do by the software architect, finished writing their code and threw it over the wall to the testers, and then went on to work on something else. Rarely (if ever) did they hear about how well customers liked (or didn’t like) the final offering since customers didn’t get their hands on the offering until months after the developers had finished writing the code, and there was typically a separate support team that handled any customer issues that came up after the offering was released. Additionally, most developers never interacted with customers (I even know of some organizations where developers were prohibited from talking to customers!).
Now, with the advent of Agile and DevOps, everyone is much more closely in tune with what customers think of your offerings – and this is a good thing! It clearly reflects the very first principle of the Agile Manifesto:
Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
The key word here is “valuable.” How do you know what you’re delivering to your customers is valuable? After doing some initial investigation of the marketplace, discussing options with current and potential customers, and doing some brainstorming within the team on creative ways to try to satisfy the needs, the best way to determine if what you’re creating is valuable is to deliver it! Put it out there – and see how your customers react. But, what if they don’t like it? Isn’t that just a failure…?
If you’ve adopted some of the main tenets of Agile, you’re likely delivering new features on a regular basis with very short intervals (vs. putting out a big bag of features once a year like in the old waterfall days). This is the “continuous delivery” that the agile principle above is getting at. Thus, even if you find out quickly that your customers don’t like something you’ve just delivered, it’s not a failure! You’ve just gotten some important feedback that you can immediately use to determine what needs to be changed, or perhaps determine that the new feature needs to be removed altogether. Being able to get quick feedback from your customers, and make quick changes to address the feedback you get (even if the feedback is unfavorable), is how you succeed.
In sum, put out small features on a regular basis. This allows you to get immediate feedback from your customers regarding the value of the features that have been delivered, and use your continuous delivery capabilities to make quick changes in response to the feedback. Like I said, even if customers don’t give you positive feedback, the feedback is still important so that you can respond quickly with better value. This is not failure – it’s the road to success! Thus the popularity of the phrase, “Fail fast, succeed sooner!”
As always, please feel free to ask questions and share your experiences. We look forward to hearing from you!
Modified on by ScottWill
In one of my blog postings just over a year ago I suggested that mature teams may not need to use Story Points. However, at the end of that post, I wrote:
[If] your team is fairly new to writing and sizing User Stories, or if your team doesn’t yet have an established velocity, I would recommend sticking with Story Points for now because the process of assigning Story Points (during a Planning Poker exercise, for example) is *very* helpful in aligning a team’s thinking, as well as building team synergy, as the team goes through the process of having the discussions that naturally arise when sizing stories.
(You can read the full post here: link)
What I’d like to do with this post is cover a few issues on how to make sure you’re getting the most out of using Planning Poker.
First, keep in mind that Planning Poker is meant to be a very simple and quick process to be used by a team for assigning Story Points to a given story. It’s not meant to provide absolute precision regarding the assignment of Story Points, and the assignment of Story Points itself is meant to be relative to the sizings given to other User Stories on your team’s backlog.
Next, because Planning Poker is an estimation technique please don’t assume that everyone on the team must be 100% in agreement with the number of Story Points being assigned to a given Story. Let me explain: typically, when a team uses Planning Poker to assign Points to a User Story, there will be a smattering of “votes.” As an example, let’s say that, after the very first vote for a given Story, there are a couple of 3's, a 5, a couple of 8’s, and a 13. The scrum master should ask why folks who voted 3 thought the size was relatively small, and then ask the person who voted 13 why he thought the size was relatively big (i.e., over 4 times the estimated size of those who voted 3). After a brief discussion, the scrum master should ask for the team to vote again. Let’s say this time there’s one 3, several 5’s, and a couple of 8’s. A good scrum master should say something like, “OK team, let’s go with a 5 for this story and move on to the next story on the backlog.” What the scrum master is looking for is “harmonic convergence.” Notice how, in the second vote, there were fewer 3’s and the 13 went away. The bulk of the votes were gravitating towards a 5, and so you can see the team is getting closer (“converging”) on a given number. Good enough! Don’t waste time by voting again, and again, and again, and again (ad infinitum and ad nauseum) until the team members all vote the same – it’s not worth it. Estimation is not meant to be precise, and spending more and more time trying to be precise with estimates is a waste of time.
And here’s the main point that I’d like to make – let’s say you’re one of the team members who voted an 8 for this story even though the number finally assigned was a 5 – should you be upset? Should you start an argument? Should you want to keep voting until everyone agrees with you and assigns the Story an 8? No, no, and no. Even though you may really think the story should have been sized at an 8, you can see the team was converging on a 5, so just let it go and press on. Planning poker is not a contact sport.
Finally, once teams get the hang of Planning Poker, most of them vote no more than twice on any given story, and they usually don’t spend more than just a couple of minutes per story. Here’s the high-level process:
Step 1. If you've not assigned Story Points to any User Stories on your backlog then, as a team, quickly pick out what you all think is the smallest story on the backlog and automatically assign it a 1. All other Stories on the backlog will be sized relative to this Story.
Step 2. Grab the next User Story from the backlog.
Step 3. Have a brief discussion about the Story regarding the anticipated effort relative to the first story (the story itself should be familiar to the team since, if the writing of the Stories was done correctly, the team participated together in the writing of the given Story).
Step 4. Vote.
Step 5. If there appears to be a fairly strong consensus on a given number, go with that number, and then go back to Step 2….
Step 6. Otherwise, if there’s a fair amount of disparity in the votes cast, then have another brief discussion focusing on asking those who voted with the lowest number, and those who voted with the highest number, to give some insights into their respective thinking.
Step 7. Vote again – you’ll likely see some harmonic convergence on a specific number after the second vote, and then just go with that number. Now go back to Step 2 (lather, rinse, repeat)….
In sum, Planning Poker is a great technique to use to quickly assign Story Points to your User Stories. Just be sure that the team doesn’t over-engineer its use.
As always, please feel free to ask questions and share your experiences. Leslie and I look forward to hearing from you!
“If you’re not better this month than you were last month, don’t tell me you’re Agile!”
I forget exactly where I heard that quote but it was from someone well known in the industry that came up during a webcast I was listening to several years ago. It caught my attention and helped me start to focus more on why Continuous Improvement is considered a foundational principle of agile. My research led me back to the Agile Manifesto, specifically to the principles of the Agile Manifesto where one of the principles reads:
“At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.” [emphasis added]
No doubt you’ve heard of, and hopefully engaged in, regular reflections (sometimes called “retrospectives”). If you haven’t done so, or have tried them and not gotten much value, then I’d like to provide a few ways to help make them valuable and to help you and your organization adopt a Continuous Improvement mindset. Conversely, even if you do regularly hold reflections and find them useful, the hope is that the following is something else you can add to your “bag of tricks” and make them even more valuable and compelling.
First, we recommend that reflections occur at the end of every iteration. These meetings are team meetings and shouldn’t take more than an hour (a half-hour seems to be fairly typical in our circles).
Next, the meetings are not meant to be “gripe sessions.” Yes, sometimes a little bit of griping can be cathartic, but the goal of a reflection meeting is more than just walking away happy that you had the chance to vent your spleen… The goal is to figure out a way to improve between now and the next reflection meeting.
The meeting facilitator should just go around the table and ask everyone to list the pain points that they’re facing. The facilitator keeps a list of all the pain points brought up and, after the last person has spoken, shows a list of all the pain points raised – ranked from those with the highest number of mentions down to those with the least. The item at the top of the list is what the team focuses on since that is the one that is having the biggest negative impact on the team.
Now that the biggest pain point for the team has been identified, the team brainstorms on some specific actions to take to improve in that one area and includes those actions as part of the iteration plan for the next iteration.
At the end of the next iteration, during the reflection meeting, the team determines whether that pain point has been resolved. If not, the team brainstorms on some additional actions to take in the next iteration. The key here is to NOT start trying to solve another pain point until the first one has been solved to everyone’s satisfaction. Once the biggest pain point has been solved, only then should the team move to the next biggest pain point on the list. Lather, rinse, repeat every iteration – and soon Continuous Improvement will be the norm…
I’ll have some additional suggestions in the next post. In the meantime, please comment on your experiences with reflections, as well as on any helpful practices you’ve discovered. Thanks!
Modified on by ScottWill
No doubt you’ve already heard about DevOps. What you may not be aware of is how DevOps builds on Agile principles and practices. For example, Software-as-a-Service (SaaS) projects have adopted DevOps in order to have the ability to frequently update their websites with additional features and capabilities. Some SaaS offerings are updating their production websites multiple times a day – which is a far cry from the once-a-year-release cycle that was rather typical for products built using waterfall.
You might be thinking to yourself, “Multiple times a day…? How does that happen…?” I’ll touch briefly on three essentials of Agile that contribute to this capability. The first is breaking work down into small batches and completing one small batch of work prior to moving to another. You’ll no doubt recognize this as a Lean principle derived from queuing theory. Simply stated, Lean has shown that small batches of work transitioning through a system are far more efficient than an occasional big batch of work. For our purposes, this means that having small amounts of code written, tested, and automated, where any defects have been fixed, and where any necessary user-documentation has been written, is far more efficient and productive than just having a large batch of code written that hasn’t been tested or documented.
The second point is Agile’s emphasis on “working software as the primary measure of progress” (see the 7th Principle of The Agile Manifesto). This ties in directly with the previous point – as small amounts of code are written, the goal is to get that code to production-level status as quickly as possible (“working software” that is “Done!”) so that the new code can be provided to customers with high confidence that it will work as desired, have the right level of quality, and help customers address a particular need.
The last point regards the tremendous emphasis in Agile on automation. With DevOps, the need for automation increases significantly because of the desire to deploy new features and capabilities on such a short timetable. Not only are builds and testing automated, but test environments are automatically provisioned, code that passes the automated test suite is automatically deployed into production and, if a problem occurs anywhere along the way, the process is stopped, the code is automatically rolled back, and appropriate personnel are automatically notified of the problem. The ultimate goal is to make a small code change, “push a button,” and have the new feature or capability automatically rolled out without any further human intervention.
No doubt you can tie additional Agile principles and practices to the DevOps initiative, but I thought I’d touch on just these few to show how DevOps is nothing more than a logical next step after Agile – they are not two, independent approaches to building software. As always, please feel free to share your thoughts! We look forward to hearing from you!
Modified on by LeslieEkas
Successful agile teams require timely leadership to help the team work together, make decisions and progress. A team leader may have a job associated with leadership like a scrum master, or a team leader may emerge when the opportunity presents itself. Making leadership work on an agile team requires that you learn to lead and to follow. Early in my career as a manager, I partnered with a leader from another team to design and build a new product. I was full of energy and excitement and I wanted my team to accomplish great things. However I was aggressive, a lot of the time. I was quick to pass out assignments, check on progress, and be impatient. My new partner had a very different personality and I noticed that she had a particular trait that I lacked. She was very good at working with teams in real time to solve a problem. I told myself to stop and pay attention. How does she do it?
She came to each discussion prepared. She did her homework in advance so that she had knowledge of the topic and often an opinion. At the beginning of the meeting she set the tone to one of knowledge sharing, respectful discussions, and decision making. She started by reviewing the problem at hand and made sure that everyone in the meeting was on the same page. And then the real difference came, when others offered their thoughts, she listened. I mean she really listened and paid attention to what they were saying. She would read back the thoughts to make sure that she understood and let the team know that she understood. She did not allow herself to get distracted. Her focus on a topic helped to keep the meeting on course. Her natural ability to hear everyone’s input and respond to it let them know their input was valuable. Finally, she was always calm. This was the deal breaker.
After watching her run very successful discussions, I paid attention to my own behavior. I worked harder to make sure that I came prepared. But when I disagreed with an opinion my heart beat would increase, and my impulse was to jump in fast and offer my opinion. That kind of rapid response can seem like an interruption and result in sparring. Sometimes sparring leads to successful results but it often discourages others from participating. Problem solving usually requires thoughtful debate and compromise. Pushing ideas back and forth allows teams to think together. But it is important to keep the tone to one of debate not sparring; otherwise good thinkers may shut down and not offer their input. What I learned to do was to fight the impulse to react and instead stay grounded and stay calm. Now when I participate in a problem solving discussion and that impulse to jump in strikes, I try to take a deep breath and wait to speak. I speak only after my pulse drops. This behavior has saved me many times because waiting allowed me to appreciate that my thoughts were not always well considered. Listening to others and leveraging their input enabled me to work out a more constructive comment.
I learned more from my old partner and many other leaders then they will ever know. Now, as a more mature leader, I have a set of personas, each of which is good at some aspect of leadership. Now when I get into trouble, I think, “What would she have done in this situation?” And I try her approach. My point is that some days you have to lead and some days you should follow and learn. As a leader, this is how you can foster the agile practice of continuous improvement.
Modified on by LeslieEkas
One of the primary reasons that agile teams are “more productive” is that they work together closely to complete small batches of work frequently and continuously. The better the team is at working together, the better their productivity. However, teams struggle to improve their ability to work together, and so this becomes one of the most significant barriers to real agile success.
If you think about how work goes in a typical waterfall project, usually the first thing that happens is that the team decides what they are going to do and then very quickly they split into separate sub-teams to do the work. Generally the team does most of its coordinated work at the end of the project when they have to make it all work. This is the "hockey stick" effect of waterfall. From my days in waterfall I remember long hours, nights, and weekends working through problems with the rest of team. In fact I remember reconnecting with people that I had not worked closely with since the last “end of project march.”
Agile breaks this pattern by working closely together from the beginning of the project. The “end of project” style of coordinated team work in waterfall happens throughout every iteration. This is what makes agile so productive. However, “getting there” can be hard because working where your domain knowledge and skills are the strongest is where you want to work and where you know you will be the most productive.
As the software industry has progressed, software projects have become larger and more complex. With size and complexity, specialization typically follows. We have been encouraged to specialize in order to capitalize on our personal strengths and then use those strengths to produce better product capabilities. Specialized skills are critical so that we build the right solutions. However, learning new skills and increasing your technical breadth is also important. To make an agile team more productive, team members needs to be willing to broaden their skills so that they can help the rest of team get to “Done!” in addition to completing their own work.
This does not mean you have to become an expert at everything or even offer your help when it is not needed. When I was in school getting my Computer Science degree, our professors told us that “You are not a <insert favorite software language> developer, you are a software engineer.” We have to remind ourselves that, as engineers, we need to continue to expand our skills and knowledge, and be willing to try any job that needs attention. If everyone on the team assumes this attitude, the team will become more productive.
Here is the analogy that I think of when I am trying to explain this behavior. In the movie Apollo 13, after the initial oxygen explosion happens and disaster ensues, the mission commander asks that his team leaders to call in everyone on their teams to help figure out how to get the crew safely back to Earth. In the movie, teams that have not worked together are given hard problems to solve fast -- and they do solve them. This is the way very productive agile teams work together throughout the project.
Modified on by ScottWill
A while ago I started working with a team that had stopped having “standup” meetings altogether. Initially, the team started with the typical daily team meetings. After a little while they moved from having daily meetings to having them only three times a week. Subsequently they went to just once a week. When I asked why they had decreased the frequency of their meetings, and then ultimately stopped having them altogether, I was told that no one thought they were very useful and some of the team members had already stopped attending.
At one level, I applauded this team – they had taken one of the Lean Principles to heart, that of “Eliminating Waste.” Their attempts at having daily standup meetings weren’t providing any value, so they just stopped having them. However, at another level, I faulted this team. They held daily standup meetings because that’s what they thought they were supposed to do since they were now calling themselves “agile.” In essence, they had adopted a practice without understanding why they were adopting it, nor did they understand what benefit the practice was meant to provide.
What I have found in my years of coaching teams is that when teams reduce the frequency of the daily team meetings (or eliminate them altogether) it’s usually because the meeting has become just a status meeting. And, seriously, who wants to spend time every day reporting status as well as listening to others report status…? What you typically hear in such meetings are things like, “I’m doing the same thing today as I did yesterday,” “I’m still working on my code,” “I’m still finding defects,” and so on. Ugghhhh – what a waste.
So, if it’s not to report status, then what’s the purpose of the daily standup meeting? It’s meant to be a coordination and communication meeting for the team. And this type of meeting is very important. However, there are a couple of other things to cover first before I can show how the daily standup will be valuable – instead of daily waste of time.
Leslie and I recommend that, as much as possible, a team should be working together on one user story at a time. Additionally, the work items that team members tackle as part of implementing a user story (typically called “tasks”) should be small in size (a day or two at most). This means that small amounts of needed design, coding, testing, user documentation, automation, and so forth are being completed on a daily basis. For example, a developer could complete a coding task and, as soon as the build finishes, a tester can start running tests against that code. Thus there is a lot of “parallelization” taking place every day within the team. Perhaps you can now begin to see how important regular (daily) team communication is in such an environment. Conversely, you can see how the daily team meeting devolves quickly into a status meeting if everyone is working on their own thing and there’s no shared goal for the team.
By working together on one user story at a time, and using small tasks to accomplish work, the daily team meeting becomes a meeting that you don’t want to miss because you’ll likely miss something critical to the work the team is focused on.
Modified on by LeslieEkas
Teams migrating to agile from waterfall have a significant learning curve to overcome, so they tend to adopt some of the easier to manage practices first (like the daily standup, time-boxed iterations, and reflections to name the some of the typical ones). If they do not tackle practices like regularly having working software, getting to "Done!" every iteration, and not accumulating debt, then the benefits realized will likely be somewhat minimal. Stated a different way, if a team's agile adoption does not produce some clear improvements in a timely fashion, then the team is not likely to make the effort to continually get better.
A sure sign of this "stagnant" situation is teams who are doing "waterations." Waterations are iterations that look like mini-waterfalls. They typically start with design in the first couple of days, then proceed to coding for a number of days, then followed by testing, and so on. Teams that operate this way don't normally get to "Done!" until the last day of the iteration (if they get there at all).
To get real benefit from adopting agile -- and make sure that it "sticks," teams should move beyond just the basics and continually look to adopt the more rigorous practices. For example, keeping debt at or near zero throughout a project, a concerted "whole team" focus where progress is measured at the team level instead of at the individual level, coding and testing being done throughout an iteration instead of being separated into phases within an iteration, having comprehensive "Done!" criteria and sticking to it, as well as others will help teams realize more significant benefits. We'll be addressing each of these topics in future posts.
Agile offers so many benefits but one of the most irresistible is the promise of higher productivity. Once you become more productive, how do you know that you are in fact, more productive? Most agile enthusiasts agree that highly performing agile teams move faster than traditional technology teams. There are many aspects to agile that provide improved performance including the practice of maintaining working software, queuing theory, eliminating waste and multi-tasking, whole team practices, and more. But given all these changes, how do you verify that it really works? I have been asked to “prove” that a team is more productive and our teams found a way.
During the intake process, each team estimates the size of the incoming request. I will call the request an “intake item” to avoid confusing the meaning of a story or an epic. Intake items can range dramatically from something that takes a team less than a sprint to something that takes a team many, many sprints. Our teams call the estimates, “SWAGs” to reinforce the idea that the estimate is an educated guess but still a guess.
I have seen teams that SWAG by dollar cost to do the work and teams that SWAG by approximate length of time to complete the work. Both methods seem to work but the important point is that the SWAG ranges are large enough to delineate typical work and reduce the error in estimation. So for instance one team could delineate SWAGs something like the following.
Small: less than $100,000
Medium: $100,000 - $500,000
Large: $500,000 - $1,000,000
XLarge: greater than $1,000,000
Similar rules that apply to user story writing also apply to making SWAG. Representatives of the team that will do the work estimates the SWAGs, the sizing is relative to other SWAG sizes, and once the SWAG is in place, they team does not change it. After the intake item is complete and rolled out into production, the item is marked as complete. The following shows a team that has used this mechanism for over a year.
The graph shows how many items the team completed each quarter standardized on time. It is quickly apparent that the team accomplished more each quarter. In other words, if the team size remains the same, then their productivity increased over time. It also shows that this team got better at doing really large items of work.
The next graph is another view of the same information but standardized on the number of items. That is, all items are the same size regardless of their SWAG size. This demonstrates that the majority of items completed are small.
The metrics show the results for one software product regardless of the size of the product or the size of the team building the product. We have tried this same approach with products developed by software teams that consist of one sprint team with less than 10 people. And we have tried the same approach with a larger team of over 150 people broken into many sprint teams. In all cases, we get consistent and believable results.
The value of this mechanism is that we show team productivity over time. Lines could be added to the chart to identify individual intake items. To add even more clarity we can associate real product deliverables to each of the items in the chart. This has proved to be a very simple way to validate that our migration to agile is having a positive impact. We typically combine this view with quality metrics to ensure that we maintain high quality as we increase output.
Modified on by LeslieEkas
Agile teams can move the needle on large software projects once they are cross-skilled and can pull from the same backlog. I have seen this several times and the results are amazing. The overall throughput from backlog to production increases because the value provided by each team member increases and high priority backlog items don’t get log jammed.
To get the higher throughput that agile promises, teams are encouraged to become cross-skilled so they can do any kind of work in any part of the code base. This enables them to work together better as a team and tackle the most pressing needs that arise versus waiting for a skilled team to be available. Once teams are cross skilled, they increase their throughput because they are not limited in the backlog items they can do. And it works. But be warned that the team will actually slow down at first because they need time to learn. They may slow down for several months depending on the size of the code base and the team’s ability to absorb new domain knowledge and skills. But they will start to speed up.
It can be a tough sell to move to this type of team organization from a setup where teams had backlogs specific to one part of the code base. That is because stakeholders often have what they consider to be “their own team”. That is, teams often work within a particular part of a larger code base and consequently they have their own backlog. Product owners understandably love this because they can get “their” critical work done. But at the same time, they want “more” work to be completed.
Moving teams to be cross-skilled may be a hard sell to the teams and the stakeholders because it is a very new way to work for both parties. And since the transformation takes time, it will be important to validate the improvements once teams actually are able to accomplish more. Once they are cross skilled, multiple teams can work from a single backlog because any team can take the next item in the backlog. This enables them to move work around as teams are available. This is very good news. Order the backlog by priority and have highly skilled teams work their way through the backlog.
But… that means that “my” item has to compete with other items in the backlog. That did not happen in the focused team style. Once teams work from a single backlog, stakeholders have to work together to prioritize their items into a single backlog. And they will find that some of their items do not find their way to the top. What does that say about those items? Maybe teams were doing the work “they could do” but it may not have been the most valuable work across the code base.
With cross-skilled teams, you are getting “your stuff and fast”. And it is “the stuff” that stakeholders agree is the most valuable. Once you get there, you may have to find a way to show your stakeholders that they are getting a better result.