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
Speed, performance and reliability are top priorities for API providers and consumers. APIs that provide real-time information need to be able to respond quickly to requests. Similarly, APIs that experience variable demand need to be able to scale up and respond to many concurrent requests.
Performance and speed optimization happen at both the platform level and the implementation level. At the implementation level, you can manage speed and performance with design techniques, like breaking down complex APIs into microservices, supporting pagination for larger payloads, filtering, and optimizing payload size. At the platform level, the Workato API Platform includes built-in optimizations to reduce latency, leading to faster response times.
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.
We designed our caching experience to be simple and easy to apply to an endpoint. You only need to switch it on and set the time-to-live period: the amount of time each request will be stored in the cache.
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.
Zero-logging
A second tool for managing implementation latency is the new zero-logging option. 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 the API Platform
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