We had an interesting discussion today about how to ‘notify’ clinicians that there is a document in a repository for a patient that they are looking after.
The documents in question will be clinical summaries of ambulance visits, and will be held in a highly available repository hosted by the ambulance service, from which authorized users (including the patient) may view them. This repository will be part of an XDS style implementation, so the repository will create a metadata resource (DocumentReference) and send that to the Registry (which we’re terming a ‘Record Locator’ service).
Once there, clinicians and patients will be able to locate and view the documents in the ways that we’ve already discussed.
In addition to storing the document, we also want to be able to create a notification to the patients usual General Practitioner (Primary Care Provider to you US folk) so that they know that an ambulance visit has occurred and there is a new Transfer of Care document for them to review.
The reason for this is that it is very useful for the GP to know that their patient has been seen by the ambulance service, in case follow up is required. In many cases – particularly when the ambulance call does not involve a hospital visit – and hence there is no hospital discharge summary to the GP – they have no way of knowing that the visit occurred. An example of this is where the patient has an asthmatic attack and is nebulized successfully at home.
So the workflow will go something like this:
- The Ambulance system creates the document (likely a CDA) and saves it directly in its repository – along with all the other required metadata. (This is the integrated document source/repository actor in XDS).
- The Repository will generate a DocumentReference resource, and send that to the Registry.
- The Registry will save the DocumentReference resource, and also generate a new resource – the Notification resource – that is directed to the patients usual GP (which will be in the Patient.careProvider property). There’s nothing to stop it creating multiple notifications – eg to a patients care team – if there are business reasons for doing so.
Once this is done, GP’s will be able to receive the notification by means of an RSS feed querying the Notification resource like this:
GET [host]/Other?code='notification'&target=<GP>&_since=<lastQueryTime>
which will return a bundle (Atom feed) of Notification resources for that GP. They can then use the Notification (specifically the DocumentReference property) to retrieve the actual document for viewing.
So what is this Notification Resource? Well, it doesn’t actually exist yet. To implement notifications we need to use the Other resource, which has been specifically designed for situations like this: we need a resource that is not yet defined (or maybe won’t be). It has a simple structure:
- Code – the type of resource. This will indicate that it is a notification resource.
- Subject – the patient
- Author – in this case the ambulance system
- Created – the date of creation
And then you add as many other properties (as extensions) that you want. We’ll probably need:
- Type – the type of Notification – eg that there is a new document for them. We could get fancier if we want to…
- About – the DocumentReference reference
- Target – a Provider resource reference to the GP
Why have we specified a separate resource for the notification, rather than just storing the GP as an extension to the DocumentReference resource and querying on that? Well:
- A tight coupling in this way would mean that the ‘notification’ is for DocumentReference resources only, and we may want to support other Use Cases – such as a notification that a patient has been admitted into hospital.
- More complex workflow – like the ability to record that the notification has been viewed and accepted (or declined) would be tricky. (Actually this is more Task type behaviour – but then, a Notification could be thought of as a type of task)
- It feels like we’re binding together behaviour that doesn’t belong together.
Some other notes:
- We’ll probably get the registry to provide a special service for this ‘save metadata and create notification’ functionality – eg POST /service/DocumentReference/saveAndNotify that takes the DocumentReference resource and does the rest. (I’ve grown rather fond of these services since Keith suggested them!)
- Because the notification query is based on an extension, the server needs to map the ‘target‘ query parameter to the target extension. We really want to be able to search on the identifier property of the Practitioner resource that is the target property of the Notification, so we’ll need to set up the profile accordingly.
And finally, in our particular situation there are a couple of wrinkles:
- The delivery timeframe of the project is before the Record Locator service is likely to be in place
- This design requires that the vendors of Practice Management Systems that the GP’s use need to implement the RSS/Atom query mechanism
For the first wrinkle, the RSS/Atom lookup will initially be provided directly by the Ambulance Repository application. Then, when the remainder of the infrastructure is in place the consumers will simply need to change URL’s to switch to the Record Locator/Registry and the system will otherwise work unchanged.
In the second case, there are a number of portal applications in use in New Zealand – we’ll add the display of notifications to those portals so that when GP’s and patients log into the Portals they will receive the notifications in the same way as they would from within their GP PMS. Hopefully, this will allow the PMS vendors to see the value of this approach, and implement the functionality directly (it’s not that hard for a consumer after all!)
Since writing this post, I’ve written another one, further extending the concept of Notifications, thinking about how to manage workflow.