How to define/classify messages and notifications in web applications

Question

I have seen content from various style guides and UX guidelines about this, and was wondering if there is a much more simple system to create a consistent and easy to implement design for various types of communication that occurs between users and systems. My initial idea is to use a Importance/Urgency matrix and assign different weightings to each combination. For example, Importance can be ranked High, Medium and Low, and Urgency can be ranked Immediate, Intermediate and Later. Has anyone seen this type of classification being used for Error, Warning, Status, Alerts and other types of messaging and notification or can provide some other approaches?

It looks like I should be looking at Impact (rather than importance) and Urgency, and use these to create priority. So are there good ways to grade or classify each of these categories? And how can these be linked to specific look & feel so they can be easily implemented by the front end developers?

Update

Looking at some of the front-end development framework these days, there has been some need to classify messages and notifications due to the CSS applied to HTML elements. An example from Foundation 5.0

And Bootstrap 3.0

To clarify the question a bit further, I am trying to look at it from the user's perspective in terms of what types of messaging that they would expect to see and what the behaviours should be like (in the context of web applications). The front-end development frameworks provide some idea about the style but doesn't make a strong link with the expected behaviour. This is something that should be independent of business rules because we are talking about a system or scheme that can be used to describe and categorize the messages and notifications consistently.

Answer 1

(I edited the answer for the sake of clarity)

Re-reading your question, it seems you are more after a way to classify messages in categories like Status, Warning and Error. To me those cannot be classified automatically, because knowledge of the business case is necessary to do so. You can maintain a matrix of classification that you will enrich over time.

I add below some information about Event Management and Incident Management, which are part of ITIL, and could be of some use for your particular case.

---

Priority is usually considered as a function of impact and urgency. Information, warning and exceptions are levels of information, generated by events.

ITIL has a matrix that describes priority depending on impact/urgency.

ITIL suggests that priority be made dependent on Impact and Urgency. Out-of-box, this is true on incident forms. Priority is generated from Urgency and Impact according to the following table:

           Urgency 1   Urgency 2   Urgency 3
Impact 1   Priority 1  Priority 2  Priority 3
Impact 2   Priority 2  Priority 3  Priority 4
Impact 3   Priority 3  Priority 4  Priority 5

(Source: http://wiki.servicenow.com/index.php?title=ITIL_Incident_Management)

I am adding more information, from the comments i've received it's not clear for everyone how you get the urgency and the impact in the first place.

What is important to note is that the classification of impact/urgency depends of your organization and business case.

Urgency categorization example

Category   Description
High (H)   The damage caused by the Incident increases rapidly.
           Work that cannot be completed by staff is highly time sensitive.
           A minor Incident can be prevented from becoming a major Incident by acting immediately.
           Several users with VIP status are affected.
Medium (M) The damage caused by the Incident increases considerably over time.
           A single user with VIP status is affected.
Low (L)    The damage caused by the Incident only marginally increases over time.
           Work that cannot be completed by staff is not time sensitive.

(Source: http://wiki.en.it-processmaps.com/index.php/Checklist_Incident_Priority)

Considering the different event types, ITIL describes 3 categories: Information, Warning, and Exception.

Informational events are typically events within normal operating boundaries. They are the types of “good” events that tend to fill most IT Service Management tools. These events are typically an indication that something has worked as it should.

Warnings are an early indicator or potential indicator of trouble. However, we need to understand that a warning is a flag to something being “unusual”, not necessarily negative (e.g. someone logs in after 6 weeks of inactivity)

Exceptions are the most typical precursor to incidents, but they will not always lead to an incident (e.g. a CPU spikes above the set threshold as a power user starts a processing job). Exception events will generally be of interest to IT Operations staff as they may be a sign of more trouble to come.

(Source: http://itsm.certification.info/event2.html)

One thing to note is that event management and incident management are linked, but not completely. You can have incidents (so impact/urgency giving you a priority) without having an event of the form information/warning/exception (for example if a user calls to say something is not working, compared to when your monitoring would throw an exception because a service is down).

Answer 2

The best messages and notifications that I have seen are written by a good copywriter at once.

What tends to happen with messages, is that they get written when they are needed, and this happens over a period of time - usually by different people. That causes a lot of inconsistency.

I would keep a list of all error messages and notifications with a short explanation of when they occur (possibly with images accompanying them). I would then give that to a good copywriter along with information on the style that you want to use. That way, even if they don't change all of the messages, they will be ensuring consistency in message urgency and style.

Simply making a matrix will not add a lot, because priority is a function of impact, urgency, and consequence. You need to rather determine for yourself whether any message is low, medium, or high priority. Anything more precise than that, will add little benefit and will likely get you focused on minutia.

Answer 3

Communicating with users is an important feature in any application on any platform, so this is something that needs to be done right or it can have detrimental effects to the UX of the entire application. Some preamble:

In the early days of the Web, content was static and hand-coded. Server-side involvement was minimal and the possibility for errors low. These days, with all the new technologies at our disposal like Ajax calls and databases, the situation is reversed: errors are frequent and to be expected, and our applications have to handle them gracefully.

(jQuery - Novice to Ninja - the authors escape me but I'll edit them in later)

Clearly, to be able to handle gracefully we need to classify. So here are some methods I've seen, along with some suggestions.

1. 4-level
   As some of the other answers here note, many desktop programs - and some web apps - have 4 levels of classification: critical, task-critical, warning, information. Personally, I think this is quite a good method: it gives you access to several different types of error message, which, when given a class and styled with some CSS, are easy enough to implement. N.B.: I talk about web apps mostly, along with the terminology, because it's what I'm used to - but the concept applies globally

2. Priority/urgency
   As with the system you describe in the question, many systems use a method of classifying by urgency. For example, a message saying that your data is all about to be destroyed is very urgent and should be shown to the user first; a notification saying that there's an unknown artist performing in Peru in two years' time is not very urgent and can be left till last. This is a good system in that it has the intelligence to decide what should be shown first and what can wait, thus making user communication more efficient. However, I'm not such a great fan of this as it lacks any real classification: it only decides on the order messages are shown and doesn't have any capability to show what is critical to the current task.

Some thoughts

I think to have a system of notifications that is both efficient and classified is the ultimate goal. Perhaps that will take a lot of refining; in fact it almost certainly will. However, I think the basis of such a system should be a mixture of both the systems described here: a sort of classified-by-criticality, time-aware system. With the components from both systems, such notifications could be delivered to the user in the order that is logical based on the order in which they should be acted upon, as well as be clear how much of the user's workflow they will interrupt.

The implementation of this in a web app would be comparatively simple: some class-based styling with CSS, along with some JS analysis of data attributes stored in the element containing the notification content, would quickly see this done. To build a more robust system, it should be backed up on the server-side, but this could still use the CSS styles already existing.

Web Notifications

A recent development in the world of web apps is the Notifications API. This allows desktop web apps to send desktop notifications to the user, which are displayed outside the app. This could perhaps help in the development of a notification system: really urgent messages could be shown in a desktop notification rather than an in-app notification.

Of course, this new API could just be used for all notifications. However, support for it is limited (at the time of writing, Chrome, Firefox > 22 and Safari), and the styling and classification would need to be done differently, as CSS has no handle on these elements. Instead, the icon option would need to be used with a number of icons, each representing a different level of criticality. However, this might mean it's not clear to the user at first glance how critical the notification is, and in some browsers (FF, Safari), notifications are automatically cancelled after 4 seconds instead of waiting for the user to cancel them.

Answer 4

How do you differentiate between Importance and Urgency ? What ever you classify as Urgent, is it not going to be equally important ?
In general web applications are built keeping this in mind. All web applications I built on java/jee platforms used some kind of logging. Now these log statements have different levels like warn, debug, error etc. The severity with which these get written to the system (files/db etc) is controlled by a controller file (For example if you want to reproduce what a user reports, a developer turns on debug statements so those can be reviewed.)
In case Fatal logs are detected in the system, the support crew is messaged with the error and its details. Which generally need attention immediately. Many firms have typical wait times before other staff is beeped about it. If a tech doesnt signal back in say 30 minutes saying he is looking into it, the messages are sent to a higher authority .. and so on. Making an application with this foresight is required.
But in case your application allows messaging amongst end users, you will have a different set of urgencys for those messages which the users can be informed about anyway (Ex P1 as subject line means very important message Or a Red exclamation mark, for ex.)

Answer 5

It sounds a bit like your goal is to get the right message to the right person at the right time. Your question seems to focus on a global idea of category and importance, which matter, but typically a given role or even individual user give more priority to a given message/alert than another.

You can use a mixture of machine learning and human curation to apply these preferences and organize the data. If you look at it from that perspective you may still end up seeing a need for error vs warning etc, but I suspect you will see less usefulness to high/medium/low importance ratings since those can really depend on the viewer more than the publisher/the global average relevance.

Depending on the size of the user space and the intended tasks, you can use a model like Stumbleupon's to pair users - so for example if User A tends to vote up questions that User B votes up, then a vote up by User B should increase the visibility of that message on User A's view. You can of course also use other metrics about messages to say, based on past usage these new messages are most relevant to User A.

Some systems like this aren't just messages but work queues (every message is itself a unit of work that must be done). These can still benefit from identifying related user priority above, but you also need to include the idea of "claiming" a task and push unclaimed tasks up in visibility. You then use user priority to determine which unclaimed tasks rise highest for who.

Answer 6

I remember from Time Management classes that you simplify this matrix further, into

    Urgent |              |
           --------------------------
Not Urgent |              |
           -------------------------- 
            Not Important | Important

As with all new concepts, the simpler the better.

Answer 7

Following on from other posters I think a matrix applied at a role or application level would be the most appropriate way to create a single system for assigning type/importance to individual messages. I think you could develop a matrix that specifies colour and icon usage for each level:

As others have mentioned these levels need to be applied at a role or application level because you cannot write a rule that applies to all users in all circumstances. But a system like this would give an easy way to apply these rules through, for example, the use of classes (e.g. <span class="major-error">). That way non-technical staff can quickly convert business requirements into technical specs and tech staff can easily build these kind of features into content management systems.