A recent discussion on the Scrum Alliance Linkedin group was around Mike Beedle’s claim that “Hard-coded Frameworks are neither Agile or Frameworks” which is clearly aimed primarily at SAFe.
I admit to thinking something similar before really getting to know SAFe in depth. Over time I realized SAFe isn’t one size fits all. Far from it.
It has many configurations and options. Do we need the Value Stream level? a System Team? at which level? How many ARTs? Component teams or Feature teams? Which metrics? Which ART to start with? Even if you don’t follow my Invitation-based SAFe implementation approach that is now a formal SAFe guidance article, you still have a lot of options at all levels and it is hardly a hard-coded methodology. Yes, not all practitioners understand this. But that’s a familiar problem from the Scrum space isn’t it. “Though shall do tasks”. “Though shall estimate in story points using planning poker”. “Though shall stand up in the Daily Scrum”.
Scrum was and is a powerful tool. SAFe, Enterprise Scrum, Nexus, LeSS, Kanban and others are powerful tools as well. A powerful tool is typically also dangerous at the wrong hands or the unexperienced hands without good guidance.
Besides – it IS funny to hear about the danger of force-fitting a hard-coded framework from leaders in the scrum community that have been telling us about SHU and following practices and the danger of scrum-but all along. And rightly so! Sometimes you do need to insist on a practice/change even if it feels hard! Agile IS about challenging your comfort zone.
Can we all agree that the real art/expertise is to figure out the right set of practices that is the goldilock between too much force-fitting and too-easy “common sense that is somehow too close to the status quo”?
(Updated) Oh – and also can we also agree there’s a huge difference between force- fitting practices to challenge your comfort zone (which is healthy change management done right) and forcing people to do something vs inviting them to consider trying it?
I met Benjamin Spector in one of the recent Agile Boston meetings. He told me a story that I liked a lot since it brought to life one of the key concepts I presented – The Transaction Cost vs Cost Of Delay curve (from Principles of Product Development Flow by Reinertsen). I was able to persuade Benjamin to write up this story…
Waste Deep in Being Done – Or…Why it’s Shorter to Take Longer
“We should have finished a month ago.” That was the item with the most votes during the team’s last sprint retrospective. This last sprint completed the final production-ready feature the team had been working on. It was delivered just in time for the scheduled annual major product release. Everyone was decompressing from having faced the possibility of delivery failure. But even as we celebrated our success, there was a sense of disappointment that we had taken as long as we did.
I had been the team’s scrum master for about 6 months, starting up with them as this latest project began. The team was small with 4 developers (3 full-time software engineers and 1 QA specialist) plus a product owner and a scrum master…me. When I started working with them, the team was practicing scrum at a beginner-level. My initial focus was mainly on getting the team to perform basic agile practices more effectively for estimating and planning, as well as for daily standups, sprint reviews and retrospectives.
Over the course of the project the team was dealing with regression failures that came back to them 1-2 weeks, or longer after their original code submissions. The problem was not terribly taxing on the team in the early stage of the project. We’d get 1 or 2 regression failure bug tickets and just included them in the next sprint backlog to fix them. Sometimes we didn’t get to fixing a regression failure until 2 sprints down the road. It didn’t seem like any harm to kick it to another future sprint. It was tolerable…or so it seemed.
The team’s practice was to submit production-ready code after running a suite of “smoke test” regression tests. The product itself was a complex CAD tool with over a million lines of code and up to 25,000 separate automated regression tests. Running the full suite of tests was an overnight process. Whereas, running a smaller subset of selected regression tests that focused mainly on the part of the code base the team worked in was a common practice among all our scrum teams. It allowed for quicker turnaround. In general, it was felt that running the regression “smoke test” suite enabled everyone to deliver quicker at a relatively low risk to the product quality. If a couple of regression failures slipped through the net, no one thought it was a big deal. In fact, this practice was explicitly called out as part of my team’s definition of done for user stories.
But, the frequency of regression failures began to increase. As we got closer to the release deadline, there were more regression bugs to fix, and the time spent fixing them consumed a greater portion of the team’s capacity. As the scrum master, this issue did not go unnoticed by me. I wrestled with the question of when it would be the best time to raise it to the team. We were within striking distance of our goal and the team was focused on finishing the project and complying with all the acceptance criteria for the project. Significantly, one of those criteria was delivery with zero regression failures.
About a week before we finished the project, I began reading Jeff Sutherland’s latest book “Scrum: The Art of Doing Twice the Work in Half the Time.” I came to the chapter called Waste is a Crime, and a section called Do It Right the First Time, and the words leapt out the pages. Sutherland gives a powerful example with Palm Inc.’s research on the amount of time taken to fix bugs not found and fixed right away (page 99). The research showed that it took 24 times longer to fix a bug a week or more after code submission, than if it was found and fixed at the time the developer was actively working on the code, regardless of the size or complexity of the defect. 24 times!
So there we were at the end of the project, with everyone experiencing the elation and relief of a successful delivery mixed with a sense of disappointment that we did not finish as quickly or as cleanly as we had expected. “We should have finished a month ago.” Why didn’t we?
It was at this moment that I jumped up and said, “hang on just a second. I’ve got to get something at my desk that will be really interesting for everyone to hear.” I bolted out of the conference room, ran to my desk grabbing the Sutherland book, and returned slightly breathless with the page opened at the passage describing the Palm Inc. research about bug fixing taking 24 times longer. The gist of the Palm Inc. story was about one and half pages long, so I asked the team’s permission to read it aloud before we continued with our retrospective discussion. Everyone agreed with some amusement and curiosity about what I was up to. When I finished reading the passage, I could see the impact in the eyes of every team member. Each member of the team began looking at each other recognizing this shared insight. That’s the moment when I knew I had their attention.
I put the question to the team, “How many regression bugs have we fixed since we started this project?” The answer was 35. I had already sized the problem when I began monitoring it closely over the last 3 sprints. I quickly showed them my query in the Jira database, displaying the search criteria and the tally of regression bugs on the conference room overhead projector. Everyone agreed that it was a valid.
Then I asked, “On average, how long does it take us to fix a regression bug?” We started opening up individual records so we could see our tasked-out estimates for each one. Examples ranged from 8 hours to 16 hours typically including tasks for analysis, coding, code review, adjustment of some of the tests themselves to accommodate the new functionality, submission for regression testing and final validation. Some took a little more time. Some took a little less. After a few minutes of review, the team settled on the figure of 12 hours or work per regression bug. So, I did the simple arithmetic on the white board: 35 x 12 = 420 hours. Then I applied the “24 times” analysis: 420 / 24 = 17.5. I said, “If the rule holds true, then if we had fixed the regression bugs at the time they were created, in theory it would only have taken only 17.5 hours to fix them, not 420 hours.” Then I doubled the number just to make everyone a little less skeptical. 35 hours seemed more reasonable to everyone. Nevertheless, it was still a jaw-dropping figure when compared with 420 hours. While I stood pen in hand at the white board, everyone on the team sat in stunned silence. While they were absorbing the impact of this new insight, I took to the whiteboard again and wrote down 420 – 35 = 385 hours. Then I reminded them of our sprint planning assumptions. “Based on our team’s capacity planning assumptions, we plan for 5 hours per day per person for work time dedicated to our project. For the 4 of you that equals 100 hours per week of work capacity.” I completed the simple arithmetic on the white board showing 385 / 100 = 3.85 weeks, underlining and circling the 3.85 weeks. Then I pointed back to the retrospective item with the most votes, I said, “There’s your lost month.”
When our retrospective ended we left the meeting with a significant adjustment to our team’s definition of done. We replaced the “smoke test” regression testing requirement with the practice of always running the full regression test suite on the code submitted for a story and resolving all regression failures before considering the story done. This change was made with the enthusiastic and universal agreement of every team member. Everyone recognized that it would take longer to finish each story up front. But, they were happy to accommodate the extra time because now we all knew, without even the slightest doubt, that even though it would take longer to finish the story the first time, it was always going to take a lot less time than having to go back and really finish it later.
Benjamin Spector has worked as a software product development professional and project manager for over 20 years. For 4 of his last 9 years at Autodesk, Inc., he has worked as a scrum master for several teams and as a full-time agile coach introducing and supporting agile practices throughout the organization. Reach out to him on Linkedin
“This format is amazing. All workshops should run this way”.
This is the comment we heard from a recent participant of our recently created Agile Boost Camp format. In this workshop we run a truly agile-style 2 days where the participants pick and choose topics they want to address. We adjust the plan along the way, we ran short timeboxed Pomodoro style sprints and consider next steps after each. Continue reading “So What Is The Agile Boost Camp Workshop?”
Once people start to get “Stop Starting Start Finishing” thinking (Kanban) or the “Focus on the current sprint” thinking (Scrum) a frequent question that comes up is how to deal with people who are required for different activities throughout the work life cycle.
Some example scenarios:
“I’m a tester who both participates in ATDD spec. workshop (upstream) and exploratory testing (downstream). The developers are free to start a new story, should I help them with the ATDD thinking for a new card or focus on finishing the one I’m working on?”
“I’m a developer who both analyzes new stories (you might call it backlog grooming if you’re a scrum team…) and develops them. I see our backlog of ready stories is running low – should I continue to work on my story or should I move to analyze some new ones?”
Stop Starting Start Finishing talks about finishing things and minimizing the waste of inventory. It seems to say always prefer to finish and not starting. Why would we even consider a different approach? And indeed on some rare teams it is reasonable to work in a pure “One piece flow” mode where we focus on one thing, finish it, and then move to the next. But this requires a very high level of collective ownership and collaborative concurrent engineering. This is seldom the starting point and rarely an early achievement of teams trying to set up a more healthy flow of work.
So in the majority of the teams the challenge is that in order to maintain healthy flow people are typically working on different things. And when the work process of these teams is such that it requires different members of the team to take part in the work in separate areas of the life cycle so they have to touch the work, leave it, and return to it, we have an issue. Maintaining healthy flow is now in conflict with Stop Starting Start Finishing because you would typically always have something to finish, so when are you going to move left on your board or go to work on things related to your next sprint?
• Value trumps Flow – Expedite at the expense of flow to maximize value
• Flow trumps Waste Elimination – Increase WIP if required to maintain flow even though it will add waste
• Eliminate waste to improve efficiency – Do not pursue economy of scale
So based on the filter what we can deduce is that if we need to start something new in order to maintain flow then this is what we should do even if it is a potential waste since we could have focused on finished something.
BTW In a lot of scrum teams this manifests as the heuristic to spend 10% of the team’s capacity on preparing for the next sprint.
A way to decrease the waste of context switching while maintaining flow is to use an ongoing cadence. For example hold specification workshops or backlog grooming sessions at a regular time each week. This minimizes the impact of the context switch since it provides some heads up for people instead of surprising them and pressuring them to move to something else (otherwise the rest of the team will be idle…).
Bottom line – one of the first steps to really getting Kanban/Scrum is to start thinking “Stop Starting Start Finishing”. But the Lean Decision Filter helps us apply the required common sense to real world situations where this seems to be in conflict with effective flow – which is actually what we are striving for.
Do you see this problem in other forms? Did you find other ways to rationalize the right thing to do? Do you have other tips/suggestions to people facing this problem? That’s what the comments are for…
How can we make promises we can keep without a commitment to the sprint content?
So I convinced you that the Scrum Sprint Commitment is not such a great idea. I convinced you it is mainly there for learning. You want to move to a commitment to try to meet the forecast instead of committing to deliver the whole forecast. But your Product Owner has a real problem with this. He understands all this learning rationale but his stakeholders want to know whether he can promise then a certain delivery on a certain date. So can we make promises without the Sprint Commitment?
Making promises to deliver certain backlog items in this sprint
Sometimes a Scrum team is expected to deliver certain backlog items for a specific sprint. Examples can be stuff other teams need to consume, a fixed date commitment to clients, a regulatory requirement etc. Such backlog items have a very high cost of delay so we want to really make sure when we promise to deliver them we deliver them. One way to make sure that is to put them at the top of the Sprint Backlog. If the team is working down the Sprint Backlog by priority (as they should) there is a higher chance they will deliver these backlog items.
But I believe we should be more explicit. We should have a clearer signal that these are special fixed-date items and clearer policies for what to do to make our promises around them. In Kanban teams use classes of service for this purpose. I recommend Scrum Teams in such a context simply do the same. Mark these items with a special color in the Backlog. Establish policies such as “If they are in danger we make whatever effort needed to deliver. Sustainable Pace will be put on hold”. Visualizing that these items are different will earn them a different class of service by the team. It also means that normal items without this fixed-date commitment might be put aside to make the extra effort to deliver those, even at the price of overall throughput. These items might call for deeper estimation and planning up front than normal items.
One key point is to make sure that these fixed-date items are not the majority of items in the Sprint Backlog, otherwise they cannot rely on preferential service. If you have a case of your whole work being fixed-date driven you need to be extra careful with planning and consider taking a time-buffer to protect against the inherent variability in sprint results.
With time the Scrum Team and Product Owner will learn about their ability to deliver these items and might be able to make promises earlier before the Sprint Planning, knowing that the price will only be the effect on other normal items in the sprint.
Making promises to deliver on a bigger project across several sprints
I won’t go deeply into this aspect in this post. Normal Agile Release Planning using history of throughput/velocity and setting hard commitments and soft commitments is the way to make promises you can keep. This means that within each sprint there will be a certain level of hard commitment related to the overall project hard commitment. If that level of commitment is already a stretch for the team then you have a dangerous project in which you cannot really expect to have safe-to-fail thinking or improvement, rather a tight focus on meeting commitment. Sometimes we have those projects. If you are always doing these kinds of projects time to look in the mirror and have a discussion about whether you are really trying to set up the organization for opportunities to improve/learn or just constantly meet commitments without any slack for improvement.