You’re likely growing your reliance on Application Programming Interfaces (APIs) in order to connect disparate systems, unlock value from data, and launch innovative products and services that delight customers and partners. But APIs need effective lifecycle management so that they’re carefully planned and managed right from ideation to deprecation. In fact, properly managed APIs have been shown to fuel growth in enterprises.
To maximize the value of your APIs, you need to be optimizing each stage of the API lifecycle, especially by shifting left and focusing on the planning, designing, and building great APIs. Although opinions and naming tend to differ slightly for each organization, here are 7 common API lifecycle stages that we’ll be discussing in this article:
- Plan
- Design
- Build
- Run
- Monitor & Report
- Promote & Discover
- Subscribe
Enterprise API Lifecycle Stages
1. Plan
As we all move towards a product mindset for APIs, proper API planning ensures your enterprise can quickly deliver new capabilities, without introducing duplication and/or poorly designed artifacts. APIs that are well-governed and consistent cost less time to implement, and decrease developer overhead while increasing the quality of the applications that are consuming them.
During the planning stage, business stakeholders, product owners, and technical analysts are able to ideate how to fulfil new digital business processes and opportunities using APIs. It’s important to note here that API reuse should be the first port of call. API sprawl is a looming threat to the digital economy, so if your existing APIs are reliable and reusable, they can quickly be composed together into product bundles. Having said that, even the most mature enterprises might have gaps in their API coverage when it comes to launching new functionality, so let’s assumed you have identified the need to create a new API and look next at the stages of doing so. The plan phase is complete when you’ve outlined a blueprint for the API – what it’s going to do and who’s going to own it, what product bundle it’ll be a part of, and any expected KPIs you’ll want to track later.
2. Design
The design phase is where service architects, developers, or technical analysts define the functions of the API and how it will be represented in it’s technical form e.g. which API protocol it will be implemented in.
A great design stage ensures risk management and governance frameworks are followed through the remaining stages of the lifecycle with a view of specification versions (as you’ll iterate your API over time), approvals, and usage. Following design best practices also ensures you’re constructing your API properly and ensuring it’ll be reliable and consistent once deployed.
3. Build
In the build stage, developers build the technical details for the APIs. An effective build phase leverages automation to accelerate this stage; reducing manual and error-prone tasks to ensure alignment to governance, standards, frameworks, security, and deployment guidelines and templates.
When building new APIs, developers should implement and define all the technical details such as payloads, headers/parameters, non-functional requirements, mappings, and response codes. If using existing APIs as mentioned before, this stage will involve creating new versions of the API which can be updated/modified and extended as needed.
4. Run
Now, your API can be deployed from design-time to runtime via your API gateway(s). The gateway provides a single source of entry for all APIs and handles common tasks that are used across a system of API services such as authentication, routing, rate limiting, monitoring, analytics, policies, alerts, and security.
Enterprises sometimes struggle so sync the runtime and what happens once the API is implemented to the API tooling they’ve used to complete the first 3 lifecycle stages. Best practice is to leverage tooling that offers bi-directional integrations to ensure you have an accurate system of record for all APIs and any runtime updates can be automatically pushed back in to your design-time catalog.
5. Monitor and Report
The monitoring and reporting stage of the lifecycle is where the deployed API is now running and being monitored for the set of service level indicators that have been defined for that API. The raw numbers should be captured in a downstream telemetry system where they can be aggregated and visualized. This allows you to see exactly what is happening with a given API in near real time.
Alerts should also be set up to notify owners when their APIs start misbehaving and breach their defined thresholds for their most important metrics.
6. Promote and Discover
When it comes to your gold standard APIs, they are only really of value if they’re being consumed. Therefore, the next stage is to promote APIs to your consumer views (such as developer portals, API marketplaces, and consumer portals), so they can be discovered by consuming developers and consuming business roles.
Great API discovery for consumers involves being able to search and filter APIs across multiple runtimes, browse by product bundles and applications, and see what’s in-flight in the organization as well as what’s already in production.
7. Subscribe
The subscribe stage of the lifecycle is where your consumers (internal, partner, and/or customer) can onboard themselves to reusing your APIs. This stage is most optimized when consumers can effectively understand your APIs (through rich metadata and business context, interactive documentation, and testing/mocking) and subscribe in a self-service way.
And don’t forget; the lifecycle is not a once-and-done process! You’ll be continuously iterating your APIs over time to support new opportunities and new consumers.
Best practices for optimizing the API lifecycle
Most organizations have spent time and resource standing up infrastructure that supports part of the API lifecycle, including API gateways, API management platforms, and other distributed environments. However, many are noticing a gap in the lifecycle and supporting architecture (that which is upstream of deploying the API to CI/CD and run).
That gap is most apparent when we have development teams manually designing and building APIs, that are code-specific to one architectural standard, runtime system, or application framework. With this approach, time to market for new APIs is slow and cost inefficient. We also see a lack of consistency and alignment to governance rules and standards, plus lots of API duplication and a lack of reuse.
Mature enterprises are leveraging API lifecycle management best practices across the process, such as:
- Aligning APIs to business needs and enabling business roles to collaborate across the lifecycle: Forrester reports that an IT-led API business strategy is in fact the opposite of an API business strategy and is doomed to fail.
- Automation of manual and error-prone tasks: e.g. governance checks and validations, and artifact generation based-off the API specification to speed up time to market and reduce developer overhead.
- Organizing APIs (and tracking them through their evolution) in a holistic API catalog: where they are discoverable to the entire organization and held upstream in the lifecycle.
- Integrating the API lifecycle with upstream and downstream platforms: to create an end-to-end framework and best of breed API architecture.
Embrace these best practices and master all stages of the API lifecycle at scale!
For a deeper dive on this topic, we recommend reading through our API lifecycle whitepaper.
