As application programming interfaces (APIs) continue to grow in adoption, the meaning of the term “API management” has evolved (and continues to do so). So do the challenges of managing APIs at scale, especially for large enterprises. But, with the help of the 6 tactics we’ll cover in this article, enterprise API lifecycle management provides an exciting opportunity to deliver a thriving API ecosystem resulting in differentiated products and services wherever the customer is.
The evolution of API management and lifecycle management
Ask five people what API management means to them and you’ll probably get five different answers, but we can loosely define 3 areas in its evolution:
- Implementation API management. This focuses on managing APIs once they’re in production, who can access them, and how they’re consumed etc.. Functionality areas like runtime metrics, authentication and authorization became popular during this stage of maturity. Organizations stood-up API gateways and many invested in traditional API management platforms.
- Basic API lifecycle management. This looks at how APIs are managed from creation to deprecation. Functionality areas like visual code editing, governance rules and style guides, and mocking and testing become important. This stage (and the last) have been predominantly led by IT, with business becoming aware of APIs as adoption grows and success is seen.
- And where mature organizations are moving to now – scaled and product-driven API management and adoption of other styles e.g. event-driven APIs. Focuses around:
- A holistic approach to all components of API strategy
- Managing multiple types of APIs across multiple lifecycle states
- Outside-in API creation for exposing business capabilities (including more focus on the planning and prioritization phases of the API lifecycle)
- Business and IT alignment
- Composability and reuse (including API consumer experience)
- Futureproofing API programs for changing technologies, landscapes, partners etc.
- Connecting data and applications for end-to-end dependency management
The evolution from stage two to three of API management can be challenging, especially for large enterprises who already have lots of legacy web services, distributed and changing architectures, and changing priorities. And with the API management market predicted to be valued at $5.1bn by 2023, the space is noisy on how to move forward. Here are 6 tactics that are working well for our enterprise customers right now to help you mature and scale your lifecycle management.
6 Enterprise API Lifecycle Management Best Practices
1. API design-first and API product mindset shift
Where once APIs were created as one-off implementations and project by-products, it’s now widely accepted that your core set of APIs (i.e. those that expose your business capabilities) should be designed outside-in and with the end consumer in mind. This mindset shift is important because it sets up the remaining best practices we’ll cover, and ensures your enterprise is treating APIs as strategic business assets.
To get there involves work on internal education about the benefits of APIs, design-first, and API product management, as well as tooling that supports a design-first approach, while being connected to your existing runtime.
2. Enable Business and IT collaboration across the lifecycle
It’s more than just developers that are involved in an API (or a Service or Event)’s lifecycle in mature organizations:
You want to enable everyone to join the playing field; business to be able to understand what APIs you have, what capabilities they’re supporting, and help drive the innovation pipeline; technical talent to be able to easily communicate and provide input during the creation (and consumption) of APIs; and risk and governance teams to easily see what’s in and out of compliance and where.
Enabling collaboration across the API lifecycle drives better consumer-centric innovation, and helps build out an enterprise planning and design muscle for faster time to market with less duplication.
3. Automate manual tasks for increased productivity without sacrificing quality
Even in the largest of enterprises, technical talent can be hard to find and keep. We’re seeing:
- Small architecture teams tasked with building the connective tissue between what the business wants and what IT has in place to deliver.
- Developer burnout in response to increased workloads and increased time spent manually writing and de-bugging code.
So if you can automate manual and error-prone tasks we can do better time and volume to market while ensuring reliable and consistent artifacts are generated. Think automating some parts of design and creation, governance checks and approval workflows, and lifecycle state management and deployment.
Developers can focus more time on business logic and customer experiences and less time on integration plumbing, and architects can focus on building out the framework that enables this further for a flywheel effect.
4. Achieve the API governance sweet spot
We all know API governance is a key part of the development process that drives quality, reliability, and ultimately composability and reusability. We also know governance is often thought of as a four letter word; a handbrake to speed. Mature enterprises are finding their governance sweet spot – a balance between centralized and federated governance across the lifecycle in a way that’s flexible and baked in so it’s just part of the process.
Configurable automated governance can help here – establishing rule sets based on things like API or Design type, use case, region or team, that can be evolved easily over time. The goal of the API governance sweet spot is that it’s easy, transparent, and most importantly helps support the value of the functionality that’s being exposed.
5. Capture and manage the complexity of an enterprise API landscape
Due to the very nature of being a successful incumbent enterprise, your lifecycles and landscape is likely very complex. And it’s not just the complexity of running APIs at scale. It’s also things like:
- Multiple API types (e.g. legacy SOAP, REST, event-based) each with multiple versions both in production and in-flight
- Changes/updates to APIs, lineages and dependencies that need to be tracked and impacts understood
- Ecosystem changes e.g. providers, consumers, partners
This needs to be captured and managed as part of your enterprise API management program to give you accurate control over the entire ecosystem and provide transparency and predictability.
6. Tie to a catalog with promoted and curated versions for reuse
API reuse is a key initiative for many API programs – a goal state of a composable enterprise with minimized redundancy. And your APIs are of course most valuable when they’re being consumed.
But consumers need easy API discovery. They need to be able to find exactly what they’re looking for and assess if it’s fit for purpose and that they want to take on the dependency. We can’t expect them to trawl through the whole portfolio of 1000s of APIs to do this.
So, your API lifecycle should be tied to a catalog – and not just any catalog – one that enables those composable versions of the APIs your teams have spent time curating to be promoted for reuse. And those curated versions should have consumer-friendly views. That’s so consumers can quickly understand the API, mock and test, and easily reuse it.