AIM. MySpace. Kazaa. We’re (carbon) dating ourselves with these examples, but everybody knows at least a couple of software giants that have fallen during their lifetime. Defunct brands like these have all reached the end of their lifecycles. But what of the beginning?

Application Lifecycle Management (ALM) is a well-documented practice in software development, with tools like SAP’s Solution Manager and Microsoft’s Visual Studio Application Lifecycle Management among the software suites for ALM available in 2022.

In recent years, API developers have actively been talking about a different type of ALM — API Lifecycle Management — as a subset of API management. Although, for the sake of clarity, we won’t refer to API Lifecycle Management as ALM again!

Moving an API from planning to deprecation may represent a process that takes many years, which is why stable API Lifecycle Management is so crucial. A mistake at any stage of the process can be damaging in both financial terms and for a company’s reputation.

The Stages of API Lifecycle Management

There are various stages to any API’s lifecycle, which can be broken down as follows:

• Planning and Design
• Development
• Testing
• Deployment and Maintenance
• Versioning
• Deprecation and Retirement

Depending on where you look, you might see this split into three broader headings: Design, Implementation, and Management. But we’ll stick with the headings bulleted above, as there are tools and products that can help with each stage of this process — the most widely-used of these being the API management platform.

In this post, we’ll cover what API Lifecycle Management entails, look at platforms and tools that can help you with it, and delve into some aspects of lifecycle management, such as developer portal generation, monetization, and retirement, that are often overlooked.

API Platforms and API Lifecycle Management

Whether or not they make it explicit in their literature, API management platforms encompass API lifecycle management. API management is generally considered to consist of API design, the use of an API gateway, and API lifecycle management.

Breaking down API lifecycle management by stake makes it easy to see how considerable the impact of API management platforms (and a few other API Lifecycle management tools and products that are on the market in 2022) can be in a strategic approach.

Planning and Design

From REST to GraphQL, OAuth to microservices, there are all sorts of techniques and frameworks to consider when it comes to planning out an API. SwaggerHub, for example, is a useful tool for creating definitions and collaborating on them.

For more on the planning stages, we’ve written before about some of the best practices of API design, including how useful the OpenAPI Specification can be when you’re still in the early stages.

Development

Actually developing your API is arguably the most important step in API lifecycle management. Tools like Hoppscotch and Insomnia are great open-source clients for building APIs.

More and more developers, however, are using API management platforms as a portal to provide access to their APIs, and embed their work within these platforms from the earliest stage possible. (And when you see how they can help with the other stages of lifecycle management, it’s not difficult to see why).

Testing

You wouldn’t release an app into production without testing it first, and APIs should be no different. Tools like ReadyAPI and Postman are valuable for testing APIs and can even automate different aspects of it.

Once again, this is something that can often be taken care of from within an API management platform. The most popular of these platforms contain at least basic testing tools, but services like ReadyAPI are capable of integrating with major platforms if you want to go deeper.

Deployment and Maintenance

Various factors will impact where and how you deploy your API — internal or external, paid or free, locally or in the cloud — but you’ll always want to ensure that you maintain control over it. For many API developers, that means using a platform like AWS API Gateway, IBM API Connect, or Microsoft Azure.

Such platforms are particularly useful in this context because they often come with policy enforcements like OAuth2 embedded within them and can be used for rate limiting. You’ll want to make sure that your documentation is always up to date, and that’s something management platforms can also help with.

Tools like Swagger and Stoplight can even be used to automate the production of API documentation and push changes live when existing specifications are updated.

Versioning

All APIs go through changes, which can sometimes mean releasing new versions and upgrading clients. There’s a delicate balance here: you need to provide adequate notice of sunsetting, but if you allow too much leeway, then API consumers might become complacent and fail to make appropriate changes in good time.

Developer portals and email blasts can both be appropriate for notifying users about breaking changes, and some modern tools are capable of simplifying this process through login notifications, announcement banners, automated API documentation changes, and so on.

Of course, the priority during this stage of an API’s lifecycle should always be to maintain stable client integrations and preserve as much backward compatibility as possible. And being passive with communication isn’t the best way to handle API changes effectively.

Deprecation and Retirement

When Netflix retired its public API in 2014, initially grandfathering in apps that already had access then later pulling the plug entirely, it prompted ProgrammableWeb’s Patricio Robles to ask “is the golden age of the public API over?”

There will always be people who react with anger when you deprecate a version of an API or retire a public API entirely, but there are ways to minimize frustration. Namely, through good versioning, in the case of the former, or honesty coupled with a long sunset period, in the case of the latter.

True, it might seem counterintuitive to consider retiring an API while you’re still getting it off the ground. But making plans about this stage of the API lifecycle early can ease problems later, and a holistic approach can really help with that.

API Lifecycle Management Expands

Developer portals and API monetization are typically thought of as being separate from API lifecycle management. But given how important these things are to the adoption and longevity of APIs, it doesn’t really make sense to keep them disconnected.

Unsurprisingly, we’re already seeing some tools integrate these things into the API management process. Red Hat’s 3scale platform, for example, embeds Billing & Payments solutions that make it easy to monetize your APIs from the same place you manage them. Similarly, they have a lengthy guide to creating developer portals in their product documentation, which can again be done from within the platform… although you might want to go above and beyond these recommendations if you want to match up with these truly great developer portals.

In fact, some larger API management platforms like Kong and Postman are already taking steps to cater to many of the above steps from one central location. Some might argue that the widespread adoption of tools like these stifles creativity and could result in the homogenization of APIs. The counterpoint? Standardization solidifies best practices and reduces barriers to entry for budding API developers.

What’s Next for API Lifecycle Management?

Precisely what constitutes API lifecycle management is still evolving. But we’ll most likely continue to see platforms try to one-up their competitors by making it easier to manage everything from one easy dashboard.

APIs have transitioned from fun side projects to legitimate business offerings. And this trend is reflected in the way many API management platforms now try to support every aspect of the API lifecycle, from creation and deployment through to marketing and monetization.

And although there are circumstances where API developers might want to pull together a custom set of distinct tools for the job, this “one-stop shop” approach probably simplifies the process of releasing an API. Regardless of how API lifecycle management is handled, or what tools are utilized, it’s always good to see API developers taking a proactive approach towards it.