The Five Whys

I’ve recently finished re-reading Lean Start Up and a chapter that has been great to refresh is the Five Whys.

It sounds fairly straight forward – a technique which allows you to perform a root cause analysis. Ask “Why did that happen?” five times, to get to the root cause of the problem.

Asking the five whys sounds simple, but in practice, it is very difficult to find that root problem consistently.

Having been through the processes a few times, I’ve noticed:

  • It is very easy to go off on tangents
  • Not have all the information at hand.
  • People tend to focus on coming up with actions as soon as possible, in an attempt to “solve a problem”, and worse, appease Management / Executives.

In most scenarios, I’ve noticed they are actions to solve symptoms and the problem shows up in other forms down the track. Some key reminders for I’ve use during such a process:

1. A very important part in performing the five whys is to perform the session with everyone involved in the room. No proxies, everyone involved with the issue, client facing, technical staff, everyone. This is critical. Perception and roles missing from the analysis can miss the root problem, or fall short.

2. Ensure someone is identified as running the meeting. They are in charge of moving past the noise, avoid going off track and drilling down.

3. The outcome is not to identify actions, but to identify the root cause.  Managers / Executives should ensure this when actions are presented after the analysis, do the actions address the root cause?

4. Actions can make it feel like you are solving the problem, so typically I prefer to address actions at the end of the session.

A great example outlined in the book was:

  1. A new release broke a key feature for customers. Why? Because a particular server failed.
  2. Why did the server fail? Because an obscure subsystem was used in the wrong way.
  3. Why was it used in the wrong way? The engineer who used it didn’t know how to use it properly.
  4. Why didn’t he know? Because he was never trained.
  5. Why wasn’t he trained? Because his manager doesn’t believe in training new engineers, because they are “too busy.”

Nicely illustrates the “human problem” behind every technical problem.

Outputs v Outcomes

We know software development industry is focused on solving problems. Customer problems. User problems.

Better, faster, cheaper.

There is a great article in the Harvard Business Review on Outputs v Outcomes:

https://hbr.org/2012/11/its-not-just-semantics-managing-outcomes

Outputs are features.

Outcomes is true value delivered.

We aim for our outputs to deliver outcomes, its treated as an abstraction. The problem in most cases is, development teams treat outputs as the end goal, and build release plans, and sprints on getting that “feature” out.

We don’t talk enough about the problem we’re solving, the outcome we’ve aiming to achieve, and even more so, measure whether we achieved the outcome.

I am not a fan of measures such as “Increased usage”. Thats not an outcome.

An great example I’ve seen in building Recruitment software is Time to fill (TTF). TTF is the time it takes to fill a vacant seat from when the request is made. TTF directly translates to Cost to fill, which is a measurable impact to the company.

For a recruitment team, Time to Fill is THE KPI they are measured on.

So rather than building a feature or product we “think” will improve TTF, measure it, try different ideas, and keep trying until you find something that gets your outcome.

None of this is groundbreaking, all we’re doing is ensuring we connect our problem solvers (product teams / developers) to our users. It is fundamentally Agile.

Contextual Craftsmanship

For many years, I’ve spoken to friends, colleagues, mentors/mentees about craftsmanship and how important it is in Software Development.

As a software developer, it is very easy to agree with. Quality is not negotiable, write your tests first, blah blah blah. We understand how important design patterns, readable, maintainable code is, especially in building sustainable software.

One aspect that I find isn’t spoken about explicitly enough, is Contextual Craftsmanship. We all know there is no silver bullet, and hence I find that craftsmanship is very similiar. There is no correct way to develop, and it depends on what you are doing, and the business context you are in.

A start up context is very different to an enterprise. Code built in a hack-a-thon is very different to a system in which a bug can literally result in life or death (ie Software for planes or medical equipment).

I am lucky enough to have experienced many of those contexts – and I’ve assumed developers are aware of this; people will change their approaches.

But as I mentor developers, and work with large development teams, I recognise the line is not always clear for everyone. The need to discuss the context explicitly is very important.

Is this a Spike / Proof of Concept that will be thrown away?

Is this an MVP to gain insights and validated learnings?

Are you building a business critical service for a Fortune 500 company which requires 99.95% uptime?

Craftmanship depends on the context.

Have the team agree on the approach; the level of quality, reliability, maintainability, DR, etc.

It is fundamental for the team to be on the same page, but it is just as important to ensure your stakeholders align to this.