At 10 a.m. on a Monday, the shipping-rate provider slows down. It doesn’t go down — it just starts responding in 40 seconds instead of 400 milliseconds.

Within minutes, checkout freezes. Server connections are exhausted waiting for replies. The product catalog, which has nothing to do with shipping, slows down too because it shares the same resources. The support team can no longer look up orders. The dashboard says the site is “up,” but nobody can buy anything.

The failure belonged to a vendor. The outage belonged to the whole company.

This scenario is more common than it seems. Companies increasingly depend on external services: payments, tax and invoicing, logistics, identity, messaging, fraud detection, cloud ERP. Each of them will fail at some point. The question is not if, but how your operation behaves when it happens.

My position: every external integration needs an explicit failure policy — how long to wait, what to do without a response, what can keep working, and how to recover afterwards. Not every failure has to stop the customer’s entire journey.

Why a slow integration is worse than a dead one

When an external service goes completely down, the error shows up fast: the connection is refused and the system can react.

When the service turns slow, the problem is sneakier. Every request waits, holding connections, memory, and processing capacity. If the system sets no limit on how long to wait, those requests pile up until resources run out — and one vendor’s slowness spreads to features that do not even depend on it.

That cascade is why many serious outages start with a secondary dependency that simply got slow.

Five questions for every critical integration

Before discussing techniques, answer these for each relevant external service:

  1. What happens to the operation if this service is unavailable for 5 minutes? For 4 hours?
  2. How long is it worth waiting for a response?
  3. Can the operation continue without it, even in a reduced form?
  4. If the operation is deferred, how and when will it be completed?
  5. Who gets notified, and how do we know the service is back?

These are business questions before they are technical ones. Whether an order can be accepted without immediate shipping confirmation is a decision for the commercial team, not the developer.

Strategies that keep operations running

Explicit timeouts

Every external call needs a timeout consistent with the expected experience. If a customer won’t wait more than 5 seconds to see a shipping cost, there is no point in the system waiting 60.

Short, deliberate timeouts stop a vendor’s slowness from consuming your own resources.

Circuit breakers: stop insisting when a service is struggling

A circuit breaker works like an electrical breaker. When a service’s failures exceed a threshold, the system stops calling it for a while and immediately responds with an alternative. Later, it carefully tests whether the service has recovered.

This protects the company — which stops wasting resources — and the vendor, which isn’t flooded with retries while trying to recover.

Planned degradation

This is the strategy with the greatest business impact. Instead of “it works or it doesn’t,” the company defines what keeps working in a reduced form:

Unavailable serviceUnplanned behaviorPossible degradation
Shipping ratesCheckout blockedUse a standard regional rate table and adjust later, within defined rules
Fraud detectionNo orders approvedAuto-approve low-value orders from returning customers; queue the rest for review
Tax/invoicing serviceOrder cannot be completedAccept the order and issue the document once the service returns, within legal deadlines
Product recommendationsProduct page errorsShow the category’s best sellers
Email deliverySign-up failsComplete sign-up and send the confirmation later

Illustrative examples. Each degradation must be assessed against the company’s financial, tax, and regulatory risks.

Not every operation can degrade — sometimes stopping really is the right call. What matters is that the choice is deliberate, not an accidental consequence of the architecture.

Queues and asynchronous processing

Many operations don’t need to finish the instant the customer clicks. When the order is recorded and the subsequent steps are processed through a queue, a temporary vendor outage only delays processing instead of losing it.

Queues also let you control pace: instead of firing a thousand simultaneous requests at a partner that supports a hundred, the system processes at an appropriate rate.

Concurrency control

Even when the vendor is healthy, excessive volume can trigger rate limiting or degrade the service. Limiting how many simultaneous operations each integration can run is a simple, effective safeguard.

Platforms are starting to build this in. In November 2026, Cloudflare announced in its changelog per-Workflow concurrency control, allowing excess instances to queue instead of all running at once. It isn’t an automatic solution for other stacks, but it illustrates the principle well: protecting your dependencies is part of system design.

Retries with discipline

Retrying makes sense for transient failures, but it needs a limit and increasing intervals between attempts. Aggressive, simultaneous retries turn instability into overload.

And every operation that may be repeated must be idempotent: trying twice cannot produce two charges, two orders, or two invoices.

Reconciliation

When operations are completed later, you need to verify that everything was actually processed. A reconciliation routine compares what should have happened with what did happen and flags gaps — before the customer or the finance team finds them.

An example: the distributor and the cloud ERP

Consider a fictional distributor whose ordering portal queries a cloud ERP to validate credit and availability for every new order.

Before: whenever the ERP became unstable, the portal stopped. Sales reps wrote orders down in spreadsheets and re-keyed them later, with errors and duplicates.

After:

  • the portal applied a wait limit of a few seconds for the ERP;
  • stock availability started being read from a periodically refreshed copy, with a warning when the data is stale;
  • orders from customers with recently approved credit are accepted and queued for confirmation;
  • orders from new customers or above a defined value wait for the ERP to return;
  • an end-of-day reconciliation compares accepted orders with those recorded in the ERP.

Illustrative example, unrelated to any real client.

The ERP still failed occasionally. The difference is that sales didn’t stop.

Signs your integrations need a review

  • Instability at one vendor has already caused outages in unrelated features.
  • Nobody can say what timeout is configured for the main integrations.
  • There is no defined behavior for when an external service is down.
  • Operations lost during failures are recovered by hand — when someone notices.
  • Calls to a partner are unlimited, and you’ve already been rate-limited.
  • Contracts with critical vendors lack service levels, or those levels were never compared with what the business actually needs.

Frequently asked questions

Do I need microservices to apply these strategies?

No. Timeouts, circuit breakers, queues, and planned degradation apply to monoliths too. What matters is treating every external dependency as a possible point of failure.

Doesn’t a vendor with a strong SLA solve this?

It helps, but it doesn’t remove the problem. A 99.9% SLA still allows more than eight hours of downtime a year — and contractual credits are usually far smaller than the cost of a stalled operation.

Where should we start?

List your external integrations, identify those that support critical processes, and answer the five questions in this article for each one. Start with the integration whose failure would cause the greatest impact.

How do we test whether operations can withstand failures?

Simulate failures and slowness in controlled environments and observe the behavior. Discovering weak points in a planned test is far cheaper than discovering them during a real incident.

Conclusion

External dependencies are unavoidable. Being held hostage by them is not.

A resilient architecture doesn’t promise that nothing will fail. It ensures that every failure has a predictable behavior, a limited impact, and a clear path to recovery.

If a third-party integration can halt an essential process in your company, it’s worth reviewing those dependencies and the expected behavior during failures.

Reach out through the contact page. Engineering and consulting engagements are delivered by IVATEC. For a deeper technical look at coordinating distributed processes, the article on the Saga pattern with .NET, MassTransit, and RabbitMQ offers a complementary approach.