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