I am designing an app for iOS where I need to prevent the user from unintentionally trigger an alarm (the action of calling for emergency should be easily accessible, but at the same time it should prevent any accidental initiation).

I don't want to use a confirmation dialog since it requires the user to read and looking for a button in a different position (it seems like too much friction on the other side).

To use a 'slide to' action button occurred to me initially as an good idea, similar to what was/is used to unlock an iPhone screen, but then I run into this topic: Creating a “Slide to power off” like slider on iOS, basically saying that Apple discourages usage of these kinds of components, and they refuse to publish such an app in the store.

Do you have any experience with this kind of user scenarios? Or do you have experience with Apple refusing to publish your app for such reasons?

  • This is not an answer so much as a suggestion: a lot of video game UIs contain deliberately difficult-to-perform actions, such as dragging an item from one place to another, holding down one item before another one can be tapped, etc. Consider looking there for inspiration.
    – SPavel
    Commented Nov 9, 2018 at 3:09
  • 5
    What is more valuable in your case of calling for emergency - protect system from false alarm or save user by simplifying way to make alarm? Also, does your application always active and never goes into background? If user needs to make app active he need to make some actions to achieve screen with alarm - is it not enough? Could you please clarify your use case.
    – Serg
    Commented Nov 9, 2018 at 11:50
  • The intention is to allow user easily and quickly call for help in variety of situations ( quickly - user should not have to read another instructions or confirmation dialog or look for another button, writing anything - there might not be time for it; and also should be easily accessible - user might be in rush, under stress), but not unintentionally run emergency since it's going to alarm authorities / others. Application is not always active, but making it active doesn't necessarily provides enough of friction.
    – enn
    Commented Nov 11, 2018 at 19:13

6 Answers 6


First, regarding answer that you linked, I think what Apple was having an issue with is the use of the same UI as their slide to power off, not the use of that UX/interaction. They just don't want it to be styled to resemble their power off slider as to not confuse users. If you were to create say, a small blue slider, or a slider that moves in a circle pattern I think you'd be fine.

However, if you want to play it safe, what about press to hold like this:

"press to hold"
Screen recording from MapMyRun app

In the .gif, a user is pressing the "hold to finish" button, which triggers a roughly 2 seconds "finshing" state where a user can let go and cancel the action, or after two seconds the action, in this case "finshing", triggers. There is a visual progress indicator to show the user that they are performing the action and how long until the action completes. You could also experiment with increasing the time or providing haptic or audible feedback to prevent false presses. This also meets your need of not having to read or click anywhere else.

  • 10
    A long hold seems one of the easier things to accidentally do. But +1, and for the OP I'd advise an easy two-stage action, in case a simple slide would have to be uncomfortably small to prevent accidental activation. A multi-stage confirm (swipe two directions, swipe and press, press and swipe, etc) can have more easily accessed input methods (e.g. larger input area), than a single stage action of comparable safety. Commented Nov 9, 2018 at 5:26
  • 9
    I worked for a company that made an alarm app many years ago. Our alarm button had to be pressed for exactly 1.7 seconds before the alarm went off. However, the user was told to press it for 2 seconds. Both numbers came from some well researched usability study that the owner had access to. Commented Nov 9, 2018 at 7:42
  • 4
    It might make sense to cancel the action if held for too long, if there's a risk of activation due to "pocket dialling". Commented Nov 9, 2018 at 11:03
  • 13
    For the "cancel" part (to avoid "pocket dialing"), you could make it a two-part counter: 1) "hold for two seconds" with the advancing circle indicator, and 2) "release now (continue holding to cancel)" with a receding circle indicator (~ 1 second). If the touch is not released before the circle completely recedes, the action is canceled.
    – Doktor J
    Commented Nov 9, 2018 at 16:34
  • 3
    A slider in a circle pattern seems like a great balance of being quick and easy to do and not trigger accidentally. In contrast, holding a button for a few seconds seems like an easy way to trigger accidentally while it's in my pocket, maybe while I'm grabbing it and pulling it out or when I just put it in my pocket and it ends up touching the button with a key or something.
    – JoL
    Commented Nov 10, 2018 at 18:09

To send money in my banking app, I must drag a symbol into a target. It is difficult to do accidentally, but quick to accomplish. It may be difficult for someone with limited dexterity or someone who is distracted.

enter image description here

  • +1, this is probably the most reasonable tradeoff between safety and convenience. However, I need to say that I used to accidentally unlock my phone constantly when I had “slide to unlock” active. It was so bad that I ended up setting up a PIN to unlock the phone solely for this, rather than due to security concerns. Commented Nov 12, 2018 at 12:27

I haven't thought this through, but there might be mileage in considering the physical equivalent. On many control panels, such as in power plants or aircraft, the especially dangerous actions have a switch cover that must be lifted before the button can be used.

My suggestion is a control that's normally in a "locked" state, and takes an action to unlock it (perhaps just a press of that control, perhaps a slide). When it's unlocked, it can be used; if it's not used within a reasonable time, or if some other control is used first, the cover "slides back" automatically.

Although it is functionally equivalent to having a "confirm" button or a popup-menu confirmation, the metaphor is somewhat different, and can be presented in a different visual form.

  • 11
    I like this option, but I think the "slide back" after a period of time is not necessarily the best option... If I were wanting the option to be available in an emergency I'd feel more comfortable leaving it uncovered with my finger over the button and manually covering it again. I'd hate to look away and then try to trigger it but find it had "auto covered."
    – Sam Weaver
    Commented Nov 10, 2018 at 17:10

Additional ideas from this article: https://www.smashingmagazine.com/2018/01/friction-ux-design-tool/

  1. Delaying the action and allow a window time for users to "undo"
  2. Extra step for security, such as asking for fingerprint
  3. Other types of authentication such as re asking password or 2-factor authentication.

Other articles dealing with the same topic:

  • 6
    Delaying the action and allow a window time for users to "undo" - this is by far the best advice here. Instead of adding complicated gestures you are eliminating the consequences of accidental button presses.
    – user120577
    Commented Nov 9, 2018 at 13:13

Let's Talk User Flows & Navigation:

User Flows are a series of steps a user takes to achieve a meaningful goal 1.

From The Science of Great UI by Mark Miller - When User's Navigate through a task, the path they take to accomplish it can be broken up into into individual steps for each context shift.

  • Path - Set of Steps needed to complete a task
  • Step - Effort to complete sub-task

And each step has two properties:

  • Length - Amount of Time to complete
  • Width - Amount of Difficulty to complete.

Difficulty can be broken up into:

  • Mental Difficulty - Remembering information, calculations, decisions
  • Physical Difficulty - Increases with precision
    • See Fitts' Law: the smaller the size of an area, the more time it takes to move a mouse cursor to that area.

So if you want to make navigation easier, you can do the following:

  1. Decrease # of steps - ex. Auto-fill city based on zip
  2. Widen steps (make easier) - ex. Increase button size on common actions
  3. Shorten steps (reduce time) - ex. Google's autocomplete suggestions
  4. Add Alternative Steps - ex. Find account by Email or Phone

Contrastingly, if you want to make navigation harder, you can do the opposite:

  1. Increase # of Steps - ex. "Are you sure" modal dialog
  2. Narrow Steps (make harder) - ex. Slide to unlock rather than click
  3. Lengthen Steps (increase time) - ex. Require long (timed) press rather than click

So all of those tools are within your disposal, and depending on your use case and the severity of performing the wrong action and the difficulty of restoring to the Last Known Good State, you might need any combination.

For example, if the alarm will trigger a nationwide missile alert, you might want to introduce a lot of difficulty, time, and informative content. If you just want to prevent accidental clicks from pockets, increasing the difficulty/precision is probably sufficient. If users might not be aware of the risks of setting an alarm, the introduced friction should include copy to let them know

Here's an example from GitHub that I think introduces severity well

Friction does not have to equal Frustration, so ask your users and get some good telemetry :)

Further Reading: How to Design Destructive Actions that Prevent Data Loss


I'm a fan of GitHub's approach where you have to type in a repository's name as confirmation when deleting a repository.

enter image description here

Your user could be asked to type in something like "911", which is very difficult to accidentally do. The string could be adjusted for locale and desired difficulty.

  • 1
    The question says a confirmation would be too much friction for the use case, so surely this answer wouldn't fly.
    – kasperd
    Commented Nov 12, 2018 at 15:46
  • 1
    The purpose of this github confirmation as I understand it is to ensure the user knows which repository they are deleting (since they need to read and type out its name). That's a step above simply knowing that they are deleting a repository. Having a user type in a set phrase doesn't give the same benefit, and adds too much friction when the user does want to perform the action.
    – Dave
    Commented Nov 12, 2018 at 18:44

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.