De Novo EMR Design - Part I: Stating the Obvious

Our ancestors began using tools millions of years ago and humanity assumed control of the planet it lives on through a succession of tools ranging from sticks and stones all the way to iPhones and drones. The basic process for discovering or inventing tools hasn’t changed much over the millennia, and it follows two basic patterns. Either an existing artifact is examined for fitness to various purposes until one such purpose is discovered accidentally or through organized efforts, or a problem is identified and a tool is then invented, or located, to solve the problem. The problem itself could be something that was thought impossible before, such as flying, or a more mundane desire to reduce the effort and expand the capabilities associated with an existing activity, such as moving goods from one place to another. Tools can have limited effects, revolutionize an entire economic sector or can change history, and some tools can have harmful effects that must be balanced with the benefits they offer for the intended task. Tools usually undergo long processes of change, improvement and expansion, and sometimes the evolving tool looks nothing like the original invention. Why are we talking about tools here? Because programmable computers are tools. The computer hardware is like the hammer head and the programming software is like the hammer’s handle (more or less). And EMRs are one such handle.

Let’s imagine that we are software builders and we have a desire to help doctors deliver patient care. And let’s further assume that we, and our prospective customers, examined all the existing tools out there and found them not quite fit for purpose. Let’s also assume that we are not suffering from delusions of grandeur, have the humility to admit that we don’t know how to cure disease and have no interest in global social engineering initiatives. Let’s imagine that we are the misguided founders of a small social business interested in doing well by helping others do good things.

The following is a theoretical exercise in software product design for the shrinking market niche still subscribing to Sir William Osler’s views on medicine. Therefore our starting point will be fixed by the assumption that medicine is “a calling, not a business” and that medicine is to remain a “humanitarian and respected profession” concerned with “diminishing human suffering”. Since we are not out to develop drugs or devices, the overriding goal for our imaginary software is to improve patient care. But in order to improve something, we first need to at least understand what that something is. So what is patient care? For simplicity of illustration, let’s further constrain ourselves to primary care, because it is probably the most common and best understood type of patient care.

Patient care is a longitudinal activity occurring over varying periods of time, but it is not continuous; instead it is a chain of discrete units of service usually called encounters, which may or may not be dependent on each other. Encounters can be proactive, reactive, physical or virtual. The mechanics of a patient encounter in primary care is very simple. Patient comes in (or not), patient relates problems (if any) to physician, physician formulates diagnosis based on patient narrative, physical examination, diagnostic measurements and finally suggests therapies to resolve, alleviate or prevent suffering from problems. Patient may or may not agree with suggestion. There are three major parts to this process - gathering of information, synthesis of information and relationship building - and each part has a very clear purpose. Note that documenting the events is just a corollary to the main process. Sounds simple? Not quite.

While this is the current practice, many product designers are designing software for what they think patient care should be, adding and removing parts to and from the current process, or disregarding the existing process in its entirety. To understand why this is a problem, let’s think about Microsoft Word. Manny decades ago, writing consisted of a blank sheet of paper and a writing instrument, quill, pen or pencil. First the typewriter removed the work needed to shape each letter by hand, and then the computer removed the need to have a physical piece of paper, and instead gave us an infinite number of blank sheets, with obvious benefits to the user. What neither of these inventions did is to redefine the authoring process; you still have to pick something to write about, do your research and “write” it down. The word processor makes it easier and cheaper to write, to fix mistakes and to make your masterpiece look appealing. Now imagine what would have happened if the creators of Microsoft Word would have decided to be a bit more helpful and gave you a series of dropdowns and buttons to choose and refine the subject of your writing and then plopped in a prewritten article, which you can now edit to your liking. Who would have used this contraption? People who have no business writing in the first place. As is true with medicine, in software design sometimes less functionality is better functionality, particularly when the extra functionality is paternalistically dictated by the purveyors of software.

Back to our little project, what do we have so far in the way of requirements?

1. System shall assist with gathering information from various sources (TBD) at the point of care
2. System shall assist with synthesis of said information
3. System shall assist with patient-doctor relationship building

Note that since we are not building a replacement for the user, our system is an assistive technology system and nothing more. These requirements are not granular enough to start programming from, but are there to always look up to, and see if everything we do serves one of those basic goals. If it doesn’t, then it should not be built. Note also that we are not questioning the user’s “workflow”, wisdom or professional decisions. We are aiming to provide a limited service, and will leave “fixing health care” to more ambitious folks. To any set of basic requirements, I like to add the prime directive of software development, which is a general warning for subsequent designers, architects and programmers:  

4. System shall not make the task harder to perform for the user

The next phase of design will take our primary set of requirements and break them down into concrete software tasks (and no, #3 is not a joke). To do that, one should understand in minute detail, and preferably practice, patient care, particularly for the purpose of observing the constraint imposed by #4. The creators of Microsoft Word, and all other direct to consumer software builders, have a much easier time with this portion, since everybody writes. Those who build software tools for domains that they are not familiar with have a tendency to make too many assumptions based on random and infrequent encounters with said domain (e.g. I take my kids to doctors all the time, I had to go to the ER once and I know how it works, etc.). Translating the above requirements into concrete specifications should entail many months of research. Assuming we have that under our belt, we are ready to move on to the next step.

Even to the untrained eye, our first three basic requirements speak volumes. #1 looks like something computers can do very well. #2 looks like something that computers may be able to do very well in the future, but right now it embodies lots of difficulties and temptations best avoided. #3 looks ridiculous to some, but very promising to younger folks who define relationships through software apps. Another nifty thing that practically jumps out of the page is that we don’t have to satisfy all 3 requirements all at once in order to have a useful product. Thus our little project lends itself very well to an agile development model where we can have successive series of small releases that are useful to our users from the get go.  Another look at those general goals reveals that we could benefit from placing some boundaries on the magnitude of our project to avoid the number one pitfall of all software projects – scope creep, or consistently succumbing to the temptation of adding one more little thing. To do that we should look, within our scope of service, at what patient care is not.

• Patient care is not a synonym for public health.
• Patient care is not a financial transaction.
• Patient care is not lifestyle coaching.
• Patient care is not a commodity (at least until people become a commodity as well).

And just in case we were not specific enough in our definitions, this software is for physicians administering care to an individual patient. We are not designing tools for staff, billers, payers, employers, federal or state agencies, and no, we are not building tools for patients. Although requirement #3 may drive us to address the patient perspective to the extent that it is pertinent to physician activities, our (paying) customer persona is the doctor (we’ll expose some APIs for the rest of the world…).

So let’s tackle the biggest bang for the buck first, and get started from the top. Part II will attempt to define a manageable set of specifications for our imaginary product. In the meantime, feel free to contribute to this thought process….