Techbanq

Healthcare · integration

In a hospital, an integration error is a clinical event

The hospital information system is where the clinical truth lives, and every system connected to it inherits a duty of care: a record attached to the wrong patient or a result that quietly never arrives can reach a treatment decision. Integration here is engineered around that possibility, not around the happy path.

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

Market
Saudi Arabia
Written for
CIO, CTO
Decision
Connect a new system to the hospital information system without clinical risk
Languages
EN · AR

Enterprise delivery credentials

  • ISO

    ISO/IEC 27001

    ISO/IEC 27001 certified

Certifications & registrations

The route

The route a clinical record takes out of the HIS

Whatever the connected system is — a lab analyser, a patient app, an analytics platform — the record travels the same route, and each stop is a place the integration can be wrong in a way that matters.

  1. 01

    The HIS emits or answers

    An admission, an order or a result leaves the HIS as a message or an API response. The HIS remains authoritative; nothing downstream overwrites it.

    • HIS
  2. 02

    The boundary validates

    Structure, mandatory fields and codes are checked at the edge, because a malformed message caught here is a log line, and one caught later is a wrong record.

    • Interface engine
  3. 03

    The patient is matched

    The record is attached to an identity under explicit rules. A confident match proceeds; anything less waits for a person.

    • Identity rules
  4. 04

    The consumer acts on it

    The receiving system uses the record for what it is allowed to do, and acknowledges receipt so a missing acknowledgement is itself an alarm.

    • Receiving system

The quarantine queue

A message that fails validation or matching is never guessed at and never dropped. It waits in a visible queue until a person resolves it, and the resolution feeds back into the rules.

The design question for every hop is the same: if this step is wrong, who finds out, and how fast.

The interfaces

The interface families a HIS actually offers

The standards matter less as acronyms than as categories of door. Most hospitals offer a mix of all four, and the integration plan starts from which doors this HIS, in this version, actually opens.

01

Messaging feeds — the HL7 family

The HIS announces events as they happen — an admission, an order, a result — as structured messages other systems listen to. The family is decades old, present in almost every hospital, and implemented with vendor-specific quirks that the interface work must absorb rather than deny.

02

On-demand APIs — what FHIR is in plain terms

FHIR is a way of asking for a specific clinical resource — a patient, a medication list, an appointment — over a modern web interface, on demand, instead of listening to a feed. Where the HIS supports it, it is usually the cleanest door for patient-facing and analytical systems; where it does not, no plan should pretend otherwise.

03

Documents where structure runs out

Discharge summaries, referral letters and scanned consents move as documents, not as fields. An integration that pretends everything is structured data loses exactly the records clinicians reach for, so the document path is designed with the same care as the message path.

04

The vendor’s own doors

Every HIS also has proprietary APIs, export jobs or database views, and sometimes one of them is the only route to a piece of data. We use them when we must, treat each as a versioned contract with the vendor, and never touch one without the vendor’s interface team in the room.

The hard problem

Why matching the patient is harder than moving the data

Moving a message between two systems is ordinary engineering. Deciding which human being it belongs to is not. Names transliterate between Arabic and English in several defensible ways, identifiers differ between a national ID, a passport and an internal medical record number, and two patients can plausibly share a name and a birth year. Every integration into a HIS runs into this on the first day of real data.

The two failure directions are not symmetrical. A missed match creates a duplicate record — wasteful, and a known cleanup job. A wrong merge puts one patient’s history inside another patient’s chart, and a clinician may act on it. That asymmetry drives the design: matching rules are explicit and reviewable, the threshold for an automatic match is conservative, and everything between certain and impossible goes to a human review queue rather than to a heuristic that guesses.

This is also where the clinical-safety mindset separates hospital work from other integration work. Elsewhere, a rare data error is a support ticket with a service-level target. Here, the rare error is the whole design problem: the system is built so that being unsure is a safe state, being wrong is loud, and no record is ever silently attached, merged or discarded.

Failing safely

How an interface fails without failing a patient

Interfaces will fail — a vendor upgrade changes a field, a network drops, a code set is extended. The engineering is in making every failure visible, bounded and recoverable.

STAGE 01

Reject at the edge, loudly

A message that fails validation is refused at the boundary with a reason, not passed inward for a later component to misread. Every rejection is counted and alarmed on, because a rising rejection rate is how an upstream change announces itself. A malformed message that becomes a metric, not a record.

STAGE 02

Quarantine, never guess

Anything ambiguous — an uncertain match, an unknown code, a duplicate suspicion — is held in a quarantine queue with its context attached. The queue is a worked surface with an owner, not a log file nobody reads. An unsure state that is safe by construction.

STAGE 03

A person reconciles

Health-information staff resolve each quarantined item with the HIS as the reference, and the interface applies their decision. The people who know the patients stay in charge of identity; the software only prepares the decision. Every resolution recorded, attributable and reversible.

STAGE 04

The fix feeds back

Recurring quarantine patterns become new validation rules or matching rules, agreed with the hospital, so the queue shrinks over time instead of becoming a permanent manual department. An interface that gets safer with use.

Our role

What we engineer beside the HIS and what the hospital keeps

  1. 01

    Interfaces built with the vendor, not around them

    HIS vendors run interface teams, change-control processes and test environments for a reason. We plan the work through them — specifications agreed, test patients exercised, cutover windows scheduled — because an integration the vendor does not recognise is one their next upgrade silently breaks.

  2. 02

    Identity treated as a designed decision

    We put the matching rules, thresholds and review queue on paper with the hospital’s health-information team before the first live message, so that what counts as a match is a governance decision the hospital made, not a behaviour it discovered.

  3. 03

    Monitoring shaped for clinical stakes

    Message volumes, rejection rates, queue depth and acknowledgement gaps are watched continuously, because in this setting silence is not success — a feed that stops is an incident even when nothing has errored.

Clinical judgement, clinical workflow and the governance of the record stay entirely with the hospital and its clinicians; we build and operate the connections so the data those decisions rest on arrives whole, matched and on time.

Common questions

What buyers ask

Do we have to wait for FHIR support before integrating anything?+

No. Most hospitals run useful integrations today on HL7-family messaging feeds, and those feeds carry admissions, orders and results perfectly well. FHIR-style APIs are the cleaner door where the HIS offers them, and worth preferring for new patient-facing and analytical work, but a plan that waits for an ideal interface postpones value the existing doors already deliver. The honest sequence is to inventory what this HIS, in this version, actually exposes, and design against that.

What happens to a message the interface cannot match to a patient?+

It waits, visibly. The message goes to a quarantine queue with its full context, health-information staff resolve it against the HIS, and the interface applies their decision. What never happens is a guess: an uncertain record is not attached to the closest candidate, and it is not dropped. The asymmetry justifies the discipline — an unmatched message delayed by an hour is an inconvenience, while a record merged into the wrong chart can reach a treatment decision.

Will integration work disrupt clinicians who use the HIS all day?+

It should not, and the method is what prevents it. The connected systems read from and write through the HIS’s sanctioned interfaces; they do not modify the HIS itself, so clinician screens and workflows are untouched. Testing runs against the vendor’s test environment with test patients, cutover happens in agreed windows through the hospital’s change process, and rollback is prepared before anything goes live. The clinicians should learn the integration exists from what newly works, not from anything that stopped.

Our HIS vendor is slow with interface requests. Can you go around them?+

We will not, and you should be suspicious of anyone who offers to. A back door into a HIS — an undocumented database read, a screen-scrape — bypasses the vendor’s change control, which means the next upgrade can silently change what the integration reads with no one accountable for noticing. What we do instead is make the vendor path faster: precise interface specifications, test cases prepared in advance, and requests framed in the vendor’s own terms, because most interface-team delay is really ambiguity being clarified one email at a time.

Next step

Review your integration map

An integration review that names which systems must talk to the HIS, the identity rules that decide a match, and where a failed message goes — before any interface is commissioned.