The phases of the Product Lifecycle occur in four major stages:
These are the starting points for the amount of time a product goes from ideation and introduction to the marketplace to the time it gets phased out.
With determining factors in place, organizations use these four phases to provide better insights, so that they can make more informed decisions regarding promotion to cost-efficiency.
It is possible that specific lifecycle models are more fine-grained than the four basic levels presented here. But in order to make the model as generally applicable as possible, we are just focusing on these four fundamental phases of a product lifecycle.
The introduction phase is the starting point of every product. It starts with designing and launching a minimum viable project (MVP), which is then followed by investments centered around publication and marketing. This helps make consumers aware of the availability and benefits of the product.
APIs are the starting point. In the end, an API simply is a way to interact with a product or capability. This capability has some lifecycle associated with it, but it also is a promise you make to consumers and keeping that promise should be a goal for every API product owner. There may come a time when a product has to be deprecated and discontinued, but good API design plans ahead for this to make transitioning between products easier for consumers.
From the very beginning, managing an API needs to take the product lifecycle into account. Having a lifecycle model in place helps API owners in an organization to better plan and manage an API. But it also helps API consumers because good lifecycle management focuses on consumers as the primary beneficiaries of lifecycle management.
Once a product has been launched and has initial consumers, it moves to the growth phase. As API Products grow, they typically see increased usage, and they evolve based on feedback from that growing consumer base.
Now it is time to start watching product usage and to start gathering consumer feedback. The idea is that your initial product (the MVP) was minimal but designed for evolution and that you can therefore safely grow your product (and with it its consumer base) without disrupting existing consumers.
It very much depends on your API product what your goals are in terms of a number of consumers (i.e., numbers of applications that use your API) and the number of end-users (i.e., the combined number of users that use all the applications that use your API).
One differentiating factor is whether your API is intended to be private-, partner-, or public-facing, and depending on that perspective, you may choose different product design options and may have different perspectives on what growth you are expecting.
Depending on your API product and its growth potential, you might see modest and organic growth (let’s say for a private API that gets incorporated into more internally built value chains), or you might see unexpected and runaway success (a public API that suddenly gains a lot of visibility and momentum).
In that latter case, API scalability might be very important (in which case it helps if you have loosely coupled implementations such as microservices), but in reality, this kind of “surprising growth spurt” is more the exception than the rule.
In either case, at some point investment in an API will decrease. It may be that it doesn’t serve the core interests of the organization anymore, or that a new and improved API has been or will be introduced.
The maturity phase means that the API has become a product that you are still keeping stable and operational. But you’re not investing in usage growth anymore, and you probably expect to see decreasing usage numbers over time.
At this point, you might have decreased investments in the product, and in particular into investment areas such as improving the product. While you may have stopped developing the product, it still is important to keep it operational.
This sometimes may require actions such as scaling it up, and ideally this kind of “maturity level activity” should be easily possible without having to go through development cycles to improve the scalability. While the product is nearing the end of its lifecycle, you may now shift investments to new products, or to entirely new areas.
Products don’t live forever. For a variety of reasons, products may near their end-of-life, and ideally, this should be managed as the final phase of the lifecycle: Recognizing shrinking demand, deprecating a product (and possibly helping consumers to switch to new products), and finally shutting it down for good.
From the very beginning of the lifecycle of an API product, you should have a plan in place for how to take a product off the market and shut down the API.
It’s relatively easy to plan ahead, and it should be a standard part of the product management plan from the very beginning.
Keep in mind that the four phases are not written in stone. But it’s important to have a strategic model to manage your products within the API landscape.
Knowing how to invest and manage your API Lifecycle is the key to managing it systematically.
Download the white paper to learn how to succeed through change with APIs.