The Operator’s Guide to Integration
November 19, 2025
Short read: NCSC Cyber Threat Report 2025, in plain English
January 20, 2026
The Problem
A system is down.
47 orders somewhere in the system, somewhere in the order workflow.
Customer on the phone asking where their order is.
Your help desk agent can't answer.
Your operations team is reconciling reports from three different systems.
This is what stateless integration looks like when it fails.
When integration breaks (and eventually, it will), you need to know exactly what happened. Not "we think some orders didn't process" or "maybe 50 transactions failed."
What Stateful Processing Means
Every transaction gets captured as integration state before we process it. Think of it like a financial ledger, every entry permanently recorded, nothing overwritten, nothing lost.
Order comes in? Database first, then process. Invoice generated? Database first, then send. Inventory update? Database first, then sync.
This is more complex than stateless processing, where transactions flow through the system without persistent storage. Stateless is faster, simpler, and honestly, easier to build.
So why do we persist everything?
The Operational Cost of Uncertainty
Before we made transaction persistence standard, we watched customers spend 5-10 hours every month reconciling data after system issues.
- "Did this invoice get sent?"
- "Which shipments updated inventory?"
- "Are we missing any EDI transactions from yesterday?"
Each question required manual checking across systems. That's expensive, frustrating, and potentially damaging to customer experience.
With Stateless Integration
You don't know what failed. You reconcile e-commerce orders against the ERP and wait hours for a manual check.
With Stateful Integration
You know immediately. 47 orders missed between 9:15am and 10:30am, ready to replay on review.
That's the difference: certainty over guesswork.
Three Things Stateful Architecture Enables
Transaction Replay
When something fails, query the database for failed transactions. Replay them. Done. Not "try to resend everything and hope we don't create duplicates" or "manually re-enter 50 orders."
This is particularly valuable for:
- System maintenance windows (planned downtime)
- API failures (when vendor system goes down)
- Network issues (connectivity drops)
- Integration bugs (something breaks in production)
Complete audit trail
Your customer asks: "When did you process my order? When did it ship?" Query the database. Timestamps and full transaction history are available. Done.
This matters for:
- Customer service inquiries
- Financial audits
- Dispute resolution
- Compliance requirements
- Performance monitoring
Cross-system insights
Because every transaction from every system is in one database, you can see relationships. This turns your integration platform into a source of business intelligence.
Some customers use this for:
- Executive dashboards showing real-time business metrics
- Root cause analysis when something goes wrong
- Understanding bottlenecks in their processes
- Reporting that spans multiple systems
Why We Made This Choice
In our first five years, we tried both approaches – stateless and stateful.
We watched customers operate with stateless integration and saw the operational cost:
- Hours spent reconciling after failures.
- Uncertainty about transaction state.
- Manual work that integration should have eliminated
We absorbed the development complexity, meaning the performance overhead is negligible for most transaction volumes. The infrastructure requirements are also more manageable.
But the operational benefit to customers equals:
- Knowing exactly what happened
- Being able to replay failed transactions
- Having audit trails
We built the complexity into the platform, so customers don't have to live with the operational cost of uncertainty.
The Bottom Line
Stateful processing is an architectural choice we made because we operate integrations long-term and see the operational benefit.
It's not the only valid approach. But for companies that need certainty about transaction state, the ability to replay failures, and complete audit trails, it's worth the architectural complexity.
We absorbed that complexity, so you get the operational benefit without having to build it yourself.
If you'd like to talk about integration architecture with someone who's lived with these trade-offs for 20 years, get in touch.
