May 2026
Most integration failures we encounter are not caused by weak developers. They are caused by unclear ownership of data, undocumented assumptions about third-party APIs, and timelines that treat connectivity as an afterthought. Planning integrations before the first line of application code is written saves months of rework and prevents staff from reverting to manual exports.
Define System Boundaries First
Before choosing endpoints or middleware, document which system owns each entity: customers, orders, inventory, invoices, assets, and user accounts. Australian businesses often run a mix of cloud SaaS, on-premise legacy databases, and spreadsheets that quietly became production systems. Without an explicit ownership map, two applications will both try to be the source of truth for the same field, and staff will stop trusting either.
We run a short workshop with operations, finance, and IT stakeholders to answer three questions for every integration touchpoint: who creates the record, who may update it, and who needs to read it downstream. That exercise surfaces hidden dependencies — a warehouse scan that must update finance in near real time, or a compliance field that only exists in a custom portal. The output is a boundary diagram, not a technical spec, but it anchors every later decision.
Boundary clarity also informs licensing and access. If your CRM remains authoritative for customer master data, your custom portal should reference stable identifiers rather than duplicating contact details that drift over time. When duplication is unavoidable, define refresh rules and conflict resolution before build. Waiting until UAT to discover that phone numbers disagree across systems is expensive and demoralising for users.
Evaluate APIs Like You Evaluate Suppliers
Not all APIs are equal. Review documentation quality, sandbox availability, rate limits, webhook support, and change notification practices. A well-known platform may expose a legacy SOAP interface with brittle schemas while a smaller vendor offers clean REST with signed webhooks. We score candidate systems on reliability, observability, and support responsiveness — especially for Australian business hours when a production sync fails during morning operations.
Authentication deserves early attention. OAuth flows, API keys, mutual TLS, and IP allowlists each affect deployment architecture and secret rotation. If a vendor requires whitelisted static IPs, your hosting choice may need adjustment. If tokens expire hourly, your integration layer needs refresh logic and alerting when renewal fails. These are not exotic edge cases; they are weekly realities in production environments.
Prototype the riskiest calls in a sandbox before committing to UI work. We typically validate create, update, search, and bulk export paths with realistic payloads — including malformed data and partial failures. Sandboxed success does not guarantee production parity, but it exposes schema surprises early. Document every field mapping with examples, units, time zones, and nullable behaviour. Ambiguity in date formats alone has caused more reconciliation tickets than entire feature modules.
Integration Patterns Worth Considering
- Event-driven sync via webhooks when the vendor supports reliable delivery and retry semantics.
- Scheduled batch imports when volumes are moderate and near-real-time is unnecessary.
- Read-through caches for reference data that changes infrequently but is queried constantly.
- Idempotent upsert operations so retries do not duplicate records during transient outages.
Integrations fail quietly long before they fail loudly. Staff compensate with exports until trust in the system erodes completely.
Plan for Failure, Monitoring, and Recovery
Production integrations need runbooks, not hope. Define acceptable lag, dead-letter handling, and who receives alerts when queues backlog. Small Pea Software builds observability into integration layers from the start: structured logs, correlation identifiers across systems, and dashboards that operations staff can interpret without reading stack traces. Australian privacy obligations also mean logging should avoid storing unnecessary personal information even when debugging.
Versioning and vendor roadmap changes require a maintenance budget. An API deprecation notice six months out is generous only if your team has capacity to migrate. We maintain integration contracts as living documents — field mappings, test fixtures, and rollback steps — so upgrades are rehearsed rather than improvised on release night.
Security review should cover least-privilege credentials, encrypted transport, and audit trails for data exchanged between systems. Regulated industries may require evidence of who triggered a sync and what changed. Planning these controls during discovery is far cheaper than retrofitting them after go-live.
Sequence Delivery Around Integration Risk
We often deliver integration paths in the first sprint, before polished screens, because they de-risk the project timeline. If a warehouse API cannot support confirmed pick events at the required frequency, the UI design should reflect batch reconciliation rather than pretending live inventory exists. Honest sequencing sets client expectations and prevents demo-driven decisions that collapse under real load.
Testing strategy should include contract tests against sandbox endpoints, replay of production-like volumes, and chaos scenarios — revoked tokens, HTTP 503 storms, duplicate webhook delivery. UAT participants should validate business outcomes, not HTTP status codes. When integrations are planned well, UAT focuses on workflow confidence rather than firefighting connectivity.
If your next project connects custom software to finance, CRM, logistics, or identity platforms, invest a focused discovery week in integration planning. The diagrams and decisions produced there will outlast any single screen design. We are happy to review your current landscape and identify the integrations that should be proven before broader development begins.
Integration planning documents should be living artefacts — updated when vendors deprecate endpoints, when field mappings change, and when new systems enter the landscape. Teams that treat the initial diagram as finished homework rediscover the same reconciliation debates eighteen months later. Budget modest ongoing maintenance for integration health alongside application features.
