# How to define/classify messages and notifications in web applications

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.

• I like this question. It would be interesting to hear how existing systems fall short. Most systems I've seen (IDEs, OSs) have 3 or 4 priority levels/message types. For example: (1) you cannot work on anything until you acknowledge this message, (2) you cannot continue working on this task until you acknowledge this message, (3) you can continue working an acknowledge this message when convenient, (4) you won't see this message unless you go looking for it. – user1757436 Mar 23 '13 at 10:57
• This seems to be a combination of priority and message type, so what are some examples of the actual system processes that are generally associated with each of these categories? Is there a best practice or does it depend more on the application type? – Michael Lai Mar 24 '13 at 22:29
• Do you have any specific domain/users in mind for designing? For developers, you can have one set of notification system, while for the users you will have a different set of notifications for the same system. – rk. Mar 25 '13 at 21:06
• I think it is probably just for general software applications, but more for a web environment. Although I would like to think that this should be applicable/adaptable for different types of systems. I am just really after some considerations and rationale for how impact and urgency can be organized in the context of software systems. – Michael Lai Mar 25 '13 at 23:30

(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


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.


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.

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).

• Thanks for the clarification, I have updated the question based on the feedback. – Michael Lai Mar 22 '13 at 3:41
• Seems reasonable but I'll state the obvious...the more rows or columns you add to this table, the farther away from the goal of a 'much more simple system' you get. – user1757436 Mar 23 '13 at 10:53
• You're not supposed to add more rows/columns. That's as big as it gets. – Gauthier Mar 23 '13 at 11:29
• Is there some approximate way to separate all the different types of messages and notifications under this system? For example, where would a internet disconnection fall under this classification? Is it just based completely on the type of application, or is there some generally consensus/rule of thumb about what is urgent versus not urgent? – Michael Lai Mar 24 '13 at 21:35
• This matrix gives you the priority given the impact and urgency. Classifying event in the 3 categories (information, warning, exception) depends on your business case. An internet disconnection could be a warning if you have a hot backup link, or an exception if you have only one link. The urgency and the impact are again different, it depends on many things. If your internet connection is vital for your business, it will be impact 1. If you have your backup link working, the urgency may be 2. Basically 1 is ASAP or impacting everyone, 2 is later today, and 3 is some time. Hope that helps – Gauthier Mar 25 '13 at 2:08

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.

• Isn't impact related to consequence? The reason I want to be able to classify them in some way is so that I can work out the visual and interaction design for each of the types of messages so that there is consistency in the way that the user is exposed to them by the application. – Michael Lai Mar 22 '13 at 3:43

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.

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.

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.)

• I would think that urgency has something to do with time sensitivity of the response, so that if a timely action is taken it can reduce the impact of the outcome. On the other hand, I'd say that impact has to do with the number of people that the event affects. Therefore, the importance of getting a message across about an event is some weighted function of its impact and urgency. Surely when building the web applications you refer to there is some classification/tag against the event logs that you use to sort/filter them. I am interested in what those categories are and how you use them. – Michael Lai Mar 26 '13 at 21:56
• Doing something your boss explicitely asked, but which doesn't bring any value to you is urgent, but not important. Upgrading your system's licence that will expire in 3 months is important, but not urgent. It is an accepted fact that urgency and importance are not the same thing. In your example, you had to classify the messages in the first place (warn,error,fatal), and this can only be done knowing the context of the application. Classifying events is part of Event Management, that's what i describe in my answer. – Gauthier Mar 27 '13 at 1:44
• Right. But for what OP asks I think it is probably just for general software applications, but more for a web environment. What I described is the typical way such events are handled in most web applications. > I am interested in what those categories are and how you use them. You can read these two links and see if these are of any help to you : 1 and [2] (stackoverflow.com/a/1984368/1083581) – happybuddha Mar 27 '13 at 15:37
• Good points in the StackOverflow post, and other than the DEBUG type that may need some clarification in how it applies to the user, I think there are some good guidelines there to follow. – Michael Lai Jul 30 '14 at 23:16

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.

• Some very good points there. In this instance you can assume that there is a homogeneous group of users that carry out similar tasks. I am just after some type of design pattern or best practice that can be applied to a new system/application. – Michael Lai Mar 27 '13 at 3:37

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.

• Interesting point but I wonder if it just means too many messages will get into the Urgent and Important category, which would defeat the initial purpose. Conversely, there might be things that need more attention that gets missed? – Michael Lai Mar 27 '13 at 21:37
• Quite true and the same goes for would you ever create messages for things that were not urgent and not important. Then the question comes down to how you go about defining the urgency / importance, which I suspect is more important than the matrix you use. Perhaps define a certain set of criteria that make a message urgent / important. – icc97 Mar 28 '13 at 9:43

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.