Embrace Change with a Layered API Program

TIBCO Layered API Program

Reading Time: 6 mins.

The mainstream news is currently full of stories that speculate on the possibility of regional recessions, or even a global one.  Will a recession occur? The most relevant question to ask yourself, however, isn’t whether change will occur, but instead, is your business prepared for change?  Because opportunities lie within that change—if your business is agile enough to adapt to it.

Companies that build their businesses around an agile and flexible API program are better prepared to adapt to change. For example, such changes might include the evolution of your business systems, business processes, and even your business model.  It could also include new types of API consumers and client environments that emerge, such as was the case when mobile devices were introduced years ago. All of these forces, and more, place continuous pressure on you to adapt your API program quickly.

An agile API program exhibits characteristics that are similar to agile software applications.  To help localize the impact of new requirements, software applications are typically structured in layers, where each layer serves a specific purpose within the application and is very loosely coupled to (dependent upon) other layers.  

Layers, like software, allow you to implement change more quickly with fewer errors

For example, the Model-View-Controller (MVC) design pattern separates the functionality of an application into individual layers that interface with data sources (model), encapsulate business logic (controller), and interact with users and present data (view).  Because these layers are loosely coupled, they can each be quickly adapted to support new requirements while requiring little to no changes to the other layers. When you localize the impact of a change to just a specific layer, you minimize the amount of code that needs to be changed and thus implement change more quickly, and you reduce the risk of introducing new errors into your application.  

Also, your API program can be architected using a layered approach to achieve similar benefits, where each layer exposes APIs that serve a specific purpose and is loosely coupled to other layers.  This allows the APIs and their implementations at one layer to be changed without requiring changes within other layers. There are a variety of published best practices and architectures available that give you guidance on how to best layer your APIs. 

In addition, you will utilize different API technologies throughout your architecture to apply various advantages within the layers that best exploit them.  For example, RESTful APIs work well for creating abstractions of lower-level web resources such as customers or orders. But since RESTful APIs are each tightly coupled to a specific web resource, they are difficult to use to define flexible queries across multiple web resources (such as querying orders by a customer), and for building APIs that support different types of consumers and client environments that each require slightly different data from a single query.  For this layer of APIs, you should also look to use GraphQL APIs that provide a high degree of flexibility.

You only need one tool to develop an agile API program

You might think that you’d have to piece together many different tools to assemble the technologies and features needed for an agile, scalable API program.  However, you get everything you need within TIBCO Cloud™ Integration.

TIBCO Cloud Integration is comprised of multiple capabilities delivered within an integrated experience.  Each capability is tailored to a specific skill set – such as developers, integration specialists, application owners, and API product managers.  They also help you implement different integration use cases. 

Build event-driven APIs 

Event-driven APIs are able to deliver real-time responsiveness, support microservices development for optimal agility, and provide greater application scalability. The Develop capability of TIBCO Cloud Integration is based on the open-source Project Flogo, and lets developers easily build event-driven APIs and secure them with a microgateway. The AsyncAPI specification is quickly becoming the defacto standard for event-driven APIs, in part due to its native support for popular streaming frameworks like Apache Kafka. TIBCO Cloud Integration supports the AsyncAPI specification to enable new event-driven use cases. Ultimately, event-driven APIs enable easier adoption of loosely coupled microservices for more agility, provide mediation between events and microservices for security and scale, and provide a standardized specification for universal connectivity to events, services, and streams.

Manage the full lifecycle of your APIs 

Further, the Manage capability of TIBCO Cloud Integration provides full lifecycle API management tools for API product managers.  Thus, within a fully integrated environment, your business can create, implement, test, productize, secure, and analyze a fully layered API architecture under a single API management and integration license. 

Optimize the total cost of your API program 

TIBCO Cloud Integration is available on a subscription basis.  As your API consumption increases, the available subscriptions provide you a seamless growth path to easily add capacity for additional integrations and API traffic.  You can even augment your subscription with TIBCO Cloud Integration pay-as-you-go (PAYG) services from the AWS Marketplace to meet your peak API traffic—helping optimize the total cost of your API program.  

You can try TIBCO Cloud Integration for 30 days at no cost or obligation by registering for a trial edition, and quickly implement and deploy APIs in TIBCO Cloud.  

You can’t stop change from coming, but with a layered API program enabled by TIBCO Cloud Integration, you can adapt to change quickly and take advantage of opportunities that emerge from it.