What it solves
When two systems need to agree on the same records, a no-code scenario is sometimes not enough. We build small, well-monitored integration services: authentication, field mapping, queuing, retries and alerts — so data moves reliably and someone is told when it does not.
Typical problems
- Exports and imports run by hand every week
- Records that drift apart between systems
- An integration that fails silently for days
- Rate limits and API changes breaking things without warning
- A vendor ‘native integration’ that syncs half the fields
What changes
The systems you already pay for agree with each other. Records created in one place appear correctly in the others, duplicates are prevented, drift is reported, and someone is told when a sync fails. Where an AI tool needs to read your systems, an MCP server gives it scoped, logged access instead of a shared login.
Example workflows
Workflows we build regularly in this service. The “what changes” lines describe the process after the build, not measured results; measured results are published only in case studies, with permission.
CRM to accounting sync
Won deals are re-keyed as customers and invoices in the accounting system.
A webhook on ‘deal won’ creates the customer and draft invoice, maps the line items and writes the invoice number back to the CRM.
What changes: no double entry; both systems agree.
E-commerce to warehouse
Orders are exported nightly as CSV and imported by hand.
Orders stream to the warehouse API as they are paid; stock levels and tracking numbers flow back; failures retry and alert.
What changes: same-day dispatch, live stock on the site.
Legacy system with no integrations
A database that nothing else can read.
A small middleware service exposes a clean API and keeps a queue so downstream tools never overwhelm it.
What changes: an old system that finally talks to new ones.
What gets automated
- REST, GraphQL and webhook integrations
- Two-way sync with conflict rules
- Custom middleware and serverless functions (Node, PHP, Python)
- Queues, retries and idempotency
- Logging, dashboards and alerting
- Authentication: OAuth 2, API keys, signed webhooks
Systems we work in
Tools describe the systems we connect; they do not imply partnership or certification.
- REST & GraphQL APIs
- Webhooks
- n8n
- Node/PHP middleware
- Model Context Protocol (MCP)
- HubSpot
- Pipedrive
- Clio
- Cliniko
- Xero
- Stripe
Human checkpoints and security
The rules that keep this service safe to run in a regulated firm. They are written into the scope, enforced in the build and described in more detail on the security and data page.
- Field mapping and conflict rules agreed in writing before any data moves
- Idempotent steps: running twice never creates duplicates
- Reconciliation reports show drift instead of hiding it
- Authentication with scoped API keys or OAuth; MCP servers expose only the tools you approve
What every build includes
The difference between an automation that works in a demo and one that still works in a year.
- Automatic retries when a connected app is briefly unavailable, so nothing is silently lost
- A run log for every execution — what came in, what was decided, what went out
- Failure alerts to Slack or email after repeated errors, with a pause switch you control
- Idempotent steps: running twice never creates duplicates
- Written handover: a one-page map of the workflow, its owners and how to change it
- Built in your own accounts — you keep every credential, licence and asset
How the work is delivered
Map
Current process documented with the people who run it.
Scope
Written proposal, diagram, deliverables, fixed price.
Build
Short stages in your accounts, demo at the end of each.
Launch
Monitoring, alerts and documentation before go-live.
Pricing and engagement
Written inventory, risk register and priced options in 5–8 working days. Fee credited against an option accepted within 30 days.
Two to six systems synced through APIs, webhooks or n8n, with field mapping, reconciliation and monitoring; fixed after a mapping session. Fixed in writing before work starts; nothing outside scope without your written approval. Half on start, half on go-live.
Monitoring, fixes when an app changes its API, credential hygiene and a monthly health report. Cancel any month.
Deliverables
- Source code in your repository
- Field mapping document
- Runbook: what to do when an alert fires
- Monitoring dashboard
Questions
Custom code or Make/n8n?
If the volume is modest and the logic simple, a no-code scenario is cheaper to maintain. If you need queues, high volume, strict error handling or a vendor with no connector, a small custom service is the right tool. The audit tells you which.
Where does the code run?
In your cloud account (AWS, Azure, Google Cloud, Cloudflare) or on a small VPS you control. Nothing runs on our infrastructure.
What if an API changes?
Alerts fire, the queue holds the data, and the fix is covered by the retainer — or quoted quickly without one.
Can you document an integration someone else built?
Yes. Reverse-engineering and documenting existing integrations is a common starting point.
How does pricing work?
Most engagements start with a fixed-price Automation Reliability Review (from $900). You then get priced options in writing with one price and a delivery date each. Ongoing monitoring and improvements are a monthly retainer you can cancel any month. All prices are in USD.
How quickly can something be live?
A first workflow is usually live within two to three weeks of sign-off. Larger builds are staged so something useful ships early and the rest follows.
What happens when a workflow fails?
Every build ships with retries, a run log and alerts. Anything that does not run as scoped in the first 30 days is fixed at no charge; after that Automation Care covers fixes, or we quote a small fix and turn it around quickly.
Who owns the automations afterwards?
You do. Everything is built in your accounts and documented, and your team is walked through it at handover. You can maintain it yourself or keep us on retainer.