API Performance Tuning

APIs/Services performance plays an important role in providing a better experience to the users. There are many ways available through which we can make our APIs/services perform better. In this article, we are going to see some such tips to improve the performance of the APIs/Services. 

Below are some of the metrics that we need to consider while optimizing the performance of APIs/Services:

• Response Time: Measures how quickly the APIs/Services are responding.
• Payload and its size: Amount of data transported over the network.
• Throughput: Number of times the APIs/Services are being invoked.

The above parameters need to be optimized to make the APIs/Services perform better. Below are some of the techniques which can help to improve those:

Caching

This is one of the widely used techniques to reduce the hits going to the server while calling the APIs/Services and thereby reducing the time taken to serve the requests to the client. Caching can be done at the CDN layer or at the API Gateway layer, or in both, depending upon the need to avoid the calls going to the server. APIs that return the same response without any change in the contents can be considered for this caching. Cache duration has to be set accordingly to fetch the latest response from the server. 

Compression

Compressing the contents before transporting them over the network avoids the latency at the network layer. Compressions like Brotli or GZip can be used to achieve this. Though it adds a processing overhead of compression/decompression, the amount of time spent on it will be lesser than the amount of time spent transporting the data over the network.

Payload Size

The amount of data returned by the server as a response to an API plays a major role in deciding the performance of that API. Sending only the needed data to the client reduces the network and other overheads in transporting the data to the client. 

Logging

Avoid excessive logging of data to the log files, as this makes the server spend time on logging instead of spending time processing the request. Set to appropriate log level to avoid detailed logging. As a best practice, consider checking for log levels before logging, irrespective of the log levels configured. This would avoid the string concatenation or object conversion operations that happens while the parameter is being passed to the logger methods. This would save the memory and execution time of the code. For example, in Java, the below statement will do the concatenation of the String even though the log level is set as INFO. 

log.debug("This is a test "+"Message"); 

Asynchronous logging is another option that can be considered to improve performance, as it doesn't wait for the logging to be completed. The only drawback of this approach is that there may be a delay in logging the details into the log file. 

Optimizing the API/Service Code

Following are some of the best practices that can be followed to optimize the code at the server level:

• Caching frequently accessed contents on the server. For example, frequently accessed data from DB can be cached to avoid the calls going to the database.
• Avoiding conversion of contents from one format to another. For example, converting JSON to String is a costlier operation in Java and should be avoided as much as possible.
• Fetch only the data needed from the database or from any other data source.
• Use connection pooling to connect to DB or any other data sources.
• Eager initialize the contents/objects/details that are needed for the application during the start-up in order to avoid the time spent on the initial requests.
• Avoid/reduce the synchronization area/block within the code.
• Configure proper timeouts to external/third-party calls to avoid thread waits.

Auto-Scaling

Auto-scaling is another capability through which we can improve the performance of the APIs/Services by scaling up/down the number of application instances to serve based on the incoming traffic. The capacity of the single instance needs to be measured, and the number of instances to be scaled up/down can be decided to depend upon the expected traffic to the APIs/Services. Apart from that, the size of the instance can be decided based on the infrastructure needed or available. Finalize the instance size and scaling needs by conducting performance testing before the application goes to production. 

Settings

Optimize application and application server-related settings for optimal performance. Below are some of the areas which can be optimized for better performance:

• Connection Pool 
• Thread Pool 
• Memory and GC  
• Cache/Cache framework
• Auto-scaling 
• Web server
• Other framework/third-party applications used in the application.

It would be good to tune these settings by conducting performance testing that simulates the production-like behavior. 

Optimizing the performance of APIs/Services helps to improve the overall user experience on the application/website and also optimizes the infrastructure used by it. This can be achieved using some/all of the above-listed best practices or tuning tips. Of course, there are pros and cons to all these approaches. Strike the right balance based on the needs of your application.