System Integration for SMBs: What We've Learned Connecting 50+ Tools

Integration Patterns: Choosing the Right Approach

After connecting dozens of systems, from Pipedrive and Exact Online to Shopify, Telegram, and everything in between, we have settled on a few patterns that work reliably. The choice depends on your requirements for speed, complexity, and reliability.

Webhook driven (event based). The source system sends a notification the moment something happens. A new order triggers an instant sync. This is ideal when you need real time updates and the source system supports webhooks. Pipedrive, Shopify, and most modern SaaS tools offer them. The downside: if your receiving system is down when the webhook fires, you miss the event unless you have a queue.

Polling (schedule based). Your integration checks for changes on a schedule, say every 5 minutes. This is simpler to build and more forgiving of temporary outages, but it introduces latency and can be wasteful if nothing has changed. We use polling as a fallback or for systems that do not support webhooks.

Middleware layer. A dedicated service sits between all your systems, translating data formats and routing events. This is the right choice when you are connecting three or more systems. Without middleware, you end up with point to point connections that multiply exponentially. With four systems and no middleware, you need up to twelve direct connections. With middleware, you need four.

The Biggest Pitfalls

These are the issues that have burned us (and our clients) enough times that we now plan for them from day one.

Rate limits. Every API has them, and they are rarely generous enough for bulk operations. Exact Online, for example, has strict rate limits that can throttle a sync that tries to push hundreds of invoices at once. Always implement rate aware queuing and exponential backoff. Never assume you can fire requests as fast as your code runs.

Data conflicts. When two systems can both modify the same record, you will eventually get conflicting edits. A sales rep updates a phone number in Pipedrive at the same moment the customer updates it on the webshop. Who wins? Define conflict resolution rules upfront: last write wins, source of truth priority, or manual review flags.

Authentication token expiry. OAuth tokens expire. Refresh tokens sometimes expire too. We have seen integrations fail silently for days because a token expired and nobody noticed. Always implement automatic token refresh, and alert on authentication failures immediately.

Schema changes. The API you integrated with six months ago might have added required fields, deprecated endpoints, or changed response formats. Pin your integrations to specific API versions where possible, and monitor changelogs for breaking changes.

Best Practices That Save You Pain

Idempotency is non negotiable. Every operation in your integration must be safe to retry. If a webhook fires twice (and it will), your system should not create duplicate records. Use unique identifiers and check before create logic everywhere.

Log everything. Every API call, every data transformation, every decision point. When something goes wrong, and it will, your logs are the difference between a 10-minute fix and a 3-hour investigation. Include request/response payloads (sanitized of credentials) and timestamps.

Build monitoring from day one. Do not wait until something breaks to add alerting. Monitor sync success rates, latency between systems, queue depths, and error rates. A dashboard that shows "last successful sync: 2 minutes ago" across all your connections gives you instant confidence that everything is working.

Handle partial failures gracefully. If you are syncing an order that creates records in three systems and the third call fails, what happens? Roll back the first two? Queue the third for retry? Flag the order for manual review? Decide this upfront.

Version your integration logic. When you change how data maps between systems, keep the ability to roll back. Schema migrations in integrations are just as important as they are in databases.

The Practical Reality

No integration is truly "set and forget." APIs change, business requirements evolve, and edge cases surface over time. The goal is not perfection on day one but building a system that is observable, maintainable, and resilient enough to handle the unexpected. The companies that treat integration as ongoing infrastructure rather than a one time project are the ones whose systems actually stay in sync.