The database that stores a patient record as a path, not a join.
InterSystems Caché is a high-performance, multi-model database: object, relational and multidimensional at once. Under the hood it keeps data in hierarchical globals you address directly instead of searching, which is exactly why it sits beneath some of the most demanding systems in healthcare. We spent years engineering on it, inside large-scale healthcare platforms.
A database that doesn't look like a database
InterSystems Caché combines database management, application development and integration in a single platform. It speaks three data models (relational, object-oriented and multidimensional) over one physical store, so a team can model entities as objects, query them in SQL, and still get the raw speed of direct multidimensional access.
That combination is why it shows up in healthcare, banking, government and telecom: places where transactions are high-volume, latency is felt by a human waiting, and downtime isn’t an option. InterSystems has built data software since 1978; Caché became the platform of record for organisations that needed performance without giving up developer productivity.
Healthcare data, at the speed care needs it
A healthcare provider generates an enormous amount of data every day: demographics, diagnoses, treatment plans, assessments, medications, lab results, authorisations and claims. A clinician needs the right slice of it instantly.
- Manage large volumes of structured and unstructured clinical data.
- Keep transaction processing fast while thousands of records change at once.
- Integrate data across departments and outside systems without building a silo per source.
- Stay available and consistent, because a few seconds’ delay can change a clinical decision.
Traditional relational databases can stall here: complex, high-volume workloads turn into multi-table joins and repeated disk seeks. Caché takes a different route to the same data.
One platform, cleanly layered
Applications talk to business logic; logic reaches data through either an object or a SQL lens; both resolve to a single multidimensional engine that owns physical storage. A request travels down and a response travels back up the same spine.
Why multidimensional beats joins
A relational read fans out across tables and joins them back together. A Caché read walks a known path straight to the value. Same data, far fewer moving parts.
Data lives in globals: persistent, hierarchical arrays where the address is the index. There is no separate table to define and no row to look up; the path you write is the path you read. Globals are sparse, so only the data that exists consumes space, and deeply nested clinical structures come back without a single join.
| Feature | What it buys you |
|---|---|
| Multidimensional storage | Direct, sparse access with no joins to read a full record |
| Object + SQL on one store | Model in objects, query in SQL, no second copy of the data |
| ObjectScript | MUMPS-class speed with a modern development language on top |
| High availability | Mirroring and shadowing keep downtime low |
| Scalability | Grows with users and data without a redesign |
| Built-in security | Row- and role-level controls over sensitive records |
MUMPS isn't legacy, it's the engine's heart
MUMPS (the M language, born in a hospital in 1966) introduced global variables and a multidimensional data model. Caché didn't replace that; it grew from it, adding indexing, transactions, security, objects and SQL on top.
Understanding MUMPS pays off precisely because so much of Caché’s behaviour, and so much production healthcare code, still rests on globals. ObjectScript is the modern extension: it keeps M’s speed while adding the structure of a contemporary language. The same record can be a global, an object and a SQL row at once.
What we delivered on Caché
Inside large healthcare platforms (patient records, treatment planning, clinical documentation, billing, reporting and compliance), we worked across the full breadth of the system. The common thread: outcomes clinicians and administrators feel, delivered on a platform most teams are afraid to touch.
Core clinical features
New capabilities and fixes across long-lived clinical workflows, extending decades-old logic without destabilising it.
Clinical data capture
Electronic forms that catch bad data at the point of entry, so records are right before they are ever saved.
Faster deployments
Automation that turned days of manual system setup into a repeatable process measured in minutes.
Connected systems
Integrations with hospitals, labs, pharmacies and payers so a record entered once is correct everywhere.
Reporting & compliance
Patient summaries, clinical documentation and compliance reporting the organisation could stand behind.
Performance under load
Tuning that kept clinical workflows responsive as data volumes and user counts grew.
Records that are right from the start
Electronic forms are where clinicians actually enter assessments, diagnoses and treatment plans. The most valuable place to fix data quality is the moment of entry, before a bad value ever reaches the record.
Validation runs the instant a clinician types, and again before anything is stored, so a treatment plan can’t reference a diagnosis that was never made. Just as important, forms are configurable: organisations adapt their clinical workflows without waiting on a software release. The result is cleaner records, less rework downstream, and reporting the organisation can actually trust.
One record, reflected everywhere
A modern healthcare ecosystem is many systems that must agree. Caché is built to be the integration point: it collects from hospitals, labs and payers, standardises it, and serves a single repository the rest of the platform reads from.
We built and maintained the integrations that move data between the platform and external systems, so information entered in one place is reflected accurately across every connected system. Standardising into a unified repository is what makes comprehensive reporting and analytics possible, and what dissolves the data silos that slow care down.
Why it holds up where care can't wait
The year MUMPS was created, and its model still powers the engine
To read a full patient record from a global
Data models over one physical store: object, relational, multidimensional
- Faster retrieval of deeply nested records, with no joins to reassemble a patient.
- Lower database overhead and high transaction throughput under real clinical load.
- Interoperability that keeps records consistent across hospitals, labs and payers.
- Reliability and availability that let clinicians trust the data is there when they reach for it.
Old roots, modern reach
Caché’s advantage is structural: store data the way you read it, and most of the work a relational database does on every query simply disappears. It asks for specialised knowledge (a smaller community than mainstream databases, and real effort to master), but in return it delivers the speed, reliability and scale that mission-critical healthcare depends on. Knowing the platform from MUMPS up is what lets a team extend it safely instead of working around it.
Running on Caché, MUMPS or another platform everyone’s afraid to touch? We’re at home in the engine room as well as the front end.
Talk to engineering