API integration services for the systems your business runs on
Connect one important workflow across your existing applications, with clear data ownership, visible failures and a recovery path your team can operate.
01
When the connection becomes an engineering project
Better Software scopes, builds and maintains custom API integrations for operating businesses and product teams. We start with the handoff that needs to work, check what the source and destination allow, and agree how to prove the result.
A customer changes an account detail, but the operations application still has the old value. A new order reaches one system and needs manual entry in another. A connector runs, yet nobody can explain which records completed or who should resolve the exceptions.
The immediate request is often “connect these two systems.” The work underneath is deciding which system owns each field, how identities match, what happens during an outage and how the receiving team knows its records are current enough to use.
We help engineering and operations leaders turn that problem into a bounded implementation. Bring a specific handoff, the systems involved and an example of what goes wrong. We can assess whether configuration, a supported connector or custom engineering is the right next step.
02
Start with one source, one destination and one business outcome
The first scope should name the applications and the change that must arrive. That might be an approved account update moving from your product into an operations application, or a completed order creating the right record in a downstream system.
We define the fields, mapping rules, identifiers, direction and acceptable delay with your team. We also separate historical backfill from ongoing updates. Loading existing records and keeping later changes correct have different failure cases.
Two-way synchronization needs an explicit conflict policy. If both applications can change the same field, “keep them in sync” leaves a business decision unresolved. One-way delivery or ownership by field may be enough. We choose the smallest approach that supports the workflow.
The initial scope is a named handoff with agreed acceptance evidence. It is not a commitment to connect every tool in the company.
03
What we scope, build and hand over
| Workstream | Concrete output |
|---|---|
| Access and feasibility | Required endpoints and fields, authorization scope, vendor restrictions, environment access and unresolved dependencies |
| Integration contract | Record identities, field ownership, transformation rules, exclusions, timing and deletion behavior |
| Implementation | The agreed adapter or service, configuration, validation and supported delivery mechanism |
| Recovery and reconciliation | Rules for retries, duplicate handling, uncertain outcomes and finding missing or rejected changes |
| Acceptance and handover | Test evidence, unresolved exceptions, operating instructions, ownership and an agreed maintenance scope |
The design depends on the applications. An API that exposes today's records may support current-state repair without preserving every intermediate event. A webhook may need a separate recovery process. For example, GitHub documents that it does not automatically redeliver failed webhook deliveries. We check the actual provider contract before promising recovery behavior.
Access is part of feasibility. The customer's plan, permissions, vendor approval and API limits can constrain the work. If a required capability is unavailable, we narrow the workflow or explain why it cannot be delivered through the supported interface.
04
A recovery test: should two unseen accounts be removed?
An integration review should show what the team does when the evidence is incomplete. Consider a hypothetical customer-account sync from a SaaS application into an operations tool. The source owns account presence; the operations tool owns service notes.
The destination contains accounts A, B, C, D and E. A source scan returns A, B and C on its first page. The second-page request fails. If the integration treats the first page as the whole source, it could mark D and E for removal even though it has not established that either account disappeared.
Pagination is part of the source contract. For example, GitHub documents that paginated REST responses return a subset and provide links for fetching additional pages. The example below uses synthetic account IDs, not GitHub account behavior. We would check the actual application's pagination, permissions and comparison boundaries.
We ran a small offline decision exercise with those five IDs. It performs no API calls or destination writes. Its result separates incomplete evidence, absence in a completed comparison and a deletion that needs review.
- Destination identities
- A, B, C, D, E
- Source page one
- A, B, C received
- Source page two
- Unavailable. Enumeration is incomplete.
- Decision
- D and E remain unresolved. No automatic deletion.
| Controlled case | Result from the exercise | Operating decision |
|---|---|---|
| Page two fails after A, B and C arrive | D and E are unresolved; the comparison cannot establish absence | Preserve destination records and investigate or resume the scan |
| All pages return, but the access scope changed | Evidence remains incomplete for the agreed comparison | Check permissions and scope before classifying unseen accounts |
| A complete comparison in the same scope contains all five IDs | No identities are absent | This presence check passes; field values need separate checks |
| A complete comparison contains A through D, with no deletion evidence for E | E is absent from the compared set; no deletion-review candidate is produced | Investigate why E is absent rather than infer deletion |
| The same comparison includes explicit source deletion evidence for E | E becomes a deletion-review candidate | Apply the agreed retention and approval policy before any removal |
The exercise produces zero automatic deletions in every case. That is a boundary of this sample, not a claim that every integration needs manual deletion. Some systems can safely automate explicit deletion events under a defined contract. Absence in a partial response does not establish that contract.
The sample trusts the supplied completeness and scope flags; it does not prove them. The real implementation needs evidence that enumeration finished and that permissions, filters and the comparison boundary stayed valid. A changing live dataset may require provider-supported snapshot or cursor semantics, or a different reconciliation method. Reading the last page alone does not establish a consistent snapshot.
Before accepting this workflow, we would ask the team to interrupt a scan, change its access scope and introduce an explicit deletion case in an isolated test. The review should show what remains unresolved, which destination records stay intact and who can approve the next action. Duplicate fixture identities and conflicting present/deleted evidence must also be rejected.
This is a tested offline decision exercise with synthetic inputs, not a tested production integration or a customer result. It checks identity presence only. It does not validate field mappings, reconstruct every historical event or establish that replaying an external action is safe.
For the broader completeness contract, see how to find API changes that never reached an integration. Bring the source's enumeration and deletion rules to the first conversation; they can change the recovery scope and estimate.
Download the offline exercise: Python source and sample results (JSON). These files contain synthetic inputs and make no network requests or destination writes.
05
Agree the acceptance evidence before expanding the scope
A successful API call is one piece of evidence. The review should also show the intended destination state, the handling of invalid input and what the operator sees when delivery fails.
For the selected workflow, we agree tests for repeated changes, an unavailable destination, a rejected record and a change missing from delivery. Where a response is lost after an action may have succeeded, recovery must account for that uncertainty before repeating a consequential action.
We record what can be repaired automatically, what needs a person and what the available interfaces cannot establish. The handover names the owner of unresolved work and the procedure for investigating it. Acceptance applies to the agreed scope and test evidence, not a guarantee that external systems never fail.
06
Keep the integration maintainable after launch
The ongoing scope can include investigating failed changes, adapting to vendor API changes, maintaining authorization and updating mappings as the business process changes. We agree those responsibilities alongside the build.
Your team retains authority over business rules and vendor accounts. We identify the technical owner, escalation path and access needed to support the integration. Coverage hours and response commitments are agreed explicitly; this page does not promise round-the-clock support.
If the work requires ERP functional decisions, regulated-domain review or platform-specific expertise beyond the agreed team, that capability must be established before we commit to it. General API engineering is not a substitute for those responsibilities.
07
Is custom integration the right fit?
This is a fit when a consequential workflow spans existing applications, the supported connector leaves a specific gap, and someone owns both the business decision and ongoing operation.
A configuration change or standard connector may be sufficient for a simple handoff. We assess those options before adding a service your team will need to maintain. If you need a customer-facing interface as well, that is an additional product scope to evaluate separately.
Budget depends on the interfaces, mapping complexity, backfill, failure handling and ongoing responsibility. See our current team and pricing approach for engagement context. An integration estimate needs the actual workflow and access constraints.
08
Bring one handoff to the first conversation
Share the source and destination applications, the records that should move, the current workaround and one failure or exception. Include relevant API documentation if you have it. An anonymized example is enough to start the discussion.
We will discuss the business outcome, technical dependencies and whether the work fits our team. The next step is an agreed scope with open questions made visible.