Preferable way of calling user attention on a desktop application

Question

I have a desktop application, where users write orders (among other things). It's a MDI-like application (tabbed interface really), and each order is written in its own tab/window.

There are several rules that might issue warnings when a user is saving an order, but should still allow the saving of that order (just give attention and allow to correct or even give an option to correct automatically if possible).

There are many of these rules, so the possibility of one such warning appearing is quite common.

For example:

• An order is for an address for which you "usually" don't use "that" shipping company. Still, the shipping company can be used to ship to that address, and it's indeed used in some very specific scenarios.
• An order has several detail lines and a shipping company specified, but there's no weight specified. Weight might be added later (so the order needs to be allowed to be saved in an "incorrect" state), but there should be an attention call to the user (giving the option to autofill it with the sum of the product weights)
• A non-shipped order is coming from eBay (for example), and is not marked as paid. This should usually not happen (since most orders coming from eBay are paid up-front), but it could happen under some circumstances, so it should be allowed. Most of the time this will be a mistake, so the user needs to get called to attention, but still allow the order to be saved (or been given the option of autocorrect it before saving).

(etc.)

The way I've done it is retrieving the list of warnings and use a message-box-like dialog (actually a TaskDialog but never mind that) and show a single modal popup in case there's actually any warning when saving.

The problem is that these warnings are common (I'd say they happen in one out of every 10 orders) and the user(s) doing those orders tend to click "save anyway" sometimes without reading all the warnings in the window.

The most problematic part of it is when they are actually expecting one of those warnings (so they know the popup will show when saving) but there could be others that they were not aware of.

Do you have any recommendations on a better way to handle this?

Please don't use the rules I gave to answer: those are just examples (actually, the third one is unlikely to happen since orders coming from eBay are filled automatically and by default they show as paid, but I used it as an example of a possible warning) and "correcting those rules" is totally out of the question: let's imagine those are needed and well-thougth (they may be not, but that would be a different business-model question, not a UX one).

Update

As discussed in the comments of the answer by @DanielZahra (which raises valid points), there's one assumption here: the users of this precise application will make mistakes, and are generally pretty busy (so just filling a message queue with the warnings won't work, since they'll probably not look at it -think of our generally filled mail inboxes-).

What has actually worked in the past was issuing the warnings each on its own popup (so if there were three warnings, it'd show three messageboxes one after another unless you cancelled the "save" operation), but I highly dislike this. My current way of doing it is getting all warnings and showing them in a single popup, but that's not working and there are more mistakes now than when I was using many popups.

Mistakes in an order can end up costing money (think of point one in my list... generally the main reason not to use "that" shipping company to "that" address is because in that case, the shipping company might be much more expensive on some conditions than another one), so, if I have to choose between "allowing mistakes to be made" or "disrupting the flow", I'd definitely choose the latter.

I'm trying to find a balance: I understand human errors will be impossible to avoid (since they could be infinite), but I want to keep them to a minimum while not having users (very) frustrated with the usage of the application.

After banging my head against sketches on notebooks trying to, I haven't been able to find any solution, and since I'm the only developer of this application and I have no collegaes with whom to share my thoughts or brainstorm with, I'm using UX to try to come up with a better solution.

Answer 1

Looking at the field research done on security warnings (e.g. Krol et al. 14 or Porter Felt 14), you can see a common theme shaping up with warnings that get in the way of productivity (which seems to be what you're worried about): users unavoidably get habituated to those warnings, but you can efficiently prevent them from ignoring too many warnings by reducing the number of said warnings they're exposed to.

If you really want to force your users to digest all those warnings, you'll unavoidably need them to perform tedious efforts. Porter Felt's data showed users processing malware warnings in ~2 seconds in naturalistic settings. Some lab research in the same field experimented with other forms of warnings and ended up needing about two whole minutes of interaction to have an important impact on click-through rate. You don't want to be the guy doing this to your users, because they'll hate you and be frustrated.

Now that you're convinced you need to reduce the number of warnings, go through each warning and decide if:

• there is an outcome that is clearly more desirable and more frequently correct than the other (e.g. for the "unpaid" orders, staging the order until payment or manual clearing is most likely desirable), see 1)
• there might be a more frequent outcome, but the infrequent one is not undesirable (e.g. genuine changes/updates of address for a regular customer), see 2)
• you have no clue, issue a warning

1) Clearly preferable outcome

Enforce the most desirable outcome and notify the user more passively about this enforcement, or take them back to the change you made in the form and let them re-submit with your change immediately; if they cancel your change, don't re-enforce it (they maybe really meant for the order to be unpaid, e.g. it's shipped as a gift from sales to a begrudged regular). In short, enforce a decision but offer a mean for the user to circumvent it in situation.

2) Infrequent but neutral outcome

You can draw attention to the user whilst editing, use some custom logic to discriminate between changes and typos (e.g. if the address is super similar, there might be some form of typo made by the person who setup the order rather than an actual change), and have a contingency plan if the somewhat-different-than-usual outcome was indeed an error (e.g. how often will you ship to the wrong address if you let all "different-than-usual" addresses slip through, how much will that cost you and how quickly can you rectify the order for your customer?). Generally speaking, risk analysis applies here.

In any case, log how your users currently deal with the warnings, and look back at whether they made the right decision, or whether no right decision can be inferred. If you need to reduce the number of warnings, the first step is to understand why they occur and what's to be done in the situations where they occur.

If without data or with your limited UX skills, you reach the conclusion that all existing warnings are legitimate, it might be time to hire a usability expert and have them work with your staff to come up with cheaper interaction methods / less error-prone processes.

Answer 2

I would start at looking how to make the popups look different at a glance. This can be done with shape, position, colour coding etc.

I would however like to point out that if your are issuing a lot of popups/modals, that in itself is a usability issue. Have you considered using a notification que or inbox. Being too intrusive with your application is what is likely causing your users to 'get rid' of popups quickly.