HAKEEM National EHR

In 2010, Node.js v0.4 landed and the internet spent the year arguing about whether JavaScript on a server was a joke. Meanwhile, at 22 years old, the team at Electronic Health Solutions (EHS) — a public-private partnership between the Jordanian government and a healthcare provider consortium — was writing MUMPS routines for the pharmacy dispensing module of a national EHR that would eventually serve four hospitals across Jordan.

That was HAKEEM. The team’s role: Developer and System Analyst, 2010 to 2013. Three years. Four hospitals. One national-scale system built on a technology stack that made modern engineers make a face — which turned out to be exactly the right preparation for the next decade.

What HAKEEM was built on

HAKEEM was built on VistA — the Veterans Information Systems and Technology Architecture developed by the U.S. Department of Veterans Affairs. VistA is one of the longest-running EHR systems on the planet, deployed in American veterans’ hospitals since the 1980s. It runs on MUMPS (later M), a hierarchical database and language combination that looks like nothing else you’ve ever written.

The decision was sound. VistA is battle-tested in a way commercial EHRs struggle to match: pharmacy modules, clinical decision support, scheduling, billing, all under one coherent data model. Open-source meant Jordan didn’t need to license proprietary software for a national deployment. The fact that it runs on GT.M, a hierarchical NoSQL database, meant you needed engineers who could read MUMPS and weren’t afraid of a forty-year-old stack.

What the work actually looked like

The title was Developer/System Analyst. In practice, it was three distinct workstreams running in parallel.

MUMPS routines. The team wrote M routines in three packages: Pharmacy, Billing, and HL7 Messaging. Pharmacy dispensing logic in MUMPS is one of those things that offends your aesthetic sensibilities and then works correctly for forty years. Variables are global by default. The database is the language — globals (MUMPS’s term for persistent variables) map directly to the hierarchical database structure. A routine is a file. There are no functions in the modern sense; there are labels and GOTO-equivalents that make structured-programming people uncomfortable. And yet: the dispensing logic written for HAKEEM’s pharmacy module is almost certainly still running in some form in Jordanian hospitals today. You don’t get to say that about most JavaScript frameworks.

C# GUI applications. The two main ones were the Patient Information Management GUI and the Scheduling GUI, both communicating with the VistA backend via its RPC Broker protocol. These sound boring. They weren’t. Patient information management in a national EHR means the registration nurse’s interface is the entry point for data that flows into every downstream system — pharmacy, labs, billing, reporting. Build the GUI in a way that lets garbage in, and you’re debugging patient ID mismatches at Prince Hamza Hospital six months after go-live. The Scheduling GUI had similar gravity: outpatient clinic scheduling at the Amman Comprehensive Clinic meant appointment slots across multiple departments, cancellation handling, and staffing reports. Boring software that matters enormously when it breaks.

Mobile GUIs. In 2012. For a healthcare EHR. Java for Android, Objective-C for iOS. Mobile healthcare in 2012 was not a mature space — Android was on version 4.0, iOS 6 was months out, and the UX conventions for clinicians accessing patient records on a mobile device didn’t yet exist. The team was figuring it out under the constraint that a misread patient record on a mobile device has patient-safety implications that a misread tweet does not.

Bash backup scripts. Also part of the job. The GT.M database ran on Linux servers and needed reliable backup and task management. Not glamorous. Entirely load-bearing. Hospitals that lose data make headlines for the wrong reasons.

Four hospitals, four deployment stories

HAKEEM rolled out to four facilities, and each was its own project.

Prince Hamza Hospital was the large general hospital — high volume, multiple specialties, the full breadth of the EHR’s capabilities. Where you find out whether patient registration and scheduling scale when you have hundreds of outpatient visits per day.

Amman Comprehensive Clinic was the outpatient model. Lighter on inpatient care, heavier on appointment management and chronic disease follow-up. The scheduling GUI earned its keep here.

Prince Hussein Hospital had clinical workflow requirements that didn’t map cleanly to the default VistA configuration. Customization at the MUMPS layer. The kind of work where you’re reading a routine from 1993 and deciding which lines to change without breaking everything downstream.

King Hussein Cancer Centre was the integration project — KHCC had its own EHR, its own patient records, its own workflows, and needed to connect with HAKEEM via HL7 v2. That integration was built by the team and is documented separately; the short version is patient identity resolution across two MRN spaces, event ordering, and pipe-delimited message parsing and transformation.

What national-scale infrastructure teaches you

Three years on HAKEEM taught something that has carried into every project since: the gap between “working software” and “infrastructure a country depends on” is an organizational problem, not a technical one.

The code was hard. MUMPS is hard in ways that are legitimate, not just aesthetic. HL7 is hard. Writing a mobile EHR GUI in 2012 before anyone had a playbook for it was hard.

But the harder problems didn’t have a debugger. Which hospital gets the next customization sprint? Who owns the decision when two hospitals need conflicting modifications to the same MUMPS routine? What does rollback mean when you’re mid-deployment at a facility seeing patients tomorrow morning?

The technical skills from those three years were valuable. The understanding of how complex systems fail at the organizational layer was more so. Writing pharmacy logic in MUMPS turned out to be a pretty good way to learn both at the same time.