- Market
- Saudi Arabia
- Written for
- CIO, CTO
- Decision
- Connect a new system to the hospital information system without clinical risk
- Languages
- EN · AR
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.
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
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
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
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.
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.
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.
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.
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.
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.
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.
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.
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
- 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.
- 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.
- 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.
In this cluster
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.

