I Designed an Integration Layer That Expects Vendors to Fail
A resilient boundary that keeps core workflows moving when an external service slows down, changes, or disappears.

LIVE SIGNAL · INTEGRATIONS · V2.4 · PROD
0103
In plain English
This concept creates a stable layer between the business and the vendors it depends on. External services can become slow, return the wrong shape, or go offline without forcing the core product to fail in the same way.
Business value
- More reliable day-to-day usage
- Better operational visibility
- Easier maintenance
- Less manual work
- Role
- Integration strategy, API contracts, reliability patterns, backend services, observability, recovery design
- Design · Build · Ship
- Timeframe
- 2026
- Domain
- API integrations, vendor reliability, distributed systems
- Category
- Integrations
- Placed every vendor behind a platform owned adapter contract.
- Used a durable outbox, idempotency keys, bounded retries, and circuit protection.
- Validated and deduplicated every inbound event before it could change business state.
- Designed reconciliation and operator recovery for ambiguous outcomes.
- Placed every vendor behind a platform owned adapter contract.
- Used a durable outbox, idempotency keys, bounded retries, and circuit protection.
- Validated and deduplicated every inbound event before it could change business state.
- Designed reconciliation and operator recovery for ambiguous outcomes.
Your Product Is Only as Stable as Its Dependencies
An integration often begins as a small request between two systems. It becomes dangerous when the business quietly starts depending on it for payments, identity, inventory, messaging, or delivery. At that point, a vendor incident is no longer someone else’s problem. It becomes a broken customer journey inside your product.
For this independent concept study, I designed an integration layer that treats external failure as normal operating reality. The goal was not to hide every outage. It was to protect the core workflow, preserve intent, and give operators a clear path to recovery when a provider behaves badly.
The Dangerous Space Between Sent and Completed
Direct API calls create a simple architecture until they become a dependency chain. A slow vendor holds open application requests. A repeated callback creates duplicate records. A changed field breaks parsing. A timeout leaves the business unsure whether the action failed or completed somewhere else.
The system needed to handle uncertainty without producing silent data loss. It also had to support multiple vendors without spreading provider specific logic through the product. Recovery had to be safe enough for operators to use under pressure, with clear evidence of what happened and what the system would do next.
The difficult question was not how to retry a request. It was how to preserve business intent when the external world cannot give a reliable answer.
Ownership
Everything I designed, built, and was accountable for.
Product & UX
- Reconciliation and recovery workflows
Engineering
- Integration strategy and contract design
Additional scope
- Adapter layer and durable delivery flow
- Webhook validation and deduplication
- Observability and failure testing plan
Key decisions
The calls I made, what I rejected, and why: these are the tradeoffs that shaped the system.
Place every vendor behind a platform owned adapter
Let provider payloads flow through the core application
A stable internal contract prevents vendor details from spreading into business logic.
Retry is a mechanism. Recovery is a system.
Create a Boundary the Business Can Trust
I placed every vendor behind an adapter contract owned by the platform. The core application sends business commands such as create shipment or capture payment without depending on a provider payload. Each adapter translates that command, validates the response, and stores the external reference separately from the internal record.
Commands enter a durable outbox before delivery. A worker sends them with an idempotency key, records every attempt, and applies bounded retry rules with increasing delay. Circuit protection stops repeated calls when a provider is unhealthy. Failed work moves into a recovery queue with the original intent, current state, and reason for failure intact.
Inbound webhooks pass through signature checks, schema validation, deduplication, and ordering rules before they can change business state. Unknown fields are preserved for diagnosis while invalid events remain isolated from production data. A reconciliation worker compares internal expectations with provider records so ambiguous timeouts can be resolved safely.
The operator view is built around recovery. It shows which vendor is degraded, which workflows are waiting, what has been retried, and which items need a human decision. Traces connect the customer action, internal command, vendor attempt, callback, and final state without exposing secrets.
feedback · calibration loop
Backend
Database
Infrastructure
Also used
When the answer is uncertain, preserve intent and reconcile from evidence.
Failure Becomes Visible and Recoverable
- Business intent preserved
- Duplicate outcomes prevented
- Vendor failure isolated
- Recovery trail visible
The result is a vendor boundary, delivery pipeline, recovery queue, reconciliation process, and observability model that can be tested before production. It is an independent reference architecture rather than a claimed client deployment.
The design has four acceptance rules. No business command can disappear after it is accepted. A repeated request must not create a duplicate outcome. An ambiguous timeout must enter reconciliation instead of being guessed. An operator must be able to see the full decision trail without reading raw logs.
This architecture lets the product remain honest during failure. Some actions may wait, but the system keeps their intent, explains their state, and recovers deliberately. That is the difference between an integration that merely works in a demo and one the business can depend on.
No accepted business command disappears during vendor failure
This design protects customer workflows from external instability. It preserves every accepted action, prevents duplicate outcomes, and gives operators a clear recovery path when a provider is slow or wrong. These are design targets for an independent concept, not measured production results.
“Rusty understands the difference between adding features and making software actually usable. He looks at how people work, finds the friction, and improves the system in a way that makes daily operations feel smoother.”
Operations Stakeholder
Internal Platform Team — name under NDA
What I Would Break on Purpose
The biggest lesson is that reliability lives at the boundary. A vendor contract can look clean while the real world still produces delay, duplication, reordering, and partial success. The design has to represent those states instead of forcing them into success or failure too early.
I would test recovery before testing speed. Teams often benchmark the happy path while the expensive incidents happen in the uncertain path. I would inject timeouts, repeated callbacks, malformed responses, and delayed events until operators can recover without improvisation.
The next step would be a shadow integration against one provider. It would process real traffic without controlling live outcomes, giving the team evidence about retry volume, event order, schema drift, and reconciliation accuracy.
A resilient integration does not promise that vendors will behave. It preserves business intent when they do not.
External failure should become a managed state, not a customer mystery.
10+
3
5+
10+
Need similar work for your business?
I help product teams ship reliable backend systems. Let's talk about your project.
Start a Project