Systems that finally agree with each other.
Make the systems you already pay for talk to each other — cleanly, observably, on contract. Webhooks that retry. Pipelines that don't lose events. Reconciliation for the day something inevitably drifts. We've spent a decade in the messiest integration surface there is: hospitality.
An integration is a contract, not a connection.
Most integration pain is really a contract problem. Two systems agree on a happy path and nothing else. We design the boundary first — what the data means, what happens when it's late, what happens when it's wrong — and then write the code that honours it.
We start by mapping the real flow of events across the systems you have, including the ones nobody documented. We find where data is silently lost, duplicated or reordered today, and we design an anti-corruption layer so your domain doesn't inherit someone else's schema.
What you're left with is an integration layer you can reason about: idempotent, observable, and recoverable. When a third party has an incident — and they will — the failure is contained, visible, and replayable, not a 3am mystery.
Map, contract, build, reconcile.
Four phases that assume things will go wrong, and design for that from the start.
Map
We trace every event across every system, including the undocumented ones. Where data is lost, duplicated or reordered today — written down, with evidence.
Contract
We define the boundary: schemas, semantics, retry and idempotency rules, and what "consistent enough" means for your business. The boring document that prevents the exciting incident.
Build
An anti-corruption layer, idempotent consumers, retries with backoff, and a dead-letter path that a human can actually act on. Observability written alongside the code.
Reconcile
A continuous reconciliation job that proves the two systems still agree — and tells you, in plain language, the moment they don't.
What we actually do.
The integration surfaces we've already been burned on, so you don't have to be.
PMS & channel managers
The hardest integration surface in hospitality. We've worked across the major property-management and channel systems and know where the bodies are.
Payments & reconciliation
Stripe, Adyen and the long tail of acquirers. Event-sourced reconciliation that survives audits and chargebacks.
Identity & SSO
OIDC, SAML, SCIM provisioning. Single sign-on that works for the enterprise buyer without breaking the small one.
Event pipelines
Durable, ordered, idempotent. Queues and streams that don't lose events under load and don't replay them into chaos.
Webhook infrastructure
Inbound and outbound. Verified signatures, retries with backoff, replay, and a dashboard your support team can use.
API design & gateways
Public and partner APIs that age well. Versioning, rate limits, contract tests, and documentation people actually read.
Tools we keep returning to.
Durable, observable, boring. Integration is the wrong place to be adventurous.
Webhooks · gRPC
Temporal · BullMQ
Outbox · CDC
Grafana · Sentry
Recent integration work.
Most of it runs quietly between two systems. These are the ones we can describe.
One channel layer, nine PMSs
A single integration layer in front of nine different property-management systems. Onboarding a new property went from weeks to a day.
Reconciliation that survived audit
An event-sourced reconciliation pipeline for ~€420M/year of volume. Zero unresolved breaks across 18 months in production.
SSO without the rebuild
Added enterprise SSO and SCIM to a product that wasn't designed for it, without forking the small-customer experience.
Webhooks that stopped paging
Replaced a brittle webhook fan-out with verified, retried, replayable delivery. On-call interruptions down by an order of magnitude.
Related services.
Integration rarely arrives alone. These usually come with it.
Got two systems
that won't agree?
Tell us a little about what you're trying to connect. We reply within two working days, in plain language, with an honest read on whether we're the right team.