One of the key philosophies of the Disciplined Agile Delivery (DAD) framework is that it presents software development teams with choices and guides them through making the right choices given the situation they face. In other words, it helps them to truly own their process. Part of doing so is to choose the software delivery lifecycle (SDLC) that is the best fit for their context. In this blog posting we overview the DAD Exploratory lifecycle which is based in part on Lean Startup strategies.
This lifecycle can be applied in two ways:
- As a replacement of the Inception phase of other lifecycles. In the Inception phase we invest a short yet sufficient amount of time and effort to validate that the initiative being considered makes sense and to gain agreement on the stakeholders’ vision. In a situation where the actual need and value of what is being proposed is in question this approach is a very good way to determine the true market need before scaling up the initiative and moving into the Construction phase.
- As the implementation approach in the Construction phase. After applying the Exploratory approach to validate your vision, a decision needs to be made regarding which of the four DAD lifecycles to apply as we move into Construction. For instance, you may choose to use DAD’s Scrum-based basic agile lifecycle if there is sufficient confidence from the learnings in the Inception phase regarding the viability of the vision. However, if there remains some uncertainty regarding the feature set to be delivered it may make more sense to continue using the Exploratory lifecycle to build out the product in Construction.
The following diagram overviews the DAD Exploratory lifecycle. This lifecycle is followed by agile or lean teams that find themselves in startup or research situations where their stakeholders have an idea for a new product but they do yet understand what is actually needed by their user base. As a result they need to quickly explore what the market wants via a series of quick learning experiments.
Now let’s describe how the Exploratory lifecycle works. There are six activities to this lifecycle:
- Envision. Your team will explore the idea and identify a potential implementation strategy for implementing it. This could be as simple as getting a few people together in a room to model storm both the business vision and your technical options on whiteboard and paper. You want to do just enough thinking to identify a viable hypothesis for what your customers actually want. This hypothesis needs to be testable, which implies that you need to identify how you are going to measure the effectiveness of the new functionality that you produce.
- Build a little. Your team should invest just enough effort to build a solution that tests the hypothesis. In lean parlance you want to build what’s known as a minimally viable product (MVP). The amount of effort will vary, from several days to several weeks – your goal is to make something available very quickly so that you can test your hypothesis.
- Deploy. Once your current solution is ready it is deployed into an environment where you can test your hypothesis. This deployment may be to a subset of your customers, in many ways what used to be called an “alpha” or “beta” release, so that you can determine whether the solution is of interest to them.
- Observe & measure. Once the solution is available in production you want to determine what aspects of it, if any, are of interest to your user base. To do this you will need to instrument your solution so that it logs data regarding important events within it. For example, you may decide to record when a screen/page is accessed, when a sale occurs, when certain business functions are invoked, and so on. The idea is that you want to understand which functionality end users find useful, which functionality leads to customer retention, which functionality leads to greater sales, … whatever is important to you. Generation of this data enables you to monitor, to observe and measure, how well the new functionality is received by your user base. This in turn allows you to make a fact-based go-forward decision. If the functionality is well received then you may choose to continue with the existing strategy and add more functionality. Or your strategy may be so successful that you decide that you’re ready to productize the development of this solution. If the functionality wasn’t well received your team might choose to pivot and continue in another direction or even give up completely.
- Cancel. Sometimes you discover that the product idea isn’t going to work out after all. In fact, this is particularly common in research and development (R&D) environments as well as start ups. The advantage is that if an idea is going to fail, then it is better that you learn that it’s a failure quickly so that you can devote your energies into other strategies.
- Productize. After several iterations of building a little, deploying, and then observing & measuring that you’ve identifying a product that will be successful in the marketplace (or in the case of internal application development successful with your user base). As described above, although you may choose to continue following this lifecycle, a common decision is for the team to adopt one of the other DAD lifecycles – such as the Scrum-based agile lifecycle, the Kanban-based Lean lifecycle, or the Continuous Delivery lifecycle – and effectively treat the time they spent following this lifecycle as their Inception phase.
To summarize, the DAD process framework takes a flexible, non-prescriptive approach to software-based solution delivery. As a result of this philosophy DAD supports several development lifecycles, one of which is the Lean-Startup-based Exploratory lifecycle described in this posting. This lifecycle is typically followed in situations where you are unsure of what your user base wants, and sometimes even when you are unsure of who your user base (your customers) will even be.