Retry Logic

/rɪˈtraɪ ˈlɒdʒɪk/

noun — “the system’s way of saying, ‘let’s politely ask again before giving up entirely.’”

Retry Logic is the programming and system design strategy of automatically re-attempting an operation that has previously failed, usually due to transient or recoverable errors. This technique is widely used in network communications, API requests, database operations, and distributed systems, where temporary hiccups like dropped connections, timeouts, or service overloads are common. It works hand-in-hand with Error Handling and Idempotent operations to prevent repeated failures from causing unintended side effects.

In practice, retry logic often includes rules such as the number of maximum attempts, delays between retries, and exponential backoff strategies to avoid overwhelming a system. For example, a web client might retry a failed HTTP request three times with a delay that doubles after each failure. When combined with idempotent operations, retry logic allows applications to safely re-issue requests without risking duplicate processing, making systems more robust and reliable.

Retry logic is especially important in cloud environments, APIs, and distributed architectures, where failures are inevitable due to network instability or temporary resource constraints. It integrates naturally with Logging to track retries, with Data Validation to ensure consistent input, and with API Design to guarantee predictable outcomes.

Some illustrative examples:

// Simple retry logic in Python
import time

def fetch_data():
    for attempt in range(3):
        try:
            return get_data_from_server()
        except ConnectionError:
            print(f"Attempt {attempt + 1} failed, retrying...")
            time.sleep(2)
    raise Exception("Failed after 3 retries")

// JavaScript retry with exponential backoff
async function fetchWithRetry(url, retries = 3, delay = 1000) {
    for (let i = 0; i < retries; i++) {
        try {
            const response = await fetch(url)
            if (!response.ok) throw new Error("Request failed")
            return await response.json()
        } catch (err) {
            console.log(`Retry ${i + 1} failed, waiting ${delay}ms`)
            await new Promise(res => setTimeout(res, delay))
            delay *= 2
        }
    }
    throw new Error("All retries failed")
}

// API request with idempotent POST
POST /payments with idempotency-key
// repeated requests with same key do not create duplicate charges

Retry Logic is like gently knocking on a stubborn door multiple times: eventually, it opens without breaking anything inside.

See Error Handling, Idempotent, API Design, Logging, Network Protocols.