Tagged: Improvement

RAPID Agile: Customer Focus – Defect Management

Before we dive back into defining an approach that mixes Product and Custom focus, we should probably ask “How does one focus on the customer?”

In an ideal world there are no defects; but since there are, and customers expect them to be resolved, an ideal approach balances itself between being proactive and reactive; proactively resolve reported/discovered defects and appropriately manage escalations. On the surface, one focuses on the customer by making sure that the defects are fixed before a customer reports them and if a customer reports them, they are addressed promptly (top priority of course) and the customer is satisfied – below the surface, defect management and prioritization play an important role towards our customer focus as this tells us how soon we can (and will) actually resolve defects.

The list below doesn’t capture all possible approaches in resolving defects; it captures approaches that I have had some experience with (I recommend that you certainly do not try the first one):

  1. Don’t resolve them
  2. Push the defect to the original developer, or the developer most familiar with the functionality for resolution.
  3. Allocate time for the first available developer to pull a defect in and resolve.
  4. Have a defect duty rotation where a person (or team) resolves only defects for a time period
  5. Have a dedicated team for defect resolution.
  6. … Some other create ways to resolve reported defects..

Always push to most familiar
Pushing the defect to the most familiar sounds like a great idea and in many cases it is because the one most familiar would be able to resolve quickest and positively impacts customer experience. The issue with this approach is that the most familiar person might be involved with something that has a higher priority than this defect, or is out on PTO and would not be able to resolve for another 2 weeks. Let’s say it takes someone familiar with the code to resolve in 1 hour but takes someone not familiar with the code 6 hours. If the defect goes to the person currently tied up and is most familiar, the customer will have to wait a minimum of 2 weeks + 1 hour; however, if it goes to the person not currently tied up and is least familiar, the customer will have to wait a minimum of 6 hours. Being collaborative and available for the team may improve the turnaround time on average, but a hard coded “always send to the one who created it” may not be the best approach.

Allocate time to pull
Allocating time towards the end of an iteration, development or whatever, towards “defect resolution” allows the team to first get the scheduled work out of the way, and “if” there is time, someone may pick something up from the backlog of defects. The issue with this approach is that if the development cycles are fully booked (maybe there is a hard date) and there is any risk or complexity that might lead to developers putting in all they have to meet the delivery; defect resolution gets thrown on the back burner. In most cases where the approach is “allocate time to pull defects”, the unspoken rule is that new products come first, defects second – unless; where the “unless” is for escalations and chaos/fire-fighting instances. For agile teams, if the time allocated towards defect resolution does not change from sprint to sprint, then there is no impact to velocity; however, if the time allocation is not fixed the velocity can get impacted depending on how much time is spent on defect resolutions (usually hours) vs. features (SP’s)…. You could estimate defects in story-points but this can lead to additional issues that will need to be worked out… i.e. do you really want to hold a sprint back? etc..

Defect resolution duty rotation
For a given time (usually the span of a sprint) a developer within a team, or a whole team themselves will be on defect resolution duty; once the time span is over, someone else (or a different team) takes on defect resolution duty and so on. This helps cross-train and helps make everyone familiar with the code base. It can also help improving code quality since everyone is learning from everyone’s mistakes and provides a great collaboration platform; while it does have some great benefits it does introduce some challenges. A significant issue is that developers and teams lose traction as they switch focus from “new product” to “old product”; the interruption can cause a delay since the developer(s) will need to get back to where they were after the rotation is over. For organizations that have many teams or larger teams this may be less of a concern since the rotation might happen every few months; but even then, when it does happen it does have a negative impact.

Dedicated team for defect resolution
The thought on this one is that if there is one team solely focused on supporting “released software” (defect/engineering sustaining team) and other team(s) focused on creating “new software” (Feature teams) that you end up with a two-tiered development approach where both the product and the customer can be focused on. The feature (new software) team is rarely impacted by defects from the “live” world and they can always focus on delivering new product; the defect/engineering sustaining team is dedicated to resolving defects and is not tied up with new features. The issue with this approach is that no one aspires to be a “defect fixer”, developers want to “develop” new and innovative “features” (or at least I did); It is possible to make this work if more attention is given to down-time cross-training, root cause analysis, collaboration, role rotations, etc… (I have seen teams evolve this approach into a “defect resolution duty rotation” approach)

In addition to the above, there can also be hybrid approaches that mix various approaches, i.e. defect resolution duty rotation with an added “pager duty” where someone (not on defect duty) is on-call but in general there is no “incorrect approach”; however:

Any approach can become incorrect when developers are forced to accept an approach that they do not agree with (or understand).

Any approach that is going to be implemented should be discussed with the teams that will be implementing it, focus on and explain the “why”. When an approach does not work, try to adjust it or try something else!

“if the code repository is an “elephant” and new code is peanuts being fed to this elephant by the other guys, then I am always cleaning up after the elephant; who wants to be a shit cleaner forever?”.

Advertisements

Horizontal Management – Maintaining momentum: Keep progress moving

While machines might give the same level of output everyday, the same doesn’t apply to people.

In a real environment, each member’s momentum and motivations will change without notice. This requires management to step in and make sure they are constantly evolving the processes so that members will remain motivated. Leadership is important to motivate key players, channel information to keep everyone engaged and make working horizontally routine. To accomplish this, management might bring in an outside champion, who will help wring in new ideas and “fresh” stream of motivation. Instead of looking at a project as a whole, it should be broken down into smaller goals that are realistic and achievable. Management should encourage and build on small success, to demonstrate that it was an important milestone and motivate members. Progress and results should be demonstrated so that members can all acknowledge the ongoing progress and success.  Management can keep the members interests by ensuring that they are always focused on achieving the goals that were set, and if deviation is detected, corrective action is taken to bring things back on track.

A horizontal team is dynamic as it is always changing, management needs to account for its dynamic nature and make necessary adjustments to accommodate/adapt to the change. Money is probably the best motivator, but too much money too early in the process can hinder individual initiative and prevent people from innovating. Since horizontal structures focus on team collaboration, a downfall is that meetings can go on forever and schedules can be missed; this can unmotivated some members who feel that decisions are not being made in a timely manner, which is why management can implement deadlines which will help practitioners develop a common schedule and manage workloads effectively so that the projects momentum is kept at a steady pace.

[Source: Moving from the Heroic to the everyday: Hopkins, Couture, Moore]

Horizontal Management – Building support structures: To keep Horizontal team in check with Vertical roles

Even though a “horizontal structure” is flat in nature, it does still need a (vertical) support structure.

The main purpose of a support structure is to help managers build lasting relationships and achievements with teams. There are two basic type of support structures that managers can mix and match when building or working with teams, depending on the requirements as each has its own attributes.

  • Informal structures don’t define rigid roles and responsibilities, they are open to interpretation and people can define their own roles and swap roles as needed, hence they are less resource intensive, more flexible and less binding on members; Informal structures help promote open discussion and communication among its team members; and
  • Formal structures are more rigid and roles/titles might be defined where members have specific responsibilities; this makes them more resource intensive but less ambiguous; they require some logistical skill and expertise to implement. These structures are great when consistency and quality are important factors.

It’s important for management to recognize what type of structure needs to be in place and when its put in place; as “when” a structure is erected, it can play an important role in the success of the teamwork initiative. If too much formality is introduced early, people might feel there is no difference in the “horizontal structure” and the “vertical structure” where vertical structures are rigid, formal and bureaucratic and would be less motivated to work with the initiative. In contrast, waiting too long to build a support structure or the lack of a support structure can hinder the ability of the team to successfully work together as a team, especially when they need to be able to adapt when in tight spots.

Since the resources and effort required are greater when setting up formal structures, informal structures are great for short projects, however when the projects will go on for a long period of time or are of large scale, formal structures would be more suited as they are less ambiguous and will stay well formed longer (as they are more solid than informal structures).

Authority and roles in informal structures are more ambiguous and can be swapped around; In formal structures, the roles and responsibilities are more definitive, hence less ambiguous and in that regard, formal structures would work best in situations where important decisions need to be made.

[Source: Moving from the Heroic to the everyday: Hopkins, Couture, Moore]

Kill the (process) champion

This isn’t anything new: Individual or a group of individuals (champions) see the benefits of process improvement, understand process improvement, and want the organization to benefit from process improvement by implementing process improvement. – What a novel idea.

In order to successfully implement and benefit from process improvement, its imperative that management sponsors the process improvement initiatives/activities. If management, or (in a smaller company) the owner does not see or understand the benefits of process improvement the truth is that it will never be successful.

Champions who try to implement process improvement by themselves will lose the motivation for (process) improvement along the road as they get busy with tasks and other responsibilities; this is especially true when they are going to be the only ones who are making the effort.

For example, an individual (software developer) trying to sponsor process improvement themselves to their own work, working for a company that has no form of formal requirement gathering or does not follow a software development model will soon get tired of putting in the effort (to gather requirements formally) as it will go unnoticed and unappreciated (maybe even criticized).

There might be even cases where the organization is so small (agile would work great here) that it would be impossible to place a “formal” process improvement methodology or cases where the organization feels that the processes they have right now are “perfect”; even though they might not be.

To determine if process improvement is required we can use the history of how well past projects went, under budget, over budget, issues that were faced and so on. We can also measure certain things and create actual results that tell us how good or bad our current process actually is.

Image

It is always easier to explain your point to upper management when you have actual data and visuals such as charts that can be analyzed and used to substantiate your point; this is where measurements come in. Measurements themselves can be a complex and important tool that can be used in process improvement models such as CMMI, but it is not until level 2 and 3 (in CMMI) that you actually get to make use of those measurements. At some point (idea for another post) I will discuss how quick and dirty measurements can be put in place without too much of a hassle (and measure process without process). Not everyone is a “process” person and fail to understand the importance of process (and a formal SDLC).

Many will however understand results obtained from the measures when they are presented and used to talk about costs, budget, resources and timeline’s.

Making Changes: Change Cycle

To stay ahead (or on top) of the game, we must recognize that change is good and that we must be continuously improving the way we work. While reading a book “90 days” I realized that I had been through these stages multiple times, fortunately walking away successful. It also made me realize how close I was to a possible failure in some of the changes I had made and because of this realization; the Change Cycle will always be on the back of my mind when I attempt to drive Change.

I took the concept that was in the book and modified the terms as it was easier for me to relate the “change cycle” to something I already knew, the “process cycle”.

Here is what I do and have to say about process:

Good process should be well tailored to the organization that intends to benefit from it. Process is much easier to implement when its implemented in stages based on a feedback loop; When improving or introducing process, a big concern is usually how fast and how much? Well, too much too early generally results in resistance to change and too little too late results in process loss.

So what should be done?

A rapid agile approach should be taken when implementing process. Process is implemented and/or improved when the lack of process has been identified. Once an idea of what process needs to be implemented has been formed, the cycle starts with

  • Introducing the process as a pilot, if the pilot is successful
  • It should then be verified that it’s repeatable. If the pilot is successful and repeatable
  • It should be formally defined and shared among the team as the formal process.
  • The process should now be managed and measured to obtain metrics to figure out how successful it is, its ROI, etc. These metrics should then be used to
  • Optimize and continuously improve the process.

The concepts of the “process cycle” for introducing a process are very close to the concepts of a “change cycle” for introducing a change.

In a change cycle, you:

  • Introduce a change and if the introduction of the change seems successful you then
  • Maintain the success to obtain stability. Once stability has been insured you
  • Optimize and introduce other changes as needed; this is your optimal success cycle.
  • Should the change not be maintainable, you will need to
  • Adapt the change to make it maintainable; this is the adapting cycle.
  • If you cannot adapt your change to be maintainable, you might have to
  • Change direction and counter the change; this is the Counter cycle.
  • If the change cannot be countered and be made maintainable, you will end up with a failed change. You can also end up with failure if your introduced change is not successful. A change can easily be unsuccessful if it’s too large; rubs people the wrong way, inappropriate, incorrect, etc.

Sometimes we start in this cycle at a completely different stage, for example we may realize that we have inherited a change put in place by someone else (different team, a VP, etc.) and we now need to act and adapt their request, or counter the change, making it successful. The 90 days book does a good job of giving a more general view of the change cycle; for me, the stage comparison of the two cycles makes sense.

The change cycle for making changes is just a small piece of the puzzle. How you go about obtaining buy in from your team, peers, and higher ups is another big part of the puzzle that will either result in success or failure. That will be a topic for another day.