Implementation guide basic queries

I am new to FHIR in general and definitely new to Implementation guide. There are plenty of things that are unclear to me.

Recently, we implemented a healthcare app - lets call it A that can give the user’s blood pressure, temperature, etc. We also built a test app that can integrate with it.

All these apps are FHIR compliant. The test app sends a ServiceRequest to the app A to get data. A sends back a response in FHIR compliant format (ObservationResponse) with the data that the user wants. Ex: the test app may ask for temperature and A will give the reading.

We are also making our app open for other 3rd party developers to integrate with. Ex: any 3rd party app should be able to integrate with us by sending a FHIR compliant request (ServiceRequest) and can get the data they want by reading in the ObservationResponse it receives.

If someone wants to build an app that integrates with ours, I can tell them the following -

  1. FHIR request they need to send us
  2. FHIR response they can expect - including the complete structure.
  3. What values to populate in the request and what fields to read from the output.
  4. I can share examples as well.
  5. We work through Android intent calls (not sure if that matters)

Overall, our implementation is a very basic FHIR integration. An app willing to integrate has to send a request in a specific format and expect a particular output.

However, I am not sure what goes into the Implementation guide. I looked at some examples but did not get much of a clue.In fact, it left me more confused.

Some questions:

  1. Whatever inputs I have for integration (mentioned above), is that what we need for the implementation guide?
  2. Any other info we need to add?
  3. Where in implementation guide do we add these? Most sections do not seem to apply to our case at all. I do see a section titled: ImplementationGuide.definition and a subsection titled ImplementationGuide.definition.resource under that. Is this where the above data goes in?
  4. If so, do we use complete structures?
  5. Do we provide a skeleton structure of the ServiceRequest and ObservationResponse in one of the above sections? And give actual examples down below?
  6. How do we differentiate what is an input and what is an output?

Thanks in advance!

ImplementationGuides typically have CapabilityStatements (that define the different systems involved and what operations they need to be able to invoke or respond to), StructureDefinitions (that define the data structures passed to and from those operations), ValueSets (that define the codes to be used within those data structures) and occasionally other resources such as OperationDefinitions, MessageDefinitions, etc. The ImplementationGuide just ‘packages’ the information shared. The interpretation of how the resources interrelate is handled by their relationships. For example, the CapabilityStatement for ‘client’ systems might say “SHALL support ‘create’ on ServiceRequest” and list the profile that must be supported for that resource.

The profiles (StructureDefinitions) would identify the specific elements that must be present (min cardinality >=1), but can also identify what elements might not always be populated, but are expected to be present if relevant and that the system will pay attention to (mustSupport = true). The StructureDefinitions can just declare the differences from the base resource and the publishing process will produce a view that applies that ‘differential’ statement and generate a snapshot showing what the resource looks like with all of the deltas applied.

There are lots of implementation guides available on FHIR now. Look here to see published versions ( and you can see the source for many of the IGs on HL7’s Github repository ( You might find this sample IG as a reasonable place to get started (though it’s brand new and will likely evolve a fair bit over the next few months as the publishing tool capabilities change and as we flesh it out more.): That will include adding some basic CapabilityStatement examples

Thanks for the clarifications. That was really helpful. I will look further into CapabilityStatements and ValueSets and Messaging as that may be of interest for us.