FUME – introducing the ultimate FHIR converter!

By: Amos (Kippi) Bordowitz

Outburn is happy to announce that we are weeks away from launching the ultimate FHIR converter! We
believe it has the potential to be a game changer in the world of FHIR®!

To understand why we think we’ve created a game changer, we must first try to understand the pains we encountered in our own work, and from many conversations with leaders in the industry. FHIR® is an incredible standard and there is no question that it is one the most important additions to the global healthcare ecosystem. But as we have come to understand and utilize it, we have run into several problems, of which here are but a few:

·     Converting existing data into FHIR Resources is complicated, labor intensive and time consuming

·     Creating a valid resource with standard tools demands an absolute understanding of the JSON (or XML) structure, which allows us to make many syntax errors that are not easy to debug

·     Conformance to profiles means one must learn the profile first before trying to convert the data to FHIR

·     People must be trained to write valid resources, this costs money and time

·     Most organizations don’t have an easy way to leverage terminology servers, forcing them to use lookup tables scattered around the organization

·     There is no standard automation for data conversion from data sources / legacy systems to FHIR. This forces every organization to create their own methods for every platform. This means that converting their data to FHIR resources depends on hiring expensive programmers dedicated for each platform
in the organization
, which leads to:

·     Absolutely no reuse. What a waste!

These are the kind of problems that probably anyone using FHIR® has thought that “if only someone would create a solution for them” – everything would be a lot better.
Well, as they say in The Burning Man community – “if you see a job, it’s yours”.  So, we did just that.

Introducing FUME - Our FHIR converter

FHIR®-Utilized Mapping Engine. Yes, we are also very happy with how this acronym turned out 🙂

FUME is a FHIR converter that utilizes the power of IBM’s JSONata engine combined with a superscript of FHIR-shorthand (FSH), designed for dynamic creation of FHIR resource instances in runtime. It comes with a method-rich function library which will give its users very powerful control over resource creation
and data conversion, as well as ease of understanding throughout the entire process.

FUME is meant to take a lot of the complexity out of FHIR® related conversions, mappings and data transformations, utilizing the concept of a mapping language, but in a syntax that is easy for any system analyst to write and understand. This means no need for expensive training.
Once the basics are picked up, it is easy to use and gives fast results – which you can see in real time.

Convert from any proprietary format to FHIR, from FHIR to any other format, or from one version of FHIR to another: FUME will allow users to map, translate and transform the information in a fraction of the time it takes with any other method. While there are some FHIR converter tools out there, they are mostly stateless, this means that making inline calls to a FHIR server or terminology service is impossible. With FUME you can do it seamlessly, as a natural part of the flow. This means that no matter what data
source or legacy system is operating in your organization, it should be a no brainer to take the data and convert it into FHIR Resources. This will also be true in the opposite direction – take any FHIR resource and transform it into your organization’s internal data model and corresponding to your data storage requirements.

Transformations are called with a RESTful API, this means that the same mapping can be called from any system, making it platform and vendor agnostic. Whatever your data infrastructure is made of, wherever your data resides - if you can access the data, FUME will handle the rest.

In addition, FUME makes it possible to create maps that are simple to write, read and maintain. The authoring process does not require any formal definition of formats or schemas, you don’t need to define any logical models or custom resource types. If you know how
your data is structured, you can write a map that converts it to FHIR in no-time, and you might even find the process enjoyable. 🙂

Once created, the mappings can be stored on the FHIR server, called from inside other mappings, migrated to other servers, and be reused – the work only needs to be done once!

The JSON problem

JSON is supposedly simple: a key-value format, be it simple data or complex structures (arrays, objects, etc.), using the JavaScript object notation. But in practice, working with the FHIR JSON structure can be complex and error prone, especially when dealing with files spanning 4, 5 or even 10 thousand lines – a very real possibility in FHIR. FUME will allow a user to go about populating the JSONs without having to understand the correct way of doing so, thus preventing the problems that can arise from several thousand lines of JSON: mismatched or altogether-missing brackets and parentheses; missing or erroneous commas, using the wrong brackets for arrays and objects, etc. In my experience, there are few things quite as frustrating as looking for that needle in the proverbial haystack. FUME assists you by hiding the complexities
of the JSON representation. You simply see the elements that can be filled and fill them – FUME will do the rest.

Under the hood

Leveraging the use of profiles:

Anyone working with profiles knows that it is not always easy to translate them into actual resources. Things that are very clear in the profile are less clear in the resulting instances. For example: a profile may have many slices with their own names and rules, while they do not explicitly appear in the actual instances.

FUME allows you to leverage the profile definition to your advantage: any fixed value from the profile or slice is automatically injected into the instance. You can address slices explicitly by their name instead of trying to implicitly translate them into actual JSON elements.

In addition, FUME will automatically produce a resource or profile template with all the possible element names, including sub-elements and slices, so all you need to do is to insert data exactly where you want. Just use the source element names, combine them in any expression or function call that may be needed, and insert into the pre-produced fields. And if the data type the resource requires is different than the one in your source, FUME will detect this and automatically correct it wherever possible. Easy-peasy!


FUME knows
how to query any FHIR server and retrieve the information required from any resource stored on the sever, retrieve the information, and make use of it as part of the mapping. You don’t need to know the exact structure of the resource – FUME will present the data to you, and you can refine you query interactively.

Function Library:

FUME comes with a whole range of functions, allowing you to manipulate your data in many ways, on the fly. Want to trim a string? Aggregate arrays? Resolve a conditional reference? Perform a search on the FHIR server and use the results? Translate
codes between code systems? Call another FUME mapping? no problem – there are a myriad of functions to help make your life easy, your work quick, and your resources perfect.

FHIR shorthand superscript:

As we have previously said, we at Outburn LOVE FHIR-shorthand
(FSH). It is a marvelous tool for creating all sorts of profiles and resources in a FHIR setting. Unfortunately, it is mostly geared towards profiles and examples and cannot handle a great workload of thousands of instances and was never meant for this purpose. That being said, we could see the potential of FSH as a mapping syntax for a FHIR converter and defined our own FSH superscript based on everything that FSH does well. We then created a dedicated parser and compiler, and made it blazing fast (anybody
working with FSH knows about the speed problem) and able to produce as many instances as any system would require, in a very short time. All in a push of button!

More features

The GUI:

The FUME FHIR converter GUI contains 3 parts: a pane housing a sample of the data to be transformed. Each key in the key-value pair also acts as a parameter name for the expression pane, where we actually do the work, i.e., typing, calling functions and such. Finally, we get to see the magic happen: in a dedicated portion of the screen, we can see the result of the conversion come into life in real-time. For example - the
JSON structure of the FHIR resource we are creating. Any change in the other panes is translated in real time to changes in the final product. It’s really cool seeing a GET method get translated right in front of your eyes into useable JSON, or seeing how a deeply nested tree of data evolves in front of you as you type!

Terminology translations on the fly:

FUME utilizes ConceptMaps stored on the server to automatically translate your local codes into more interoperable ones, taken from international and widely accepted code systems, such as HL7 CodeSystems, SNOMED-CT, LOINC, UCUM, ICD-10 etc.
Wherever in your source data the code is - just wrap it with the $translate() function, and FUME will leverage any FHIR or terminology server to do the translation.

What got me excited:

After getting to use the FUME FHIR converter for a while, here are my personal oh-wow’s:

·    Easy to use, shallow learning curve

·    No need to program anything – ready to use out of the box

·    Everything is right in front of you, in one screen

·    You don’t need to be a FHIR expert, and you certainly never need to write your own resources. Say goodbye to JSON bugs!

·    It prevents most errors I've encountered in my work in the past 2 years as a FHIR programmer and implementor

·    You can see everything happen in real time – you don’t have to compile anything before you see the result

·    Create thousands of resources in a very short time

·    If you really insist – you can actually use FUME’s robust processing model to do elaborate functional programming. But this is really just for the extreme nerds – you don’t need this functionality 🙂

Well, after all that, I bet your just FUME-ing to try it. I can’t blame you. We will be launching FUME FHIR converter in January 2023.

Stay tuned!

Important links

Now that you know a bit about FUME, here are a few links to check out:

FUME product page

FUME Documentation

FUME sandbox - try it for yourself!

Tutorial playlist

Follow us on LinkedIn

More To Explore