Techbanq

Software · integration

Your systems already disagree; integration decides which one is right

Every enterprise runs on systems that were never designed to talk to each other — an ERP, an identity directory, plant historians, a dozen line-of-business tools. Integration is not the wiring between them; it is deciding which system owns each fact, how a change in one reaches the others, and what the estate does when one of them is unavailable. Get that wrong and the connectors just spread a disagreement faster.

Serving Saudi Arabia from our Riyadh office and our engineering hubs in Lahore and Karachi

Market
Saudi Arabia
Written for
CIO, CTO
Decision
Connect systems of record so they hold one version of the truth

Enterprise delivery credentials

  • ISO

    ISO/IEC 27001

    ISO/IEC 27001 certified

Certifications & registrations

What comes before connectors

The four things governed integration settles before a single connector

A connector is easy to write. These decisions are what stop it spreading a wrong number across the estate, and they are made once rather than rediscovered per integration.

Which system owns each entity

When two systems hold a customer or a price, one has to be authoritative and the other has to follow, or every sync becomes an argument.

What it prevents: A single answer to "which figure is correct".

The delivery guarantee per flow

Some changes may arrive late; others must never be lost or applied twice. Each flow needs that decided, not assumed.

What it prevents: A payment applied once, not twice on a retry.

What the flow does when a system is down

The connected estate is only as available as its least available member unless a flow can hold work and replay it later.

What it prevents: One outage that does not stop everything.

Who may read and write across the boundary

Identity does not stop at a system edge; an integration that ignores it is a route around your access controls.

What it prevents: Access rules the integration respects, not bypasses.

The failure to avoid

How a dozen quick connectors became a system nobody could change

The usual way an estate becomes unmanageable is not one bad decision; it is a series of reasonable ones. A system needs a figure from another, so someone builds a direct link. Six months later a third system needs the same figure, so a second link is built, and a fourth, until the diagram is a web in which no line has an owner and no change is safe. Each connector was justified. Together they are a system whose behaviour nobody can predict, because the truth about any given fact now lives in whichever link fired last.

Governed integration replaces that web with a small number of agreed flows, each with a named owning system, a delivery guarantee and a defined behaviour on failure. It is slower to start than the next direct link, because it forces a decision the direct link let you defer: which system is telling the truth. That decision is the entire value. Everything after it is plumbing that a well-drawn contract makes routine.

The method

How a change in one system reaches the others without corrupting them

A change does not travel raw from one system to the next. It is validated against the contract, routed to the systems that subscribe to it, and confirmed — with a hold-and-replay path for the moment a destination is unreachable.

A flow: capture a change at its owning system, validate it against the contract, route it to subscribing systems, then confirm and reconcile — with a hold-and-replay branch for when a destination is unreachable.

  1. 01

    Capture the change at its owner

    The change is read from the system that owns the fact, so the estate propagates the authoritative version rather than a stale copy.

  2. 02

    Validate against the contract

    The change is checked against the agreed shape before it moves, so a malformed record is caught here rather than in four downstream systems.

  3. 03

    Route to the systems that subscribe

    Only the systems that need the fact receive it, each in the form it expects, so adding a consumer later does not touch the ones already working.

  4. 04

    Confirm and reconcile

    Delivery is confirmed, and a periodic reconciliation catches any drift between the owner and its followers before it becomes a wrong report.

Always available

Hold and replay

When a destination is unreachable, the change is held and replayed in order once it returns, so an outage delays a fact rather than losing it or applying it twice. An integration without this is only as reliable as its least reliable system.

Our role

What we govern and what your systems teams keep owning

  1. 01

    The ownership map, agreed with you

    We work with the teams who run each system to assign the owning source for every shared entity, because that decision is a business one your people must stand behind, not a technical detail we impose.

  2. 02

    Flows built to a contract

    We build each integration against a documented contract with its delivery guarantee and failure behaviour, so a new system can join by meeting the contract rather than by a bespoke link nobody else understands.

  3. 03

    An estate your team can extend

    We leave the flows monitored and documented so your team adds the next integration without us, because an estate only we can change is a dependency wearing the costume of a solution.

Which system is authoritative for a given fact is a decision only your business can make; we turn that decision into governed flows with a delivery guarantee and a failure behaviour, and leave an estate your team can grow without re-earning the argument each time.

Common questions

What buyers ask

How is systems integration different from building an API between two systems?+

An API is one interface on one system. Integration is the question of how a whole estate agrees on shared facts, which an API alone does not answer. You can build a clean API on every system and still have chaos, because the API tells another system how to ask but not which system is allowed to be right when two of them hold the same customer. Integration is the governance layer above the interfaces: the ownership map, the delivery guarantees and the failure behaviour. We often build APIs as part of it, but the deliverable is the agreement, not the endpoint.

Two of our systems hold the same data and disagree. Which one should win?+

The one closest to where the fact is created and maintained, not the one that is newest or easiest to read from. For a customer address, that is usually the system where a person actually updates it; for a price, the system where pricing is set. Naming the owning source per entity is the first thing we do, because a disagreement between two systems is not a data problem to be merged away — it is a missing decision about which one is authoritative. Once that is set, the follower is corrected from the owner, and reconciliation catches the drift before it reaches a report.

What happens to our integrations when one of the connected systems goes offline?+

That depends entirely on whether the flow was built to tolerate it, which is why we decide it per flow rather than hope. A well-built integration holds the changes bound for the offline system and replays them, in order, when it returns — so the outage delays a fact rather than losing it or double-applying it on recovery. Flows that cannot tolerate delay are identified early and handled differently. The failure mode of an estate stitched from naive direct links is that it is only as available as its weakest system, and one maintenance window stops several others.

Next step

Map your systems estate

A mapping session that produces the source-of-truth assignment for your key entities and the failure behaviour for each flow, before a connector is written.