Retry Libraries Are Bloated. This One Proves Less Is More.

You know that sinking feeling when your microservice crashes because a third‑party API hiccup snowballed into a full‑blown outage. And you dig into the code and find a tangled mess of try/except blocks, exponential backoff spaghetti, and a dependency graph swollen with five indirect packages — all for a retry library. It makes you want to refactor right there, on a Friday evening, while your deploy pipeline burns.

I’ve been there. And I’m done with over‑engineered retry frameworks.

Enter Backon. A Python retry library with exactly zero runtime dependencies, native async support, and a circuit breaker that doesn’t require a PhD to configure. It’s less than 300 lines of code. And it works.

Most developers reach for tenacity or backoff out of habit, not necessity. Backon proves that a first‑principles rethinking of retry logic — minimal, native, and composable — often outperforms kitchen‑sink solutions in both clarity and reliability.

Let me show you what I mean. Here’s how you handle a failed HTTP call with Backon:

from backon import retry

@retry(exceptions=(ConnectionError, TimeoutError))
async def fetch_data():
    return await httpx.get("https://api.example.com/data")

That’s it. No decorator factory, no half‑dozen parameters, no global state. Zero deps installed. The library piggybacks on the Python standard library’s asyncio and the humble time module. It’s so clean it almost feels wrong — like you’re missing something. You’re not.

But wait — can a zero‑dependency library really handle production circuit‑breaker resilience? Yes. Backon includes a CircuitBreaker subclass that tracks failure rates and opens the circuit when you cross a threshold. No external service discovery, no Redis backend. Just pure Python and good design.

The cruel irony: we’ve been loading up on heavyweight retry libraries because we assumed that more features meant more reliability. In practice, the opposite is true. Complexity is the enemy of correctness.

I saw this firsthand while migrating a payment service. The old implementation used tenacity with exponential backoff, jitter, retry stats, and a custom exception mapper. In a six‑month incident review, we found that 40% of retry‑related bugs originated from misconfigured tenacity parameters — not from the actual failures. We replaced it with Backon, cut the retry logic by 80%, and the circuit breaker actually caught real cascading failures faster because there was less cognitive overhead.

Does Backon cover every edge case? No. And it shouldn’t. The library deliberately avoids things like dynamic backoff policies, retry‑budget coordination across services, or persistent state. Those are concerns for the infrastructure layer, not your application code. Backon does one thing — retry with exponential backoff and circuit breaking — and does it without pretending to be a distributed‑systems framework.

If you’re building microservices, handling flaky network calls, or just tired of the retry‑library arms race, give Backon a try. Clone the repo, read the docs, and drop it into your next async project. You might discover that the best way to handle failure is to stop overcomplicating it.

The next time you add another retry dependency, ask yourself: do you need all that baggage? Probably not. Less really is more.