API abstraction provides a unique solution for large enterprises looking to scale their API efforts as part of an API first digital strategy. In this post we look at what abstraction is, why it’s needed, and the 6 key benefits of using abstracted APIs as your system of record and main API objects, rather than code.
Large enterprises have a gap in their API efforts: holding APIs as code is the cause
As a large enterprise trying to maximize the value of your API efforts as part of an API first strategy, you’re likely now at a stage where you need to:
- Open up your APIs to a wider audience – to be designed, developed, managed, and consumed by a wide range of personas; including internal (e.g LoBs, product owners) and external (e.g. partners in your API ecosystem) stakeholders.
- Manage, organize and group together thousands of APIs which encapsulate your business capabilities and IT functions, not just 10-100 open APIs.
- Manage different types and categories of APIs and versions across different runtimes in a flexible and futureproofed way.
- Capture and manage the growing complexity of your API program; such as lineage, mappings, conformance to data models, and security policies (and other common shared services)
What’s more, you likely want all of the above in a single unified view, understandable by both business and IT. But, relying on the implementation code for your APIs makes this near impossible – that’s because API code is hard to interrogate and understand beyond a handful of skilled developers, and it’s likely held in disparate systems across the enterprise’s architecture.
Abstracting your APIs provides an unique solution and can be used to deliver all of the needs above, in supporting API first at scale.
What is API abstraction?
Simply put, abstraction can take your APIs away from their complex code and implementation specifics, into a common metadata framework, to make them understandable by everyone in the enterprise in a standardized format.
When working with abstraction, two objects are involved to ensure your APIs are usable by both business and technical users:
- A pure abstracted view of the API: This is what we call a Design. A code- and implementation-agnostic view which contains abstracted capabilities of what the API does/will do once realized. Designs are a representation of your business capabilities and technical functions.
- A semi-abstracted service representation of the Design: This is what we call a Specification. A technical view of your API which contains implementation-specific technical details e.g. methods with a de-coded payload structure and non-functional requirements. These are versioned, and importantly can be used to deploy runtime artifacts from (API code, contract, configuration, and documentation) directly to your pipelines and API gateways.
Why do you need API abstraction?
Abstracting your APIs helps drive adoption and reuse, effective governance and reporting, and futureproofs your investments. Here are the benefits of using abstraction as part of an API first strategy in more detail:
Benefits of using API abstraction for a successful API strategy
1. An extended audience for your APIs
Your catalog of APIs and Services becomes understandable by an extended audience as the detail and business logic is not locked away in the code. Many more internal roles in your enterprise, as well as approved external users can discover, understand, and use your APIs – all with a reliable consumer experience:
- Business users such as product owners
- Other technical users
- Partners
Users of your abstracted APIs can easily learn detailed information about the APIs and your portfolio as a whole, such as:
- What APIs your organization already has (API coverage)
- How “good” the APIs are (API governance compliance)
- How the APIs work
- Who owns the APIs
- What the upcoming API versions are
2. APIs can be reused to support new digital products
As APIs are abstracted into a common framework and therefore standardized format, they can be easily combined together, and repurposed into what we call Product Bundles (which includes API products, composite APIs etc.). These bundles can be used to quickly build, test, and launch differentiated products and services for your customers and partners.
3. Normalized, consistent and well-governed API code and documentation
The metadata in the abstracted APIs can be used directly to generate normalized and consistent code, contracts, configuration, and documentation; in formats that can be used and digested by different runtime systems e.g. API gateways or code repositories like an SCM configuration.
Alternatively, if only API documentation is needed, this can be generated in easy-to-read formats like word or excel.
Abstraction also allows your APIs to easily be aligned to an API governance model upstream in the API lifecycle.
4. Flexibility on alternative/future coding standards and formats
With abstraction, the system of record for your APIs is the Design (pure abstraction) and Specification (service representation), rather than the runtime code. This means that the abstracted API can easily be redeployed anywhere across your runtime landscape, increasing responsiveness and agility, while preventing vendor lock-in.
The latest Postman State of the API Report found that enterprises are working with a growing number of API technologies. The flexibility gained from abstraction makes it easier to adopt new API patterns and protocols, such as GraphQL and Async. It can also speed up IT modernization efforts too, such as migrating legacy SOAP services to OpenAPI.
5. Enables you to build a holistic catalog of your API landscape
Once your APIs are abstracted into a common standard, you can organize them and create types of service (e.g. business capability API, system IT API, facade/experience API, 3rd party API) and map them to business and technical taxonomies. You can also record inter-dependencies and relationships (e.g. lineage and mappings) between your APIs and their versions, as well as understand their conformance to data models and security policies etc. This gives you a holistic catalog view of your API landscape; all the different sources of each API and where they are in the lifecycle, which are suitable for reuse and can be approved to do so, and which are not reusable and are just registered into the catalog.
6. Ease of abstracted API reporting
With abstraction comes easy reporting on API coverage, maturity, governance and regulatory compliance. This enables better tracking of KPIs and business value that your APIs are delivering; something which is extremely difficult to do if your APIs are held in code.
The ignite platform provides a unique ability to abstract your APIs and reap these benefits
The ignite platform from digitalML provides a holistic API catalog with extended lifecycle management. Done so in a way that’s connected and always-in-sync with the rest of your API architecture. Your existing APIs and Services can be harvested or imported and automatically abstracted into the common metadata framework we’ve discussed in this post, along with taxonomies, information models, and business glossaries. Once you have imported, organized, and normalized your APIs into Designs and Specifications, ignite’s robust integrations with CI/CD and runtime systems, and template-driven artifact generation enables you to deploy your APIs directly from the catalog.
Learn more about API abstraction in the ignite platform in an interactive demo.
