Don’t make users learn codes in place of business terms

Here is a good example of bad user experience I came across recently.

In training, I was told the various status codes that health claims would be in.

  • 125 for a pending claim.
  • 483 for a paid claim.
  • And so on.

I was also told codes that indicate the results of business jobs

  • 0 means a claim has been priced completely.
  • 58 means claim has an unknown provider.
  • 26, 27,28 are violations of Wyoming state laws regarding Medicaid claims for black lung disease.
  • And so on.

Then they tested us on these codes.  I did poorly on the test. Who can remember all these damn codes?

So, I have a question.

Why can’t a pending claim simply be marked ‘pending claim’? Why must you come you convert that plain English status to a number?

If there are technical reasons for representing that status as a number, fine, do so.  However, why must I, the business user, be exposed to that number? Why can’t you keep the number to yourself, and tell me the claim’s status in plain English?

Why are you making me remember arbitrary numbers, when natural and easy to understand business terminology exist?

And last but not least, if the business user did not see these numbers, you can avoid a whole chunk of training.   Is that anything but a good thing?

This is an example of “Design is an act of communication“.

This is user experience.

User experience in a back-office application

I can’t ever seem to explain what ‘user experience‘ is, leave alone make the case that it is important.  I say ‘user experience‘ and people hear ‘user interface‘.

User experience in an in-house, back-office application

Let’s try this.

Imagine I am speaking to a bean counter type middle manager in some sclerotic insurance company. I say this to him.

You make sure that the user knows the business.

I will build a system that a user can run the business with.

The user will not require training to use the system.

The system is not the business.

The system is a transparent tool that anyone with business knowledge will simply ‘get’.

The system will ensure that the user executes the business correctly, and efficiently.

New Enrollment into a Medicare Prescription Drug Plan

Consider new enrollment into a Medicare Part D plan (Prescription Drug Plan).  The insurance processor must know the business, described below.

  • A person comes to us, asking to enroll in a prescription drug plan.
  • In response we send a query to CMS (Centers for Medicare and Medicaid Services) to confirm that the applicant is eligible for the benefits she is asking for.  In industry jargon, this is the BEQ (Batch Eligibility Query).
  • If CMS finds that the applicant is eligible, we complete the application, and formally notify CMS that the person has enrolled into a Medicare Prescription Drug Plan.   This happens through the MARx Batch Input Transaction File, which we send to CMS every day.
  • Then we wait for CMS to tell us that it has accepted this person’s enrollment.  This is through the Transaction Reply Report (aka TRR), which CMS sends us daily.
  • Now, the member is completely enrolled.

Say we build a software system that allows the processor to execute the above workflow.   In addition, say we promise that the processor can simply be put in front of the system, and she will be able figure out how to perform the business without any further training from us.

More than ‘user interface’

If we can build such a system, we will have mastered user experience.

Think about what it takes to accomplish that.

Clearly we are talking about more than proficiency in HTML and Javascript.  At the very least, we the engineers, have to know the business, and we have to know the business users.

Process is very often, much ado about little

The first principle in the Agile Manifesto is “Individuals and Interactions, over processes and tools”. A recent development task illustrated that point starkly – skill trumps process.

Time’s a wastin ….

I was working through a weekend, exhaustively specifying the UI (mockups, WORD docs, UML State diagrams) for a recent user story, when it occurred to me that we were wasting our time.

Here is more or less the user story I was working on.

As a documentation processor, I must be able to review all of the documents in a mailbag. Upon review, I must be able to accept, or reject each of these documents.

In the time that it was taking to describe the UI to its last gory detail,  I could create a working prototype of the UI, which would be close to 80% of what the user needs.  The business folks could take the prototype for a spin, and give me feedback, which could quickly iron out the remaining 20% of the work.

See, we are building this for processors in an insurance company.   They are not looking for sophisticated, space age UI.  They just need something that is easy to understand, learn, and allows them to do the work efficiently.

Between the business analyst and me, we could have the UI squared away in a couple of weeks – a single sprint.  Add a tester if you must.

I will test every damn line of code I write anyway, before this leaves my hands.   The tester is only a second line of defense.   Even without that tester, I can get this very close to done.

So why am I specifying the UI when I can just build the thing myself?  I am having to do this because, collectively, the primary resources that are assigned to this task cannot or will not, produce an effective UI on their own.  That amazes me.  I am shaking my head as I write this.   If you have several years of experience with this problem domain, with these business analysts, with these end users, and with the same UI technology, you should be able to take the user story, fill in all the missing details, and end up at the UI.

Again, here is the user story, for reference.

As a documentation processor, I must be able to review all of the documents in a mailbag. Upon review, I must be able to accept, or reject each of these documents.

Let’s think through this.


  • Users have to review all the documents in the mail bag.
    • This means you have to list the documents to the user
  • So how do you present a list of documents.
    • A table, where each column is some attribute of the document, and each row is a document.
  • How do you make it easy for a user to study a large list of data that is in a table?
    • Allow filtering and sorting by various attributes.
    • Break up the list into several pages, and allow the user to page
      • Or simply allow the user to scroll up and down the large list.
  • How do you help the user make changes to large amounts of data safely, and correctly?
    • You must ask the user to confirm a large change.  Give her a chance to back out.
    • You must provide the user a way to undo a change.  Mistakes will happen.
  • What attributes (columns) of the documents must be included in the list
    • Leave out the attributes of the documents that are implementation-centric, which users have no need to know.
    • Pick the attributes that are business information.  Make a guess on which of these the user might be interested in.   Changing this list after review should not be hard.

Can’t the developer do this?


If you have been developing UI for any time at all, you should be able to do the analysis I just did, and arrive at a similar, if not the same place.

Business Info

You have been working in this domain for several years.  That means you must already have all the business information you need.

You must know the business-centric attributes that characterize the mailbag and documents.   These become the columns of your listing, and suggest what the user can sort and filter on.

Language and jargon that end-users will recognize must also be familiar to you by now.  This is where static labels, feedback messages and such will come from.


You have been working with your UI framework for several years.  So you should know how to implement the various UI features mentioned above – a table of data, sorting, filtering, paging, scrolling.

But none of this happened

But none of this happened, and a UI designer had to be brought in to spell everything out.   Why?

The Developer

Though they were well-versed with the UI framework, the developers have little knowledge of, or interest in, what makes an effective UI.

They are happy to be told what to build.  They want to be told what to build.  When left to their own initiative earlier, they produced a UI that so defied common sense and business reality, that the end-users’ job turned into a labor-intensive, error-prone, hell.

The Tester

If the testers know the lingua franca of the business (English, in this case), if the testers know the business, and if they know the end-users, the testers can judge if the UI satisfies the business need, simply by relying on the 2 sentence user story.

Unfortunately, testers’ familiarity with the business is uneven.  They are simply kids that compare a spec to delivered software.  If the spec is incomplete, or incorrect, these testers are thrown off course.

Further, more often than not, the testing leadership subscribes to the view that testers must only work off an exhaustively detailed spec.  Applying their own knowledge of the business, their own analytical and communication skills, is considered risky. The focus on learning the business themselves is weak.


Well, managers have all the power, which makes them responsible for everything, doesn’t it?

Who are they hiring?

The UI developer does not exhibit knowledge of effective UI design.    So how did we end up hiring him?

Say the manager that is evaluating the developer does not know anything about UI design himself.   So the manager cannot determine the developer’s competence in the matter.  That is reasonable and common.   A manager is constantly confronted with problems in which he does not have direct expertise.   Yet, she must hire people that will be responsible for solving that problem.    In that situation, a manager has to be able to recognize competence (and conversely, incompetence) as a characteristic separate from concretely observable skill.   Competence has an aura, a body language, a speech pattern, a look in the eye, as does incompetence. You have to be able to smell the bullshit before you see it.

When managers neither have concrete expertise, nor do they have a nose for fakery, we end up with these half-baked developers that require to be spoon fed.

Bad drivers

Many resources are able to learn and do more if we create the right environment.  This is usually some combination of large grained carrot and stick, coupled with the pushing of buttons that we can only learn by getting to know the resource personally.

Effective UI design for the corporate world, is a skill that can be learned by just about anyone in a few weeks, or over the course of a few UI development tasks.  If a developer has worked on UI development for going on three years, and still does not have a coherent, useful view of the matter, the leadership has been asleep at the wheel.

The same argument applies to the testers.   The management enabled them to be unthinking, ‘garbage in garbage out’ type grunts.

Skill trumps process

What a business analyst and a skilled engineer can take care, is now distributed over a whole platoon – The business analyst, the UI designer, the developer, the tester, tech and test leads to oversee the grunts, managers to oversee all of this.

Where the work could simply be a conversation between two people, now is a multi-step workflow involving many more people than that.  Two people getting a task done is just work.    Eight people, each with their own inputs, and deliverables, working on narrow parts of the whole, and that with their vision constrained by blinders, is a process.

What does the process buy us?   Nothing that I can see.  I see overhead. An 8 to 10 person team requires more management and book-keeping than a 2 person team. I see a machine with more moving parts, which exponentially increases the complexity, the amount of co-ordination required, and the number of ways the process can fail.

One or two committed, skilled engineers can replace the whole process. Why not learn to identify, hire and hold on to such resources? Why the fixation on process? Do you want get work done?  Or do you want to run a process?

Do ‘meaningful use’ standards include pushing lab results to patients?

I went in for some medical tests early yesterday morning.  It has been over a day since then, and there are several questions I wish I had answers for.

  • My insurance changed recently.  Has the change registered correctly at the hospital?  Will there be any mishaps with payments?
  • I left my urine sample in a little cupboard.  The cupboard already had another sample, which had not been picked up yet.   Did someone pick the samples up, all right?  Have the tests been performed yet, and are the results in hand?
  • Have the results been sent to the physician who ordered the tests?
  • Will the lab send me the results?  I would like an electronic copy of the results.   They are my tests dammit.

Events in the workflow

Each of these is an event in the workflow that was my tests.  Notifications about the disposition of these events would set my mind at ease.  I understand some folks might not want this much information. Well, make these notifications optional; let me choose which ones I want to receive.

When a business process is carrying out a customer’s business, some events in the process will be of interest to the customer.  Are you able let the customer choose the events they want to know about, and how they would like to be notified?  I would not mind a tweet.  Others might like an email, or a text message.   It is not hard to see that this need is a natural part of any enterprise system, which is carrying out a customer’s business.  This is ‘user experience‘, which to my mind is also, often synonymous with ‘customer service‘.

It occurs to me that either the lab where the tests were performed, or the physician that ordered the tests could keep me informed.  Of course, no joy from either party at the moment.   Some day ….

I dug through the EHR certification requirements for Stage 2 of ‘meaningful use’, and found only a reference to facilities of the ‘pull’ variety.   The EHR must allow MU data (lab results included) to be viewed, downloaded, and transmitted.

   § 170.314(e)(1):  View, Download, and Transmit to 3rd Party

However, these documents are hard to read, and I might have missed something.

The computer programmer in me is a little bit happy I think.  As everyone keeps saying, a lot of work remains to be done.

I haven’t met a physician yet, who likes EMR software

I only have anecdotal evidence, but every physician I talk to, hates the EMR software he has to deal with.

Ye old Enterprise IT

One particularly tech savvy young resident in an area hospital, says, “… too many clicks, too many clicks“. These are folks that live in their iPhones and iPads every spare moment they have.

As he did book-keeping on his laptop, I peaked over his shoulder at the EMR program he was using.  Also, a couple of months ago, I had occasion to spend a few days at Johns Hopkins, helping take care of a family member, and I took every chance to watch the staff at work at their monitors, which now seem to be stashed into every available corner (each patient’s room had a desktop, monitor, keyboard, and mouse).  I was a little taken aback to see that they were all using Windows desktop applications.  Seen through eyes drunk on modern touch-screen mobile devices, these apps look old-fashioned – poor, tired, windows, boxes, lists and buttons, huddled together in an unappealing jumble.

My doctor friend said his EMR was cumbersome to use, and it took too long to enter all the data that he is prompted for.  He seemed to unconsciously separate information that is vital to patient care, from information that is just “for billing“. Often, he enters only the patient care information that he thinks is necessary, and ignores what he called, “fluff“.

The word “fluff” struck a chord.  Design for mobile first.  That forces you to identify the “fluff“, and drop it.

Essentially, what I saw was classic Enterprise IT interfaces.  They serve some bare business purpose, with little thought to ease of use.  Users, doctors, and nurses, in the midst of their high-stress workdays, just deal with it, because, well, they have to.

There were more tell-tale signs of Enterprise IT.

"Yea, they improve things, but everybody hates the changes. You 
manage to learn one thing, and then they make you learn something 
new all over again."
"They never ask the doctors.  They try to keep us away from what 
they are doing.   They build something and show it to us, and it 
is not great, but then it is too late to change anything."

Impenetrable domain knowledge

The doctor is looking at lab results.  He sees that haemoglobin is low.   In that situation he is taught to then look at past iron levels, and vitamin levels, which are results of other tests.   In the interface he showed me, the iron levels, and vitamin levels were hard to find.  The lab results were a long Excel like table, and he had to scroll far and wide to find them.  They were not close to the haemoglobin levels.  The interface was not smart enough to offer the iron levels and vitamin levels when it detects that the haemoglobin is low. The doctor said he sometimes surrenders to fatigue and irritation and simply orders the tests for iron levels and vitamin levels again.   Of course that is duplicated effort for someone, not to mention a wasted expense.

The business analyst who modeled the diagnostic processes obviously did not know how medical personnel are expected to react to low haemoglobin.    The UI designer did not know that a relationship exists between low haemoglobin, and iron, and vitamin levels.   The interface they built does not reflect that knowledge.  The EMR software did not make the physician’s job easier.  In fact, it made the whole process more inefficient, and wasteful.

There must be so many other little use-cases like this.  I imagine the patient care domain is vast, varied, and complex.   A doctor spends years acquiring all that training, and knowledge.   How can you expect a business analyst, or UI designer to absorb all that information?   Even in the best of circumstances, there are so many ways for domain knowledge to get lost in the translation, from business user through business analyst, to system designer, and finally to the developer.  I imagine that this exercise is even more error-prone in a complex and information-heavy field like patient care.

Are we barking up entirely the wrong tree?  Is it a fool’s errand to try to model the patient care domain in order to produce a structured interface that makes the doctor’s job easier?


A simple-minded EMR

I wonder if something like this would be a viable EMR system?

A universal key

You must be able to uniquely identify a patient, a human being.   In other words, you need a universal key for their records, which you can apply at any health-care organization they are visiting.  Say, fingerprints.  Would that work?

A simple collection of documents

Medical records themselves are just a collection of documents.  They can be anything at all – plain text, HTML, WORD, EXCEL, PDF, audio, photos, video, etc.  Each provider simply creates whatever records makes them happy, in any format at all.

Each document is characterized by very simple, non-medical meta-data.

  • Who created them?
  • When were they created?
  • etc.

The documents are all stored together against that universal key.   You have the patient’s fingerprint, you have her records.


You need the ability to search through a patient’s medical records – the collection of heterogenous documents. You must be able to return results ranked by relevance.


You must have the ability to simply transfer the records of a particular person between providers.  And even to the patient herself.   This is a simple transfer, because there is little structure to speak of.   It could be as simple as an email with attachments.

Start Minimal

That’s it.   There is your minimal, but possibly complete, EMR.  In capability, it probably matches what folks are able to do with paper records, with added sugar due to the fact that the records are native citizens of the digital world.

The system is simple enough that it can be quickly adopted by organizations.  This is what every institution must be able to do, off the blocks.  No complex analysis effort.   No errors that are introduced simply by the act of creating the new system.

And build on it

Once the system is on-line, slowly build on it.

  • Improve identity tracking, if necessary.
  • Improve entry, generation, and visualization of data.   As we saw above, this means applying knowledge that only physicians have.   Business analysis must come directly from the physicians.   Work on one specialty at a time.  Work on one disease at a time.  Or something like that.
  • Improve search.  Which is really ‘data analysis‘ aka ‘analytics‘ aka ‘big data‘.
  • Improve data storage, and data transfer.

And so on.


Many Whys

So why are EMR systems not as simple as the one described above?

Are there considerations that I still have not learned about?

Why is there so much structure, which is hard to get right, and much of it un-intuitive to physicians?   Are these related to ‘accountability‘, and ‘billing‘?

I mentioned HL7 standards, and SNOMED taxonomies to a couple of young doctors – a resident, and a fellow.  They had never heard of them.  This is medical knowledge that software engineers are basing EMR software on, and doctors have little knowledge of them?  I was about to sign up for an expensive week-long seminar on HL7.   Is that a waste?   What is going on?

I went to a meet-up of the local Health 2.0 chapter.  Folks spoke with enthusiasm about many things, but EMR systems did not come up at all.

There seem to be a lot of startups doing healthcare related work in Pittsburgh.   However, everybody I met is working on devices, and solutions for use by individuals to get control of their personal health .  No one said anything about making a doctor’s day to day work easier, and more effective.

There is something interesting going on here.   Are enterprise concerns, like EMR, simply  un-cool?  Or are they considered a done deal?   Is it too late, and well-nigh impossible, to enter the field now, and improve on matters?











What use is knowledge that I cannot name?

It turns out that I have done information architecture for some time now, but I never knew it.

A young acquaintance is learning HTML, CSS and such.  I gave him Steve Krug’s classic handbook, Don’t Make Me Think.  My young friend banged through the book in a day, and his cup running over, started going on about this, that, and the other, including at one point, ‘tabbed pages‘.  After some confusion, I realized he was referring to a web page whose content was organized with tabs,

A web page organized with tabs

A web page organized with tabs


rather than the tabs that most modern browsers offer.

Tabs in a browser

Tabbed Browser windows

Unaccountably, the ‘tabbed pages’ triggered a thought that had not occurred to me before – the ‘tabbed page’ represents at least three different kinds of knowledge.

The users’ needs

Tabs in a web page exist for a reason.  They serve a purpose.   Someone devised them to solve a problem.  What is that problem?

Shoe store

A user is at shopping site.  Say, a shoe store.

The store sells stuff that you can classify in categories that are familiar to, and expected by the user – Men, Women, Children, Casual, Formal, Outdoor, etc.   Each category of shoes has more items than you can fit in the real estate available on a single web page.

The shopper must be able to peruse any category that she is interested in.   Further, regardless of where she is in the site, the shopper must be able to switch to any other category of shoes.

Farm insurance policy

You own a large farm.  You have an insurance policy for the farm, which includes many individual coverages.  You have had the policy at the same insurer for several years.   You want to log in to your insurance company’s web site, and see all available information on your farm policy.

An insurance policy is characterized by many different kinds of information.

  • Demographic information about the policy’s owner – name, address, age, marital and employment status, etc.
  • The various coverages included in the policy – Livestock, limits of the coverage, deductible associated with the coverage; outdoor buildings, limits of the coverage, deductible associated with this coverage; coverage on machinery; coverage against crop failure; and it can go on and on.
  • Historical data – the policy as it existed in past years (the industry refers to that as ‘terms’)
  • Billing history
  • Documents associated with the policy – signed agreements, photos, letters that went between customer and insurer, etc.

You cannot fit all of this information into a single screen.   You must clearly indicate what types of information are available for a policy.  Finally you must allow the user to pull up and view any type of information, at any point in her interaction with the web site.

Someone must know

Someone must know the data you are presenting.   What is this data’s place, and purpose in the world as we know it?  Can we break the data down into coherent parts?  How might the parts be related to each other?  How do you refer to the various slices, and components of the data?

Someone must know the needs of the user vis-a-vis that data.   How does the user understand the data?  What is her mental map of the data?  How does she categorize the data?  What names and labels does she use to refer to the data?  How does she think the various pieces of the data are related to each to other?  What exactly is the user interested in viewing?   What processing might she want to trigger on the data?

What do you call this knowledge?

I always thought of this knowledge as ‘business analysis‘. I suspect that most folks I have worked with, none of them trained in the magic arts of user interface design, would also think of this as ‘business analysis‘.

However, I am learning lately that this particular sliver of the business might be known as ‘information architecture‘.  I am not sure. Does it matter what it is called?


Presentation solutions

Now you understand the data that you have to present.   You also understand the user’s expectations regarding the data.   Can you devise ways of presenting the data such that the user’s needs are served?

You do not know how to write computer programs.  You know color, shape, image, typography, and layout.  You know how people react to these visual elements.   You can communicate with people using just those tools.   You know how to convey information, suggest actions, and create a virtual environment on the computer screen, which makes a user feel safe, competent, and perhaps even happy.

You are able to use the expertise I described above and design many different ways to satisfy the needs documented by the ‘information architecture‘.  Of these various alternatives, ‘tabbed pages‘ are just one.  Here are some others.


Drop-down for choosing between categories

Drop-down for choosing between categories



An index, and a tree of links

An index, and a tree of links


tag cloud

A tag cloud


You also probably know how to present these alternatives to users, and test their use of them to determine what works best.

Once one of these alternatives, perhaps even tabbed pages, is chosen, you ask computer programmers to construct the interface.

What do you call this knowledge?

So what do people call this expertise?   I hear several terms, all of which seem related.

  • Graphic design
  • Visual design
  • Interaction design
  • Human computer interaction
  • Anything else?

Do they all refer to the same questions, and answers?  Is there an overlap?   Does it matter?

Is it possible to be good at one, and not the other?  Can you be a good graphic designer, but a poor visual designer?  Could you be an an expert on human computer interaction without being a good visual designer?  Or could you be good visual designer but know little about interaction design?  The last does seem plausible.  Mostly, all of this seems a little bit nuts; another case of words getting in the way of meaning.

In layman’s (that would be me) terms, this expertise simply seems to be what falls in between knowledge of the business – data, processes, and users, on the one hand, and the ability to construct the interface, on the other.   These folks design an interface in response to the business knowledge that the ‘business analysts’, or ‘information architects’ provide, and the ‘programmers’ (the construction workers of the digital world) tell the designers what they are able to slap together.

Constructing a solution

Finally, we have the field of knowledge that I am able to grasp effortlessly.   Given a blueprint of the interface, someone has to make it flesh.

You use languages and technologies like HTML, CSS, Javascript.   You can also choose some server-side poison like ASP, JSP, XUL, and so on.   The more you are cognizant of the other two kinds of knowledge, the more effective your construction will be.  However, you often know little other than the construction tools.

What is this knowledge called?

I think this is what many people call ‘web development‘.  Often, a web developer is almost always someone with only knowledge of  ‘construction‘.


Why does any of this matter?

If you are starting out, and getting a kick out of creating web-sites, are you able to figure out which of the three types of work is giving you the high?

Just as important, are you able to tell which of the three areas you have a facility for?

  1. Do you like the rigorous analysis, and the emphasis on precision in language, which seems the central characteristic of ‘information architecture‘?
  2. Do you have a gift for communicating visually, without which you can’t do well at the ‘presentation design‘ part of the work?
  3. Or do you have a gift for nuts and bolts detail, and are able to methodically, and relentlessly concentrate on a job till it is done?  This is what construction requires – stamina.

The question is just as relevant for someone like me, who has been programming for a while, and has lately developed an interest in something that I know is not exactly programming, but I don’t know what to call it.  The best thing I can think of is – you know, that thing that Apple does so well.   Design?  User experience design?  Usability?  What?  I have never thought of myself as a creative person.  What?

For the record, I think my strengths might be (1), and (3).   I enjoy, and obsess over (2), but I don’t have a gift for it.  I think.   As the man said, “it is a puzzlement”.

User experience for the techies

What do I think of when considering ‘user experience‘ for the technical folk?   What makes it easier to do their jobs?  What helps them do their jobs better?

Techies include the following sorts of resources.

  • Programmers
  • Testers
  • Dev Ops
  • Program Operators

As always, common factors that I listed in the post, User experience in an enterprise system, apply to these resources as well.

Programmers can see everything

Interestingly, it appears that programmers occupy a special place in the enterprise.   Everything, systems and data, that any corner of the enterprise sees and uses, must be accessible to some programmer or the other.  Who builds these systems?  Programmers.  Who do you call when anything goes wrong?  Programmers.   Nothing can be hidden from the programmers.

This means that the the user experience considerations that apply for everybody else in the enterprise, which I have written about in other posts, apply to programmers as well.

One thought occurs to me.   Doesn’t this kind of all-pervasive access raise privacy issues?  Not to mention security concerns?  I wonder how enterprises deal with this.


A Domain Specific Language (DSL)

Often, for some reason or the other, a programmer is asked to perform a business task.  The enterprise system typically supplies business users a graphical interface for this work.  Programmers can use that interface too.  However, programmers have technical skills that typical business users may not have. Further, programmers have responsibilities other than performing business tasks, which means they are looking to save as much time as possible.

Hence, if it is possible to provide programmers an alternate interface, which is more powerful, and more performant, even if more technically complex, it would be a good thing.

In some of my previous work, programmers did considerable customer support work. Often they would have to perform some activity that meant wading through pages and pages of UI, in order to make one small change, or press one button.  I heard them lamenting the lack of a more ‘expert’ kind of interface. After all, they arguably had more technical expertise than the rank and file business users.  We could have used a scripting solution. A couple of lines of a well designed DSL (domain specific language), would have put them all in a good mood, not to mention saved a lot of time, and energy.

Say that you have to change the type of roof, on the 3rd barn of the farm that is insured by farm policy, FU-237EKS. After the change, the policy must be assigned to an underwriter for review.   In the UI, the change happens on the 8th screen of the farm policy. The assignment to the underwriter is a further 3 screens down.   Rather than schelp through all that UI, some folks I knew would have liked to execute something like this script.

FU-237EKS.barns[3].roof = shingle
underwriters['nate silver'].reviews += fp237eks

However, keep in mind that it ought to be possible to design the graphical user interface so that it provides the same kind of power, and efficiency. The recent, industry-wide emphasis on usability is all about this kind of improvement.  The point here is that alternatives to GUIs (graphical user interfaces) exist, which might more naturally fit programmers’ sensibilities.

I also wonder if there might be certain kinds of business functions that are hard to represent in a GUI.  Some complex, but one-off, workflow, which has to be created on the fly, for instance.  This is a question to explore.


Some items related to support

  • You must be able to change the logging level that is in effect without stopping the application.
  • You must be able to add muscle to the system, without stopping anything.  Bring more servers on line, add more threads to a running server, and so on.


Software Configuration Management

Essentially, all of configuration management must be automated.

Check out, and check in of code; build, test, assembly, and release of an application, must be completely scriptable.  You should be able to do all of this at a click of a single button, or the issue of a single command at the command line.

In some of my previous work, even though the code base was all in one source control system, we used to have to explicitly issue about 60 check out commands. We never automated the check out. So to
create a new workspace, we would do a lot of manual work – 60 clicks of the mouse, 60 commands at the command line.

Releasing a new version of the application was a multi-step, manual process, which would require some Dev Ops person to be up at ungodly hours.

Some releases, especially emergency patches, were horrendously complex. Some poor schnook, sitting in India, used to have to painstakingly undo changes to several parts of the code base, make the release, and then restore all those changes.

Needless to say, this was error-prone. Disasters, big and small, begging to happen.  This should never be the case.

Software configuration management (sometimes referred to as build management, release management), must never be a burden to the developer.   Folks that specialize in this work (Dev Ops), must hide the complexity by automating it all away.   If you are using tools that do not lend themselves to this kind of automation, well, you are using the tools that developers cannot love.   This is infrastructure, which is meant to remove some of the drudgery from a developer’s working life.   So let us have useful, and reliable, infrastructure.



One of the most critical lessons of the Agile philosophy is the recognition that developers must also test.   The Agile world asks, how does a developer know he is done with a task?  The Agile world answers, he proves it with tests.  When all of his tests run successfully, the developer is done with his work.

Each developer must be able to test her work independently of other programmers.    This means that each developer must have separate sandboxes for code, and data.

Developers have their own sandboxes for code by virtue of using a 
source control system.  However, in my previous work, I often 
encountered resistance to setting up independent sandboxes for 
the data.  I never really understood this.  Why couldn't each 
developer have their own copy of the system database for instance?
Isn't this sort of thing quite inexpensive these days?

We must automate the generation, and load, of test data.

In one of my previous jobs, many tests required testers to create an
insurance policy.  These were manually entered, a laborious process,
which took significant time.   

As you can imagine, testing was not as rigorous as it could have been,
because it was just too hard to setup the data required for the test.

The system’s user interfaces must support automation.   This is necessary not only for functional testing, but more importantly, for load testing.   You have to be able to simulate many users banging on the UI.   For this to be done with any kind of rigor, you have to be able to drive the UI with scripts.  Keep that in mind when you construct the UI.

Tests must run continuously.  If you have ‘continuos integration‘ going, you have this in place.   Continuous integration is a feature of software configuration management.   Every time a change is checked into the source control system, you must automatically kick off a build of the whole system, which, by definition, includes tests.   This allows you to find errors sooner rather than later.   Continuous integration is possible only if all of your software configuration management is automated.

Finally, a replica of the production environment must be available to the developers.   Often, you run into errors that only seem to happen in production.   Give developers an environment that is identical to production, where they can test, and debug problems, without messing with the production environment itself.  Without this, you are asking developers to be brilliant, which seems like a high risk strategy.


Techies other than developers

So how about testers, dev ops personnel, and program operators?   These folks perform functions that have been covered above, and in earlier posts.

The section on testing applies to folks that are exclusively black box testers.   The section on configuration management applies to dev ops.   Earlier posts on graceful processes applies to program operators.


User experience for managers

There are at least two types of managers in an enterprise, right?

I think of them as ‘business managers‘ and ‘systems managers‘.

How are they different, in so far as user experience is concerned?

Business Architecture vs. System Architecture

We can approach this question using the same yardstick that I used in an earlier post, ‘User experience for business employees‘.  Business managers are expected to know the business, and not necessarily any one enterprise computer system that helps run the business.  A business manager should be able to move between companies that are in the same business, but may use different enterprise systems.   Within the same company, the enterprise systems may change as technologies evolve, but the business might stay largely the same.  Changing enterprise systems ought not to be the business manager’s concern, bread or butter.  So who is responsible for the enterprise system, which helps run the business.  Enter, the systems manager.

The business manager knows the goals of the business.  She is familiar with the various functions, capabilities and resources that collaborate to achieve the goals of the business.  Does that definition sound vaguely familiar?  It should, because that is the general definition of an architecture.   A business manager is cognizant of the business architecture.   A business architecture is separate from, and independent of what we could call the system architecture – individual computer based systems each with its own capabilities and responsibilities, interacting in well defined ways to implement the business architecture (aka the goals of the business).

For instance, a simplistic insurance company may be organized around these components – sales, underwriting, billing, and claims.   A business manager knows the responsibilities of each of these business components, and how these components collaborate with each other to produce outcomes that the insurance company wants.

However, the billing department might run its business on the backs of four different computer systems – a billing app that manages transactional billing data, a document management system that manages documents coming out of the billing app (bills, delinquency notices, etc.), a high volume print manager, and a messaging system that helps the billing department collaborate with the other business components – claims, and underwriting, and sales.  This is the system architecture that implements the billing component.   The billing manager’s focus stays with the business component as a whole, while some IT manager must know and keep control over the computer systems that help run billing.


User experience for a business manager

Truth be told, what a business manager requires will change from business to business.  I have little knowledge of any business, so there is specificity that I am not going to be able to provide.

However, thinking about this at a general architectural level, and applying anecdotal experience gained from working in a few enterprises, I believe we can come up with a list of what a business manager might find useful.


See the work flowing through the business architecture

The business manager will need to be able to witness, and evaluate the business that is flowing through the business architecture.   Two sorts of  views will be useful.

  • A snapshot of the state of things at a certain moment.  Now, two hours ago, closing time yesterday, etc. This should allow creation of a real time tracker of the business.  Any hotspots, bottlenecks?
  • Aggregate data.  The business that was done in some duration – all day today, the week so far, in the last 6 months, etc.

Similar questions will need to be answered for parts of the architecture.  Say just one component, like claims in an insurance company.

  • Snapshot.  How many claims does each claims adjuster have outstanding at the moment?  What is each claims rep doing – in the office, out in the field, etc.  
  • Aggregate data.  How many claims were paid, and how many rejected in the last 15 days?   How much money was paid out and by whom yesterday?  etc.



The information described above must be available in two forms.

  • Old fashioned kind – reports, tables, graphs and charts.



The manager must be able to setup alerts, and notifications, on arbitrary events of interest.   These alerts should be available on devices, and social platforms of the manager’s choice.


User experience for an IT manager

The user experience requirements for the business manager apply to IT managers as well, with one difference.  The IT manager wants information on how the system architecture is performing.

Consider the example of the billing component described earlier.   While the business manager is interested in how the billing component as a whole is performing, the IT manager will want to keep track of how things are going with the four computer systems that run billing – the billing app, the document management system, the print manager, and the messaging system.

  • A realtime visual representation of the work running through the billing workflow.  This must include the number of and the type of various billing transactions, the documents going to the document management system, what the print queues are doing, etc.  This will show me hot spots.
  • How many of the Missouri auto policy billings were finished today?
  • How much did we pay out as agents’ commissions last month?
  • Map delinquencies by region, but I don’t want a spreadsheet.  I want it represented in shades of color on a physical map of the country.
  • And so on.


How to get there

As with any user experience problem, you have to start with accurate knowledge of the business.   In any environment, we have to know the business architecture well, in order to satisfy business managers’ requirements.

Reporting requirements for system architecture demand that each computer system in the architecture must expose snapshot, and aggregate descriptions of the work that is going through the system.

Finally, we are going to have to pick up expertise in data visualization beyond filling spreadsheets.   There seem to be many tools out there for the client, which can be supported in the backend by either the JVM, or node.js.




User experience for business employees

Business employees

Who am I referring to exactly?   After all even the IT developer who builds and maintains the enterprise system is an employee of the business.  In fact, I mean folks that are not IT employees.   I am referring to people whose primary knowledge is the business of the enterprise, and not computer related skills.

For instance, she is a certified underwriter of farm policies.  She is not expected to know SQL.  She is not expected to be able to setup CRON jobs, or put together a Lucene query, or even an advanced Google query.  She does not tune the Oracle database where her policies reside.

What does it mean for such employees to have good user experience?


User experience

Common characteristics

At the outset, the common characteristics, as described in these posts, apply to business folks too.

Besides these, there is a perspective that applies to business folks specifically, I believe.

No training

Business resources must really only need training, experience, and expertise in the business, and not in whatever enterprise-wide computer system that is in place.

For instance, an underwriter should be able to come into a new insurance company, and knowing no more than how to use a keyboard, mouse, and perhaps a touch screen interface, and without formal training, should be able to very quickly learn and be productive using the existing enterprise system.

Anything the business resource has to learn, she must be able to learn painlessly, by just using the system.

The interfaces that the business user encounters must be a clear, natural, and seamless representation of her knowledge of the business.   The system should guide the user down paths that are instantly familiar, and obviously correct.

The enterprise system must leave little room for mistakes.   Even when the mistakes happen, they must be caught early, and there must be little or no cost.  This is essential to facilitate experimentation, and self-learning.


You know that the user experience is good when the enterprise system recedes into the background.

The computer system must not register in the user’s mind as an obstacle, as a challenge, or as anything at all that is above and beyond her knowledge of the business.

Granted, regardless of how convoluted a system is, once a user learns it, the system will recede into the background.  That is almost unfortunate, because that is how a lot of clunky systems come to be.

However, say you have to make a change to the system.  Or say you want to replace the system.   How much resistance do you encounter?  If the business complains about having to learn a whole new system all over again, your user experience is suspect.

To put it another way, your system’s interfaces must not add any cognitive burden, beyond that which the business expertise itself requires.

How to get there

The fundamental business

Good solution design begins with effective business analysis.  Before diving into solutions, business analysis must first describe the essential business problem.  Volere, a Requirements and Business Analysis consultancy has a good definition of such analysis, which it calls ‘systemic thinking’.  To paraphrase Volere, you want an understanding of the essence of the business, without being prejudiced by any solutions, whether digital, or the old-fashioned kinds.

In a lot of my past work, the product of business analysis included 
someone's notion of a solution too, typically a user interface 
designed by folks with knowledge of the business, and good intentions, 
but not much else.  

Folks with the expertise (in user experience design) to translate the 
essential business rules, processes, and outcomes, into a transparent 
computer solution, never got a chance to understand the business at all.  
Result, more often than not, avoidable errors, unnecessary iterations, 
and ultimately, an interface, that was not useless, but that was less 
optimal than it had to be.

These were common refrains - "They will get used to it", "This is a 
documentation issue", "This is a training issue", etc.  All telltale signs 
of user experience that has room for improvement.

Human interaction design and construction

There are folks with the expertise to take the description of the essence of the business that systemic business analysis produces, and design a system with the characteristics described above.

Much of this expertise has been codified, as guidelines, patterns, and frameworks, which a competent generalist can learn as necessary.

Here is a list of resources that must serve as our guides.

Further, design is an iterative process, which will include the following sort of cycle.

  • The human interaction designer comes up with a design.
  • The design is implemented as some kind of prototype.
  • Users use and evaluate the prototype.
  • Tweak, enhance, start over, until everyone arrives at a satisfactory destination.

As this suggests, besides the design expertise, you have to be able to repeatedly construct, deploy, review, and change these solutions quickly.

Construction skills include the following.

  • Create plain wireframes with a tool like Balsamic.
  • Create colors and images laden, HTML, and CSS mockups with tools like Dreamweaver, and Photoshop, etc.
  • Create live prototypes with RAD frameworks like Ruby on Rails, or Django (Python), or Grails, or Play with Scala etc.  In particular, my personal interest is in the Java eco-system (Grails, Play), and a pure Javascript solution (for instance, Bootstrap.js, and BackBone.js at the client, and node.js in the backend).

You have to have the infrastructure and the skills for continuous integration, and continuous release.

Part of the review capabilities must include the ability to run usability tests.

Finally, there will be times when interfaces will have to change deep into the construction of the system.  Your engineering must be such that the interface can change quickly, without adversely affecting the backend.  You never want to say to the client – “It is too late to make that UI change.  You should told us this earlier,”.

As a generalist, what must I know regarding ‘transactions’

I believe, a generalist, or a team of generalists, must offer these skills, related to the implementation of ‘business transactions‘.

The failure of a business transaction must still leave the system in a safe, and valid state. As a ‘generalist’ I must either know how to achieve that goal, or know where to quickly find a solution.


As always, I want to be able to solve this problem in two platforms – the Java eco-ssytem, and Node.js.


Short-lived business transactions

Most of us are familiar with ACID transaction support in relational databases.  Relying on this support is only recommended for short-lived business transactions.

Database transactions are typically implemented by locking database tables for a particular user, which forces all others to wait till the locks are released. This necessarily slows the system down, among other complexities. Hence the recommendation that ACID transactions be very short-lived.

Here are some examples of short-lived business transactions.

  • Change the address of a customer. Typically you have already gathered the new address, and you simply have to update a few tables with the new data.
  • Apply a payment against a policy. Again, the whole transaction is typically an update to a few tables.

In the Java eco-system, this sort of short-lived transaction, when applied against a single database, is implemented with the JDBC API. We must be able to able that, using Java, Scala, and Groovy.

I must be able to talk to relational databases, and manage ACID transactions against a single database, using node.js.


Long-lived business transactions

However, often, there are business transactions that are long-lived, and must behave gracefully.

Here is one example of a long-lived transaction – migrating old insurance policies from one system to another.

This is historical data, often several years worth and can be voluminous. It contains many different parts, like contacts, coverages, changes made to the policy over the years, documents, etc. Accepting all of the policy into a new system can take a significant time. We used to run into policies that took 20 seconds to process completely. Things will go wrong, and when they do, you would like to cleanly rollback all of the incoming data. However, you cannot keep an ACID database transaction open for 20 second, 10, or even 5 seconds. That locks up database tables, which in turn will severely diminish your ability to handle load.

Here is another example – business workflows that extend over several days.

They are initiated, passed around to several folks, and then eventually completed. If for some reason this business process ends in some kind of rejection, or failure, you may want to discard, or perhaps archive data that this workflow created.

Consider that new accident information is received for an automobile policy. Maybe some documents are uploaded. Some premium adjustments are made. Some bills are generated. Underwriting, and billing managers review, and sign off. This process may take several days to finish. Say after doing a lot of work, you discover all this work was done on the wrong policy – perhaps an ex-husband’s. How do you roll back this work, and data that has been accumulating over several days? Surely not with a database transaction.

So how do ensure that such operations are well behaved? If necessary, how to ensure that these long-lived business transactions exhibit ACID properties?

As a ‘generalist’ I must know standard approaches, and solutions to this problem. Further, I must be able to implement these solutions in the Java eco-system, and in node.js.


Single database vs. multiple

In a large, heterogenous environment, you are often working with several databases. Perhaps all documents are in some legacy SQL Server DB, and day to day transactional data are in a fast MySQL DB.

How do you implement ACID when a business transaction, even a short-lived one, works with data that is distributed across more than one database?

In the Java world, there is the JTA API, which supports so-called ‘distributed transactions’. But very few people seem to use this. As a ‘generalist’ I must know what the alternative is.

Similarly, I must know how this problem can be handled in node.js.


Polyglot persistence

This is just a special case of the multiple database scenario. The data repository can be anything at all – relational DB, NoSQL DB, text based index, messaging end point, flat disk file, etc.

How do you implement ACID when the business transaction works with many different kinds of data repositories?

For instance, say you are recording an auto accident. Photos of the car might go into a noSQL database, like MongoDB. A description of the accident is saved to Oracle, and this information is also parsed and pushed into Lucene. Finally, a notification is dropped into a queue that a claims adjuster is watching. If this transaction dies for some reason, you want to rollback the changes you made to each of these very disparate data repositories.