May, 2020 | digitalML
The API Lifecycle: Recommended Approach for APIs and Services at Scale Reading Time: 4 minutes

 

In this blog post, we’re going to take a look at current approaches to the API Lifecycle in large organizations, and some shortfalls these present when it comes to delivering on their API strategies – particularly speed and scale of API delivery. We’ll also provide a recommended approach to the API Lifecycle; focusing on plan, design, and build.

Why do large organizations need to focus on the API (and Service) Lifecycle? 

As discussed in our recent CEO commentary, there is a real urge for large enterprises to mature their API strategy and accelerate digital transformation, particularly in response to the current Covid-19 pandemic (and to be flexible for whatever the “new normal” brings). Leaders are focusing on building out a catalog of APIs and Services to represent business and technical functions.

In order to rapidly mature an API strategy in support of:
– all while modernizing legacy IT – organizations need an API Lifecycle that is collaborative, fast, and scalable – and produces APIs and Services that are reusable, consistent, and secure.



Current approaches to the API Lifecycle & associated challenges for speed and scale

Leaders know to deliver consistent, reusable, and compliant APIs and Services, there needs to be an API Lifecycle in place that better supports upstream of CI/CD and run, i.e. focuses on the plan, design, and build stages, directly integrated to run. Most organizations have implemented elements of the API and Service Lifecycle into their infrastructure (i.e. API management solutions, other distributed runtime environments, etc.), but are still facing challenges when it comes to speed and scale. Because developers are still designing and building APIs and Services using slow and manual processes, that are code specific to one architectural standard, runtime system, or application framework, time to market for well-crafted APIs is slow and cost inefficient.

To be successful in the new era of digital, organizations need to move to an API strategy 2.0, modernize and normalize existing brownfield Services and APIs, and utilize greenfield development, and that’s difficult to accomplish when you’re utilizing manual point-to-point processes for the API Lifecycle. As a result, many have to choose to prioritize either business or IT goals, when both are urgently needed.


The recommended approach to the API and Service Lifecycle – focus on plan, design, and build

Plan – API and Service discovery and reuse 

When planning and prioritizing a pipeline of ideas, everyone from business to IT needs a holistic view of existing and in progress APIs and Services in order to identify what already exists and what needs to be designed (integrated with outputs from Domain Driven Design (DDD), project or product processes for a unified view). Existing assets which are reusable should be clearly approved for reuse.

Design – Design new or extend existing APIs and Services

Whether designing new or modifying/extending existing APIs and Services, this stage is used to define the technical requirements such as Methods or Operations and payloads. All should be aligned to taxonomies and models (both information and maturity), and automated governance flows enforced.

Build – automate API and Service development and code generation

To ensure APIs and Services are normalized and consistent, develop and code based on the requirements noted in the Plan and Design stages. Through runtime-ready template driven artifacts, this process should be automated so developers are focusing on big brain activities (like adding business logic) rather than manually coding.


Run – with bi-directional integrations between design and runtime

By integrating with any runtime platform already in place and other enterprise software products, a single source of truth is created for all bi-directional integrations, upstream processes, and previous Lifecycle stages, making it easier to deploy, manage, and test all APIs and Services.

    Diagram showing the API lifecycle with the ignite platform

    Organizations need to look for a solution that supports this to fill the gap in their existing infrastructures, works with abstracted artifacts instead of hard-coded APIs and Services, and fully integrates with upstream and downstream systems.


    Key benefits to a fully integrated API and Service Lifecycle

    1. Promote API and Service reuse

    You’re moving away from manual development to APIs as a set of Designs, abstracted away from code and runtime environments that are easy to find, combine, and deploy.

    2. Prevent API and Service duplication

    APIs and Services are normalized earlier on in the lifecycle, before pushed to the build and run stages, so they are standardized, normalized, and consistent for any developer to pull from.

    3. Ensure APIs and Services are consistent and standardized

    Internal and external consumers are working from a set of abstracted Designs and Specifications, with the code normalized and being generated from these.

    4. Provide speed and scale for greenfield API and Service development

    Automating the process and deskilling the development, you can deliver APIs and Services faster with this approach to the API and Service lifecycle.

    5. Modernize (or simply register) brownfield APIs and Services

    For any modernization needs or future tech moves, use a Holistic API and Service catalog that’s tied to the API and Service lifecycle, to ensure your brownfield Services are registered properly and can be modernized.

    6. Runtime vendor and tech agnostic

    Using automation in the API and Service lifecycle, generated artifacts are runtime-ready for any downstream target you may have, and are flexible for future technology.

    7. Regulatory and Technology complaint APIs and Services

    Checks and approval processes are built in throughout the entire process, ensuring consistent and approved frameworks are delivered.

    8. Develop APIs and Services which encapsulate business and IT capabilities

    Through a design-first approach, new artifacts that are generated have the design set as the standard rather than the code

    9. Support top-down and bottom-up API and Service development

    An API and Service lifecycle which focuses on DDD, business capability, and product ownership approach, while also supporting developers building in IDEs.

    Utilizing an API and Service Lifecycle that focuses on plan, design, and build and is bi-directionally integrated, you’re supporting business and IT collaboration, top-down domain driven design, and bottom-up development. Collaborating throughout the entire process ensures the delivery of new, consistent, reliable, and reusable APIs and Services at speed and scale for both business and IT goals.

    Want more information on the API and Service Lifecycle recommended approach?

    For a deeper dive into ignite’s API and Service Lifecycle on what makes it unique and how it works, check out our free whitepaper here.

    In this whitepaper, you’ll read about: