Implementing an Exponential Backoff Strategy for Flaky APIs in Kotlin

I recently had to implement a set of API endpoints to an android application and faced something I haven’t faced in a very long time, more specifically in a production environment. An unstable service that was intermittent bringing in a lot of complaints from the end users.

Dealing with flaky or intermittent APIs can be a pain. Network issues, server downtimes, and rate limits are just but a few of the problems that can cause API calls to fail. In my case it was server issues and a background sync using pagination that I needed to accomplish using a periodic work manager. Basically what was happening was I needed to sync data from an endpoint with pagination and save that data onto room db for an offline first approach android application. This proved to be a problem as getting to certain offsets in the pagination were intermittent and an average retry of 3 times would solve this issue.

To handle this scenario gracefully, implementing a retry strategy with exponential backoff was crucial. This approach not only retries failed requests but also increases the delay between each attempt, reducing the load on the server and improving the chances of success and in my case a complete and successful sync was made possible due to it.

What is Exponential Backoff?

So what exactly is exponential backoff? In simpler terms, it is a strategy where the delay between api retry attempts increases exponentially. For instance, if the initial delay is 1 second, the subsequent delays might be 2 seconds, 4 seconds, 8 seconds, and so on. This approach helps mitigate issues like temporary server unavailability or network congestion, allowing sufficient time for the system to recover before making another attempt.

Implementing Exponential Backoff in Kotlin

Below is an exponential backoff strategy in Kotlin using a suspend function.

How It Works

Parameters:

• times: The maximum number of retry attempts.
• initialDelay: The initial delay before the first retry attempt.
• maxDelay: The maximum delay between retry attempts.
• factor: The factor by which the delay increases after each attempt.
• block: The suspend function representing the API call or any operation to be retried.

Logic:

• The function starts with an initial delay.
• It attempts to execute the provided block of code.
• If the block fails, it logs the exception and waits for the current delay period.
• The delay is then exponentially increased, capped at the maximum delay.
• This process repeats until the maximum number of attempts is reached.
• If all attempts fail, the function executes the block one last time, allowing the final exception (if any) to propagate.

Example Usecase:
Imagine you’re working with an API that occasionally fails due to server issues. Using the retryWithBackoff function, you can gracefully handle these intermittent failures:

Conclusion

Exponential backoff is an effective strategy for handling flaky/intermittent APIs. It minimizes the load on your server and increases the chances of success by spacing out retry attempts. Implementing this strategy in Kotlin is straightforward and can significantly improve the robustness of your application’s network interactions.

With this approach, you can ensure that your application remains resilient and can handle intermittent failures gracefully, providing a better experience for your users.