Feature Risk
Feature Risk is the category of software risk to do with features that have to be in your software. It is the risk that you face by not having features that your clients need.
In a way, Feature Risk is very fundamental: if there were no feature risk, the job would be done already, either by you, or by another product, and the product would be perfect!
As a simple example, if your needs are served perfectly by Microsoft Excel, then you don't have any Feature Risk. However, the day you find Microsoft Excel wanting, and decide to build an Add-On is the day when you first appreciate some Feature Risk.
Not considering Feature Risk means that you might be building the wrong functionality, for the wrong audience or at the wrong time. And eventually, this will come down to lost money, business, acclaim, or whatever else reason you are doing your project for. So let's unpack this concept into some of it's variations.
This is the one we've just discussed above: the feature that you (or your clients) want to use in the software isn't there. Now, as usual, you could call this an issue, but we're calling it a Risk because it's not clear exactly how many people are affected, or how badly.
- This might manifest itself as complete absence of something you need, e.g "Where is the word count?"
- It could be that the implementation isn't complete enough, e.g "why can't I add really long numbers in this calculator?"
Feature Risk also includes things that don't work as expected: That is to say, bugs. Although the distinction between "a missing feature" and "a broken feature" might be worth making in the development team, we can consider these both the same kind of risk: the software doesn't do what the user expects.
(At this point, it's worth pointing out that sometimes, the user expects the wrong thing. This is a different but related risk, which could be down to Training or Documentation or simply Poor User Interface and we'll look at that more in Communication Risk.)
Regression Risk is basically risk of breaking existing features in your software when you add new ones. As with the previous risks, the eventual result is the same; customers don't have the features they expect. This can become a problem as your code-base gains Complexity, as it becomes impossible to keep a complete Internal Model of the whole thing.
Also, while delivering new features can delight your customers, breaking existing ones will annoy them. This is something we'll come back to in Reputation Risk.
Sometimes, users swear blind that they need some feature or other, but it runs at odds with the design of the system, and plain doesn't make sense. Often, the development team can spot this kind of conceptual failure as soon as it enters the Backlog. Usually, it's in coding that this becomes apparent.
Sometimes, it can go for a lot longer. I once worked on some software that was built as a score-board within a chat application. However, after we'd added much-asked-for commenting and reply features to our score-board, we realised we'd implemented a chat application within a chat application, and had wasted our time enormously.
Feature Phones are a real-life example: although it seemed like the market wanted more and more features added to their phones, Apple's iPhone was able to steal huge market share by presenting a much more enjoyable, more coherent user experience, despite being more expensive and having fewer features. Feature Phones had been drowning in increasing Conceptual Integrity Risk without realising it.
Which leads to Greenspun's 10th Rule:
"Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp." - Greenspun's 10th Rule, Wikipedia
This is a particularly pernicious kind of Feature Risk which can only be mitigated by good Design. Human needs are fractal in nature: the more you examine them, the more differences you can find. The aim of a product is to capture some needs at a general level: you can't hope to "please all of the people all of the time".
Conceptual Integrity Risk is the risk that chasing after features leaves the product making no sense, and therefore pleasing no-one.
Sometimes, features can work for some people and not others: this could be down to Accessibility issues, language barriers or localization.
You could argue that the choice of platform is also going to limit access: writing code for XBox-only leaves PlayStation owners out in the cold. This is largely Feature Access Risk, though Dependency Risk is related here.
In Marketing, minimizing Feature Access Risk is all about Segmentation: trying to work out who your product appeals to, and tailoring it to that particular market, but for technologists, increasing Feature Access means increasing complexity: you have to deliver the software on more platforms, localized in more languages, with different configurations of features at different price-points. Mitigating Feature Acccess Risk therefore means increased effort and complexity (which we'll come to later).
Feature Access Risk is related, of course, to Market Risk, which I introduced on the Risk Landscape page as being the value that the market places on a particular asset. Since the product you are building is your asset, it makes sense that you'll face Market Risk on it:
"Market risk is the risk of losses in positions arising from movements in market prices." - Market Risk, Wikipedia
I face market risk when I own (i.e. have a position in) some Apple stock. Apple's's stock price will decline if a competitor brings out an amazing product, or if fashions change and people don't want their products any more.
In the same way, you have Market Risk on the product or service you are building: the market decides what it is prepared to pay for this, and it tends to be outside your control.
Feature Drift is the tendency that the features people need change over time. For example, at one point in time, supporting IE6 was right up there for website developers, but it's not really relevant anymore. Although that change took many years to materialize, other changes are more rapid.
The point is: Requirements captured today might not make it to tomorrow, especially in the fast-paced world of IT. This is partly because the market evolves and becomes more discerning. This happens in several ways:
- Features present in competitor's versions of the software become the baseline, and they're expected to be available in your version.
- Certain ways of interacting become the norm (e.g. querty keyboards, or the control layout in cars: these don't change with time).
- Features decline in usefulness: Printing is less important now than it was, for example.
Feature Drift Risk is not the same thing as Requirements Drift, which is the tendency projects have to expand in scope as they go along. There are lots of reasons they do that, a key one being the Hidden Risks uncovered on the project as it progresses.
Fashion plays a big part in IT, as this infographic on website design shows. True, websites have got easier to use as time has gone by, and users now expect this. Also, bandwidth is greater now, which means we can afford more media and code on the client side. However, fashion has a part to play in this.
By being fashionable, websites are communicating: this is a new thing, this is relevant, this is not terrible: all of which is mitigating a Communication Risk. Users are all-too-aware that the Internet is awash with terrible, abandon-ware sites that are going to waste their time. How can you communicate that you're not one of them to your users?
If this breakdown of Feature Risk seems reductive, then try not to think of it that way: the aim of course should be to delight users, and turn them into fans. That's a laudable Goal, but should be treated in the usual Risk-First way: pick the biggest risk you can mitigate next.
Consider Feature Risk from both the down-side and the up-side:
- What are we missing?
- How can we be even better?
Hopefully, this has given you some ideas about what Feature Risk involves. Hopefully, you might be able to identify a few more specific varieties. But, it's time to move on and look in more detail at Complexity Risk and how it affects what we build.
At this point, it would be easy to stop and say, look, here are a bunch of Feature Risk issues that you could face. But, it turns out that we're going to be relying heavily on Feature Risk as we go on in order to build our understanding of other risks, so it's probably worth spending a bit of time up front to classify what we've found.
The Feature Risks identified here basically exist in a 3-dimensional space:
- Fit: How well the features fit for a particular client.
- Audience: The range of clients (the market) that may be able to use this feature.
- Evolution: The way the fit and the audience changes and evolves as time goes by.
"This preservation, during the battle for life, of varieties which possess any advantage in structure, constitution, or instinct, I have called Natural Selection; and Mr. Herbert Spencer has well expressed the same idea by the Survival of the Fittest" - Charles Darwin (Survival of the Fittest), Wikipedia.
Darwin's conception of fitness was not one of athletic prowess, but how well an organism worked within the landscape, with the goal of reproducing itself.
Fit Risk, Conceptual Integrity Risk and Implementation Risk all hint at different aspects of this "fitness". We can conceive of them as the gaps between the following entities:
- Perceived Need: What the user thinks they want
- Expectation: What the user expects
- Reality: What they actually get.
For further reading, you can check out The Service Quality Model, whcih this model is derived from. This model analyses the types of quality gaps in services, and how consumer expectations and perceptions of a service arise. In Staging And Classifying, we'll come back and build on this model further.
Two risks, Feature Access Risk and Market Risk considers Fit for a whole Audience of users. They are different: just as it's possible to have a small audience, but a large revenue, it's possible to have a product which has low Feature Access Risk (i.e lots of users can access it without difficulty) but high Market Risk (i.e. the market is highly volatile or capricious in it's demands). Online services often suffer from this Market Risk rollercoaster, being one moment highly valued and the next irrelevant.
Two risks further consider how the Fit and Audience change: Regression Risk and Feature Drift Risk. We call this evolution in the sense that:
- Our product's features evolve with time, and changes made by the development team.
- Our audience changes and evolves as it is exposed to our product and competing products.
- The world as a whole is an evolving system within which our product exists.
Consider Feature Risk carefully next time you are grooming the backlog:
- Can you judge which tasks mitigate the most Feature Risk?
- Are you delivering features that are valuable to a large audience? How well do you understand your audience? How does the size of the audience for a task impact it's importance in the backlog?
- Does the audience know that the features exist? How do you communicate feature availability to them?
- How does writing a specification mitigate Fit Risk? For what other reasons are you writing specifications?
In the next section, we are going to unpack this third point further. Somewhere between "what the customer wants" and "what you give them" is a dialog. In using a software product, users are engaging in a dialog with its features. If the features don't exist, hopefully they will engage in a dialog with the development team to get them added.
These dialogs are prone to risk, and this is the subject of the next section, Communication-Risk.
