Are you sure you want to answer this question?

Question

We've all seen these types of warnings: "Are you sure you want to shut down Windows?"

I hear a lot of people frustratingly reply: "Yes, of course, otherwise I wouldn't have clicked it!"

---

These types of warning messages can be very annoying, but it can also save you from data loss.

In modern Windows versions, Microsoft has removed this warning message. But in many software and on many websites, we still see these types of warnings:

• "Do you want to save your work?"
• "Do you want to close all tabs?" (which some browsers ask, while some browsers don't).

The utilitaristic way to solve this dilemma would be to say:

"many people click a button deliberately and just a few people click a button by accident, so the warning message should be removed." (which I hear a lot). But is this the right way of thinking?

So the question is:

Are there any studies or heuristics on when and where to use a warning message and how can we prevent using them (if that's preferred)? Also I'm curious to read your opinion!

---

The Answer

At the moment, steveverrill's answer about a "don't show this message again" check box is the most easy and safe solution.

In some cases (maybe in the future when computers are more advanced), auto save and/or restore buttons could be a better solution. Check those other well thought out answers too!

Answer 1

Yes. There is a very simple, effective heuristic that adjusts to the preference of each user.

Place a check box in the warning message dialog that says:

Don't show this message again

Which can be improved further by stating where that dialog can be reenabled.

Answer 2

These are Confirmation messages - Windows have a fairly detailed page on their guidelines. The whole of that page is pretty useful but here's some excerpts (emphasis mine):

Confirmations are most useful when the action requires the user to make a relevant and distinct choice that can't be made later. That choice often involves some element of risk that isn't obvious to the user, but risk isn't essential to confirmations. These elements are necessary to justify the interruption of responding to a modal dialog.

(No further emphasis from me for the below):

Is this the right user interface?

To decide, consider these questions:

• Is the user being asked a question to proceed with an action that has two or more responses? If not, the message isn't a confirmation.
• Is the UI presenting an error or problem that has occurred? If so, use an error message instead.
• Does proceeding with the action require the user to make a choice that doesn't have a suitable default? If so, a confirmation may be appropriate.
• Is there an alternative design that eliminates the need for the confirmation? The need for a confirmation sometimes indicates a design flaw. Often there is a better design alternative that doesn't need a confirmation.
• Is the user about to perform a risky action? If so, a confirmation is appropriate if the action has significant consequences or cannot be easily undone.
• Is the user about to abandon a task? If so, don't confirm. Assume users understand the consequences of not completing a task.
• Does the action have consequences that users might not be aware of? If so, a confirmation may be appropriate.
• Given the current context, are users likely to be performing an action in error? If so, a confirmation may be appropriate.
• Do users perform the action frequently? If so, consider an alternative design. Frequent confirmations are annoying and have little value because users learn to respond without thinking.
• Does the action have security implications? If so, a confirmation may be required even if the previous tests indicate otherwise.

...

Consider the design alternatives

Here are some design alternatives that eliminate the need for routine confirmations:

• Prevent errors. Design tasks so that significant mistakes are difficult to do accidentally. For example, physically separate destructive commands from other commands, and require multiple actions to complete.
• Provide undo. Provide the ability to revert actions. For example, deleting a file in Microsoft Windows usually doesn't require a confirmation because deleted files can be recovered from the Recycle Bin. Note that if an action is very easy to perform, just having users redo the action may be sufficient.
• Provide feedback. Make undesirable outcomes obvious. Providing undo alone isn't sufficient if users don't realize when they make a mistake. For example, the effect of direct manipulation (such as a drag-and-drop operation) should always be obvious.
• Assume the probable outcome, but make it easy to change. If you aren't sure what users want but there is a likely, safe, and secure choice, assume that choice, make it clear what happened, and make it easy to change using a context menu. For example, Microsoft Word assumes that users want to spell words correctly. If it recognizes a misspelled word and it knows the likely correct spelling, Word automatically makes the correction but allows users to revert.
• Eliminate the choice completely. If the choice isn't important, users just won't care. Better to simplify your program and eliminate the choice.

Edit:

Further than this, which I think is also worth mentioning from a separate page on UI principles taken from various books talks about novice users:

10. The principle of safety

...

Novice users need to be assured that they will be protected from their own lack of skill. A program with no safety net will make this type of user feel uncomfortable or frustrated to the point that they may cease using the program. The "Are you sure?" dialog box and multi-level undo features are vital for this type of user.

Apple Guidelines don't seem to have any guidelines on when, just "don't over use":

When it’s possible that users are unaware that their action might have negative consequences, it can be appropriate to phrase the alert message as a question. For example, a question such as “Are you sure you want to clear history?” pinpoints the action users took and prompts them to consider the results. However, don’t overuse this type of alert; users tire quickly of being asked if they’re sure they want to do something.

Google material design suggests that you should only use them for high risk situations and use a clear question rather than 'are you sure?' (that is obviously what you should write, rather than when):

Alerts with title bars

Use title bar alerts only for high-risk situations, such as the potential loss of connectivity. Users should be able to understand the choices based on the title and button text alone.

If a title is required:

• Use a clear question or statement with an explanation in the content area, such as "Erase USB storage?".
• Avoid apologies, ambiguity, or questions, such as “Warning!” or “Are you sure?”

Answer 3

I'm surprised nobody brought up the Mac OS X shut down dialog. It presents you with an "Are you sure?" window, but has a timer so that if the user walks away, expecting the computer to have shut down, it will while still allowing the user time to cancel.

Answer 4

There are 3 cases.

The destructive action

Do you want to delete this file?

Don't. Just do the action, and display a confirmation snackbar (non-blocking small widget somewhere where it is visible but not in the way of operating) that allows to cancel (then, either delay the action, or make sure you can revert it easily).

The question can only be answered by the user. e.g.

Do you want to allow this application to access whatever?

First time, show a popup. If you use the "Don't ask me again", make sure it is super-easy to change their mind. Google suggests a snackbar to unobtrusively allow the user to change that setting afterward.

The committing action

Shutdown the computer? Send this email? Publish this article?

Depends on you capability to cancel the action. Several options are available. In order of preference:

1. Delay the action to give the user time to cancel.
2. Make sure you can undo whatever has been done. (e.g. restarting a software quickly and restoring the previous state)
3. Ask for confirmation. Try to avoid doing that. It is annoying most of the time, and seldom useful.

Answer 5

I'm a big proponent of not showing messages blocking users from doing what they intended to do. The UX solution with confirmation popups came from the Stone Age of computer UX practices. It originates from a correct assumption that if we have a critical resource, we should not let users damage it by an accident. However, an accident is called that way because it happens rarely. This means in the majority of cases that confirmation is just a waste of a click.

However, we do have to protect users from accidents. So the right way of doing this is to save current state in undo stack, proceed with the operation, but then let user cancel or undo it. I would consider this solution more like a guideline, rather than a rule, but I'm sure it can be applied to many cases.

For instance, in case of shutdown Apple saves current state for all your applications. When you power up again you come back to your work as if you haven't shut it down.

If an operation may destroy irreversibly a critical resource (for instance, delete something in 3d party application via API) then schedule the action to start in nearest future, say in 60 seconds, but let user cancel it, if they like.

That said, I think in majority of the cases these kinds of confirmations are not needed.