Thursday, April 18, 2024
No menu items!
HomeData IntegrationA faster way to build performant low-code/no-code APIs

A faster way to build performant low-code/no-code APIs

Read Time: 7 minutes

For over a decade, companies have been using the power of APIs to make their public products consumable. In recent years, however, we’ve also seen an increasing trend towards publishing enterprise and partner APIs.

APIs give you a secure, flexible, scalable way to make your business processes consumable. You can use APIs to:

Give internal teams, retail partners and customers secure access to the same underlying processes, like support ticketing, order tracking, or inventory management.
Simplify security and role-based access control by exposing core data and functionality of your business apps via API.
Standardize workflows and create consistent business rules across your organization

However, despite all the benefits to be gained, demand for APIs often goes unmet. Why? Because traditional methods of API development, geared towards creating hyper-performant public APIs, are difficult, slow, and require a specialized skill set. To make enterprise APIs more feasible, companies need to achieve three things:

Slash the platform and ops overhead required to release an API
Accelerate and democratize the implementation of APIs
Maintain performance standards comparable with traditional API deployments

Workato’s API Platform empowers companies to achieve these objectives with:

A zero-ops approach to publishing APIs, with built in authentication, access policies
A low-code/no-code approach to implementation that allows functional teams to take a hand in implementing their own business logic, coupled with API-specific tools to speed up development
A dedicated API Gateway built from the ground up for scalability and speed

Getting out from under the overhead

Many modern API platforms and gateways are designed to give fine-tuned control over resource allocation and performance. This is necessary for APIs where to-the-millisecond responses are critical, such as payment processing, but it creates a significant barrier to adoption. The complexity of API tooling limits who can build APIs. It requires specific domain knowledge, regardless of whether the use case demands to-the-millisecond performance control.

Before you can respond to even the simplest GET request, you need to:

Decide on a language and framework
Create a server and set up hosting
Implement security and authentication
Set up policies for usage and rate limiting
Connect your implementation layer to your databases and business apps
Register a domain name and set up your DNS
Allocate compute resources
And a lot more

This inevitably means that much of the burden of API development falls to specialist ops teams, who quickly become a bottleneck.

Serverless architecture for zero-ops deployment

When you develop and deploy APIs through Workato’s API Platform, all of the above is handled for you. With a serverless architecture, you can deploy APIs in a few clicks, even to a custom URL. Authenticate clients with built-in, industry-standard patterns, such as Oauth 2.0. Set up custom access policies, usage limits,  and rate limiting. The API Gateway is designed for elasticity and automatically scales to meet spikes in demand. No human intervention is required. You can also access detailed logs and monitor the health of your APIs from a central dashboard.

By leveraging the API Platform, you not only reduce the time-to-market for your APIs, you also open up use cases that would have been rendered impractical by the overhead of traditional API development.

Speeding up implementation

Low-code/no-code development

Deploying APIs via Workato’s API Platform cuts out a lot of the ops overhead that traditional development requires, but you still have to create the actual implementation. Low-code/no-code development increases development velocity in two important ways. First, a visual building experience, equipped with prebuilt components and connectors, lets even your most tech-savvy users build faster. Secondly, your pool of potential builders increases when functional teams can implement their own business logic, so your IT teams won’t become a bottleneck.

The Workato API Platform is now a critical component of our operational processes across our products, customers, sales and more. The speed at which our team is able to learn Workato and build APIs is remarkable compared to other approaches that may take weeks of training.
– Alec Ellebracht, Staff Engineer, Confluent.

Beyond getting to market faster, empowering functional teams to implement also frees you up to iterate more often. Without needing to go back to IT for every update, you’ll have an easier time adapting to changing business requirements.

Collection generation with OpenAPI

OpenAPI is a universal format for designing and describing an API. Designers and developers use OpenAPI specs to collaborate with stakeholders, create documentation and even to spin up mock servers that consumers can use to develop clients before the API is production-ready.

Now, builders can also take advantage of OpenAPI specs to speed the development of APIs. Simply import an existing OpenAPI spec into Workato, and we’ll automatically generate an API collection, and create an API recipe for each endpoint.

Each generated recipe includes:

Input schema
Each possible response, including errors
Output schema for each response

All you have to do to release a working API is fill in the business logic in each recipe.

Check out the full blog to learn more about how to leverage OpenAPI specs to generate API collections.

Optimizing for performance

The API Platform’s zero-ops, autoscaling approach to API deployment makes it simpler, and more cost-effective to release APIs. In addition, recent investments in the overall design and performance of the API platform have greatly reduced latency and increased elasticity, such that all but the most performance-intensive use cases can now be met with low-code/no-code API development.

The enhancements Workato is bringing to its API Platform to improve performance, caching and elasticity will continue to separate them from other offerings on the market.
– Alec Ellebracht, Staff Engineer, Confluent

Reducing Latency

We typically measure the speed of an API in terms of latency: the delay between sending a request to an API, and receiving a response. Latency can be further divided into three types, each with its own causes and requiring its own reduction strategy.

Let’s run down some recent and upcoming developments aimed at reducing each type of latency in the API platform:

Network latency

Network latency is the time it takes for a request to traverse the physical network between the client and the server. The closer the server is to the client, the lower the network latency. Therefore, the most reliable way to reduce network latency is to increase the number of termination points for the API service, so that the client will always be physically close to one. 

To lower network latency for all customers across the globe, Workato has added a dedicated data center in Europe, with three additional centers planned in the APJ region. Just bringing the host closer to the client can cut overall response time by up to 90%.

Gateway latency

The API Gateway sits between the client and your implementation layer. The gateway receives and authenticates requests, enforces access and usage policies, monitors overall traffic, and handles load balancing. Gateway latency is the time it takes your API Gateway to process a request and pass it to your implementation layer. This year saw the release of version 2 of Workato’s API Gateway. This ground-up redesign emphasized reliability, higher availability, and greater tolerance to spikes in demand. The upgrade decreased average gateway latency by 50%.

When considering gateway latency, it’s important to look beyond average latency. When your APIs expose critical business processes, every request is important. For this reason, it’s important to consider other metrics, such as “P95” latency: the time within which your gateway can handle 95% or all requests. Improved auto-scaling capabilities in version 2 of the API gateway led to a 50% decrease in P95 latency.

Implementation latency

The final source of latency is your API implementation itself. That is, the time it takes to actually apply your business logic and do the work of responding to a request. Unlike network and gateway latency, implementation latency mostly comes down to the design of each individual API endpoint. A complex SQL query requesting thousands of records is going to take longer than returning a single record by ID. However, there are a couple of simple tools you can use to manage implementation latency, apart from optimizing individual recipe design.

API Caching

API Caching saves the response to a particular API request at the Gateway. If the same request is received again within a set time frame, the Gateway simply returns the cached response, instead of running the request through the implementation layer again. In effect, caching can completely remove implementation latency for a significant portion of requests.

For example, these logs show response times of 200+ milliseconds to process a standard request, but cached requests take only 1-2 milliseconds.

Apply caching selectively to use cases where:

A fast response is critical
Clients need to request the same record often
Information returned by the API changes slowly, and to-the-second accuracy is not critical. 

You can read more about caching here.


A second tool for managing implementation latency is the zero-logging option, scheduled for release later in March. By default, whenever an API call is made, detailed logs are kept for each action in the underlying recipe, recording the input and output of each action, and a stack trace for all requests. While these logs are important for tracking and auditing requests, they do increase latency. For use cases where response time is critical and log retention is not required, you can disable logging for an individual recipe. 

Disabling logging creates a significant saving in implementation latency. The more steps your recipe contains, the more time you’ll save by turning off logging.

Find out more

To learn more about how API Platform can help you make your business processes consumable with APIs, check out:

More detail on generating an API collection from an OpenAPI spec
More on implementing API caching
Out Product Hour session on the low-code/no-code approach to API development, featuring Ee Shan Sim, product manager for the API Platform
Detailed API platform documentation

The post A faster way to build performant low-code/no-code APIs appeared first on Workato Product Hub.

Read MoreWorkato Product Hub



Please enter your comment!
Please enter your name here

Most Popular

Recent Comments