The hallway consensus
Sibos didn’t feel like a payments conference. It felt like an interoperability summit.
It seemed every conversation eventually converged on the same point: the industry is stitching together old rails and new ones—ISO 20022 migrations, urgent upgrades to support cross‑border payments, rapid adoption of tokenized deposits and stablecoins, “network of networks” experiments—into something coherent enough to run at global scale. That only works if the systems interoperate. And the only way we get to interoperability is through APIs.
The difficulty is not the lack of standards, or even the engineering effort. It’s that different stakeholders see different systems. A CIO hears “ISO 20022 and CBDC corridors.” A treasurer hears “reporting first, then payments.” Compliance hears “LEI, KYC registry, audit logs.” Engineers hear “authentication, pagination, payload shape.” If we can’t show how it all fits together, adoption stalls.
The world is moving faster than people can visualize
Four threads kept surfacing:
- Legacy → next‑gen rails, under deadline. Turning on standardized statements and status messages are squeezing multi‑year transitions into quarters–look to ISO 20022/SWIFT migrations, real‑time clearing, and "reporting‑first" rollouts. The burden shows up as extra work across API programs (versioning, webhooks, idempotency), data models (ISO ↔ legacy mapping), and change management (training, controls, cut‑over rehearsals).
- Network of networks. Legacy rails (SWIFT, ACH/RTGS, card, SEPA Instant/RTP) and blockchain rails (tokenized deposits, stablecoins) are starting to interoperate. The pattern: run pre-validation, KYC/LEI, and sanctions controls at the endpoints, then move instructions and status over standardized interfaces (ISO 20022-shaped APIs/webhooks) so a single product can route across rails and reconcile the same way.
- Digital assets as workflows. Tokenized deposits and stablecoin pilots have moved from white papers to treasury operations. The question is no longer if, but how safely and how soon.
- Agentic protocols are coming. "Agent‑to‑agent" means software actors call each other directly using signed intents and receipts, without a human clicking “Pay” each time. Early protocols include Coinbase’s x402, Google’s Agent Payments Protocol (AP2), and Visa’s Trusted Agent Protocol. This shifts risk from UI errors to policy & control: what scopes and limits were granted, for how long, who can revoke, how rate‑limits and human‑in‑the‑loop escalations work, and whether you can simulate before sending. When code can move funds on behalf of millions of customers, failure modes (looping retries, stale authorization, prompt‑injection on instructions, time‑of‑check/time‑of‑use) suddenly become board‑level concerns. Interoperability here will hinge on standard messages for intent, authorization, limits, receipts, revocation, and audit, plus deterministic retries and idempotency across agents.
None of this is easy to visualize, especially across teams with varying responsibilities, which is precisely why interoperability work so often dies in committee.
Why regulated industries struggle
Banking is the canary, but this pattern repeats whenever regulation meets software.
- Many stakeholders, different altitudes.
- Treasury thinks in cash positions and FX hedges.
- Risk thinks in exposure limits and control points.
- Compliance thinks in audit trails and reportability.
- Engineering thinks in endpoints and error handling.
- Executives think in P&L and strategic positioning.
Show them the same architecture slide and receive five different interpretations.
- Legacy infrastructure we can’t rip out. We can't turn off the COBOL that moves public markets, the EHR that runs a hospital, or the SCADA system that stabilizes a grid. New has to interoperate with old in real time, under load, at global scale, and with humans in the loop.
- The compliance labyrinth. A “format change” isn’t just a new file shape; it can mean a schema/version change, code‑list/field semantics (status reasons), transport (SFTP batch → API + webhooks), or identifiers/reference data (BBAN → IBAN, LEI required). Each one ripples through validation rules, exception routing, reconciliation and audit evidence, access controls, and even RACI/org charts. Organizations can’t certify compliance until they simulate production‑grade behavior: real payload sizes, cut‑offs, time zones, concurrency, rate limits, and human‑in‑the‑loop escalations.
The visualization gap
Most failed modernization efforts don’t fail because the technology is impossible; they fail because the people approving and operating them see completely different pictures—a classic collective-action problem (no single team can justify the change until every team commits, so everyone waits for everyone else).
PowerPoints live at a 30,000‑foot altitude. API docs live at the code‑path altitude. Process maps live at the runbook altitude. Audit frameworks live at the regulator’s altitude (which varies across regulatory entities). What’s missing is a single artifact that spans all altitudes—high enough for strategy, low enough for HTTP details—where a treasurer can see cut‑offs and funds‑availability, an engineer can see retries and idempotency keys, an ops manager can see escalation paths, and a compliance officer can see the immutable audit trail.
That’s not a documentation problem. It’s a demonstration problem.
Why demonstration beats documentation
Take a tokenized‑deposit flow. The slideware version goes: “wallet debits → blockchain settlement → bank system update → confirmation.”
The real question everyone has: What happens when something goes wrong? For example: the blockchain transaction succeeds but the bank’s core update fails; or the webhook times out; or the counterparty’s pre‑validation flags an LEI mismatch; or an agent hits a 429 and retries into a cutoff.
The only way to align stakeholders is to show them what it means in the context that matters to them:
- Kick off the payment.
- Watch the API calls, headers, and payloads.
- Inject a failure (timeout, 409, sanctions hit, stale nonce).
- Watch idempotency and retry logic in action.
- See the customer experience update (“processing” → “settled”).
- See the reconciliation queue entry created.
- See the operations dashboard flag for review.
- See the audit log populate with who/what/when/why.
One artifact. Five audiences. Shared understanding. A universal language for interoperability.
A short playbook for interoperability projects
When running a migration, building cross‑rail flows, or gluing legacy to new, this is the fastest path to credibility:
- Build the shared artifact. Create an interactive demo that renders the business journey and the raw HTTP simultaneously. Avoid screenshots. Use real sandboxes where possible; intelligent mocks where necessary.
- Demo failure paths first. Stakeholders don’t need to be sold on the happy path. They need to see cutoffs, reconciliation, sanctions, rate‑limits, and human handoffs. Things inevitably go wrong, and getting to production means having an understanding and plan of what happens when they do.
- Personalize by role. Let a treasurer filter by value‑date, an ops lead trigger manual review, an engineer toggle authentication modes, and a compliance officer export an audit trail.
- Move risk left. Force disagreements to surface in the demo phase, not in month six of implementation.
Make it portable. The identical artifact should work in docs, in a sales deck, in an RFP, and embedded in an internal runbook.
Beyond banking: the same movie in other industries
- Healthcare. FHIR mandates are pushing EHRs, payers, and health‑tech vendors into live data exchange—without violating HIPAA or breaking billing. Doctors, nurses, admins, and insurers see different “systems” until you demonstrate the same workflow to all four.
- Government. Inter‑agency workflows marry mainframes to modern portals. You don’t get budget approval with a block diagram; you get it by showing a committee exactly how fraud checks, privacy controls, and outward payments line up under load.
- Energy. Grid modernization is API integration in five‑minute intervals. Regulators need visibility, operators need stability, and distributed resources need to plug in safely. Show the telemetry, the dispatch rules, and the failover.
- Supply chain. Digital product passports and provenance require manufacturers, logistics providers, retailers, and recyclers to agree on identifiers and events. Slides won’t persuade a skeptical COO; demonstrable traceability will.
The common thread: you can’t modernize faster than your stakeholders can visualize.
Where Coast fits
We built Coast to make this kind of demonstration trivial to produce and impossible to misunderstand.
- Build once, personalize infinitely. Start from a template (say, a cross‑border payment with pre‑validation). Generate a prospect‑specific version that reflects their rails, their controls, and their error handling.
- Live or mocked, your choice. Mix live sandbox calls with intelligent mocks. Business users see a polished flow; engineers see actual HTTP traffic, including headers, retries, and webhooks.
- One artifact, all audiences. The same demo satisfies business, technical, ops, and compliance stakeholders—without context‑switching between slideware and API docs.
- Embeddable everywhere. Drop it into docs, decks, RFPs, and internal runbooks. The demo becomes the standard.
If your next 12–24 months include “make these systems talk to each other,” Coast gives you the shared mental model to do it without wasting quarters on misalignment.
The takeaway
Interoperability isn’t a vendor choice or a lift‑and‑shift. It’s a communication problem masquerading as an integration project. The organizations that win will be the ones that demonstrate complex behavior clearly—before they commit budget—and align every altitude of the enterprise around the same, living artifact.
Static documentation can’t do that. Interactive demonstration can.
If you’re wrestling with cross‑rail payments, FHIR rollouts, grid telemetry, or provenance mandates—and you’re selling the vision to a room full of mixed stakeholders—let’s build the demo that makes it obvious.
By Ben Parks, GTM @ Coast
