How we work
How an integration gets built
From first scoping call to a hosted, monitored production integration — the steps, owners and timelines.
What an integration looks like in production
We sit between two vendor systems. Your platform never talks to the other vendor directly, so a breaking change upstream is our problem to absorb, not yours.
The six phases
01
Scoping call
1 week
We map the systems on both ends, the data that has to move and the failure modes you already know about.
We do
- Review the API documentation of both systems
- Identify entities, direction and volume
- Flag authentication and rate-limit constraints early
You do
- Name a technical contact
- Share API docs or a sandbox account
Output: Scope note with entities, direction and open questions
02
Interface design
1–2 weeks
A written contract before any code: field mapping, error semantics, retry policy and the exact shape of every payload.
We do
- Field-level mapping between both schemas
- Define idempotency keys and retry/backoff rules
- Agree error taxonomy and alert thresholds
You do
- Review and sign off the mapping
- Confirm edge cases from your domain
Output: Signed interface specification
03
Build & sandbox
2–6 weeks
We build the integration against sandbox credentials, with automated tests covering the mapping and the failure paths.
We do
- Implement transforms, queueing and retries
- Contract tests against both sandboxes
- Structured logging and correlation IDs
You do
- Provide sandbox credentials
- Answer questions within two working days
Output: Working integration on our staging environment
04
Acceptance
1–2 weeks
You test against real-world scenarios. We fix, you re-test, and we agree the go-live criteria in writing.
We do
- Run through the agreed test scenarios
- Fix defects within the sprint
You do
- Validate data in your own system
- Sign the acceptance checklist
Output: Acceptance sign-off and go-live date
05
Go-live
1 day
Production credentials, a controlled cut-over and a monitored first week with a named engineer on hand.
We do
- Deploy to production
- Watch throughput and error rates for seven days
You do
- Swap production credentials
- Confirm first successful transactions
Output: Integration live, monitoring dashboards handed over
06
Operate & maintain
Ongoing
We host it, monitor it and adapt it when either vendor changes their API. Versioned, with a changelog per integration.
We do
- 24/7 alerting on error rate and lag
- Track upstream API deprecations
- Ship versioned updates with release notes
You do
- Report anomalies through the support channel
Output: Monthly reliability report
Who owns what
| Area | De Herstellers | You (the vendor) |
|---|---|---|
| Interface specification | Author | Approve |
| Credentials & sandbox access | Store securely | Provide |
| Transformation logic | Own | Review |
| Hosting & runtime | Own | — |
| Monitoring & alerting | Own | Receive reports |
| Upstream API changes | Detect & adapt | Notify when known |
| End-customer support | — | Own |
Support tiers
Every integration is hosted and monitored by us. The tier sets response time and coverage window, not whether we watch it.
Standard
- Response
- 1 business day
- Uptime target
- 99.5%
- Coverage
- Business hours (CET)
Batch syncs and non-urgent enrichment
Business
- Response
- 4 business hours
- Uptime target
- 99.9%
- Coverage
- 07:00–19:00 CET
Workshop and DMS flows tied to daily operations
Critical
- Response
- 1 hour, 24/7
- Uptime target
- 99.95%
- Coverage
- 24/7
Real-time lookups in a customer-facing checkout
Have a system you need connected?
Tell us which two systems and what has to move between them. We come back with a scope note and an indicative timeline.
Request an integration