Having seen a number of examples over the years I've been wondering where this kind of interfaces stand today.

What I mean by "automatic UI" is the following.

Normally on screens, dialogues and web pages you have some input controls where you need to enter data then you press a command button "Go", "Search", "Filter" or whatever. If these are the settings, then the buttons say "Save" or "Apply". An important part here is that you always have a way to cancel the intended action by closing the window, the dialog, the page or by clicking the "Cancel" button.

With automatic interfaces there are no such action buttons. Things happen on their own as soon as you stopped entering the data in the input controls or remove the input focus from a control. Examples are many:

  • Google instant search where it filters the results as soon as you stopped typing, you don't have to click "Search" explicitly

  • Settings dialogues in the Safari Browser. As soon as you change anything it is immediately saved. The dialogues have no explicit "Save" or "Apply" buttons.

  • Lately the search on Stack Overflow careers. Search is triggered as soon as you remove the focus from any input control where you've introduced a change.

Now the question is, what is the industry opinion on this kind if interfaces?

  • Are they considered modern and "cool" so users want them everywhere?

  • Are they known to improve usability? Any studies on the matter?

  • Do they have any technical advantage behind the scenes?

  • Or is this simply a different way to do things and is nothing but a matter of taste?

My personal experiences with these interfaces are twofold. Sometimes it does simplify the interaction like Google's instant search so I see them as a positive thing. On the other side of the fence, the dialogues save and apply things immediately so if you click or change something wrongfully it will have consequences which are sometimes difficult to clean up, especially if you didn't notice you clicked somewhere (like the focus was in some list and you wheeled your mouse). In that case these interfaces raise the feeling of insecurity.

So I'm interested in your opinion on the thing. Any "official" statements from companies on this sort of things. Any usability case studies. Anything to explain why people are doing such interfaces and how they perform.

UPDATE: I've just come to realize what I don't like in these instant interfaces. It's psychological, it is the feeling of lack of control. With explicit buttons, things happen when I say. Without them, things happen when the software decides and I feel like a passive and helpless observer.

  • Reminds me a bit of this experiment...
    – Benjol
    Commented Apr 28, 2011 at 10:10
  • @Benjol: Whatever this is it doesn't work with me.
    – user4986
    Commented Apr 28, 2011 at 10:22
  • See Is Google Instant Good or Bad UX? Commented Apr 28, 2011 at 12:40
  • Pretty much all settings in OS X are saved like this (with a few exceptions).
    – Phil
    Commented May 2, 2011 at 21:55

5 Answers 5


I think you're mixing two distinct things to define "automatic". Yes there is some thing that happens "automatically", but what is it?

  1. If you take Google instant search (which by the way is optional), then you start typing in information and you are presented the best results as you go on. This feature guides you, it provides options. It provides you real time feedback about how useful your search query is to the system.

  2. If you take Safari's Settings (which from your description is a non-optional behaviour), then you make some input and the input is immediately applied. This features takes control of how your input should be handled. This is somewhat like a text editor, that directly saves any input you make (assuming there's no history, you're screwed). Or like a web content editor, that directly publishes your input to the server as you write it (this would turn stackexchange "threads" into fierce chat battles :D). Or like a spell checker that automatically inserts its best guess (which can go REALLY wrong).

So the first approach contextually provides options to you, while the second unconditionally makes decisions for you.
To rephrase that: The first one is helpful, the second one is not only annoying, but potentially harmful.

At their core, the difference between the two actions is that between queries and commands. Queries are side effect free. So there's little possibility to screw things up with "automatic" queries, but "automatic" commands are almost certain to cause unwanted behaviour (unless you execute them in a "parallel space", i.e. a preview for the settings made rather than direct application, or a backup of the current document state, rather than direct saving).

  • This is quite interesting. These are two different things indeed.
    – Developer Art
    Commented Apr 28, 2011 at 10:03
  • 2
    "Or like a spell checker that automatically inserts its best guess" - Thats pretty much what my iPhone does. And yes, it goes REALLY wrong pretty often Commented Apr 28, 2011 at 11:41
  • I personally like "automatic" preferences because these are fluent. I much more often get annoyed by Windows settings not being applied. And it's not much harder to screw things up by pressing "Apply" button with wrong value entered. However, other examples involving text editor and web content editor are quite reasonable.
    – tonytony
    Commented Feb 9, 2015 at 8:41

These kind of interfaces are definitely cool. Because you save time. Because removing lets say a search button saves you the time clicking it.

On the other hand they might not be considered as cool by users because it's new. And new always needs to be learned. And people might not like learning.

Jef Raskin focussed on these matters in his "The Humane Interface". He also measured time that actions like a click or hit of a key requires. So he removed everything he considered not necessary. Even the second letter of his first name.

Some examples from this book (let me know if I mixed up something - read it a couple of years ago):

  • A computer that doesn't have an on/off switch. The computer goes into sleep mode and turns on on any action like a hit key. Even the hit key won't be wasted. If there's a word processor running the hit key will be written.
  • Instant results in search fields. At the time he wrote the book it was not possible to implement the feature due to slow computers. Nowadays you find that in iTunes or Google Instant.
  • No save and load. You just go back in the history of the document via a timeline. Requires everything to be saved automatically.
  • No useless metaphors like an application or Icons because they are abstract. He proposes that the zoomlevel let the user dive directly into the content. You can edit immediately without opening an application for that. This would also save the choice what kind of application you should use. He invented the interface used e. g. in Google Maps by that.
  • He insisted on good labeling of buttons. E. g. "Do you want to save?" -> ok/cancel is abstract and require to read first what the actions of the buttons would be. He said the buttons should tell what they do: Save/Don't Save. Would save additional time.
  • 1
    You can't become a millionaire by saving a penny every day. This shaving off of milliseconds has no impact on the UX or on productivity. It's like counting clicks, it should be done only when you repeat the same small steps dozens of times in a row, not when you turn on your computer. Also, when I bring my computer out of sleep, I just hit the keyboard blindly with my fingers - if these strokes meant something, I'd have to delete these letters in the best case, or it may cause serious damage in the worst. Why would I consciously remember the exact state the pc was in when it went to sleep? Commented Apr 28, 2011 at 13:46
  • I have to disagree. For example a suite like Microsoft Office. It's full of time consuming misleading features (do they still have a floppy disk symbol for "save"?). If a big company with 100k worker would save 10 minutes a day per worker that would be arount 16k hours per day. Consider 10$/hour/worker that would be 166k $ saved a day. That's 43 million $ a year. And saving 10 minutes won't be that hard within an Office Product.
    – erikrojo
    Commented Apr 28, 2011 at 13:52
  • 1
    I agree on everything except the last phrase. Try to come up with an improvement in MS Office that would be so effective that it saves 10 minutes a day (which is a lot) for 50K workers, at the same time being so decidedly clear that it doesn't confuse the other 50K workers into spending an extra 20 minutes a day on it. Commented Apr 28, 2011 at 14:05
  • Maybe it's a guess of mine. And I haven't measured it. But when I'm working with Keynote I'm getting things done fast. Switching over to Powerpoint slows me down. But thats totally subjective right now. For example when I'm reading the documentation I never find the mentioned feature in Office. In Keynote I don't even need a documentation. I'd love to make a direct comparison if there would be enough time.
    – erikrojo
    Commented Apr 28, 2011 at 14:12

The first kind (explicit Apply button) actually has the technical advantage. It allows for low-bandwidth connections, becuase the UI need only contact the backend processing code when the Apply button is hit. This was a big advantage in the old days. For instance, in mainframe programming, a mainframe might serve a thousand users concurrently, and it would not be able to keep up with every edit.

This convention was brought over to PCs, which (being Personal computers) didn't have the problem to satrt with. It became again relevant in the web age, where webservers might now serve tens of thousands of (remote) users, but even there bandwidth has caught up.

Obviously, any interface that penalizes common mistakes (such as typo's) is plain wrong. But in general, that's an argument against the Apply button. That's just a way to make your mistakes permanent. And without an Apply button, you can't click it accidentily.

  • "And without an Apply button, you can't click it accidentily" - I'm not sure I understand you. Without an Aplly button every click intentional or incidental is immediately enacted. Where the Apply button is available, you can pretty much click anything around without any consequences.
    – user4986
    Commented Apr 28, 2011 at 13:18
  • That's the entire point; a sane design without Apply button will always offer a chance to go back, precisely because of those accidental clicks. A design with an Apply button allows you to revert your edits only until you click Apply.
    – MSalters
    Commented Apr 28, 2011 at 14:35
  • "Interaction that is delimited by entering an entire line of text, that is, text delimited by a Return, at a time is a holdover from the days of Teletype and should be relegated to a museum alongside the hardware of that time." - Jef Raskin in The Humane Interface Commented Apr 28, 2011 at 18:02

These predictive actions are good for advanced users, and they may be harmful to beginners, who really need the feeling of control. In case this sounds counterintuitive: advanced users need the actual control, while beginners need the feeling of control, so that they feel like they're getting the hang of it.

When a button is being pressed for them, advanced users will notice it and may (or may not) appreciate the shortcut. But beginners may not even be aware that it was pressed, and will look for a way to carry out the setting that they've defined. An advanced user of google instant search will notice the results changing as he types, and a beginner will finish typing (he is probably looking at the keyboard and not at the screen in any case), and will search for a button to initiate the search.

Look at bit.ly. If you're not signed in, you need to finish typing the original url on their homepage and then press "shorten", which gives you the short url. But if you're signed in, then once you finish typing the url in the textbox, it automatically shortens it within that same textbox. This is because the fact that you're signed in implies that you're probably not a casual or first-time user, and you'll know what happened.

In short, I think it should be treated as an advanced function / shortcut - good for experts, not so good for novices.


You asked at least four questions here. I'm just taking one of them:

  • Do they have any technical advantage behind the scenes?

Yes. They go with a style of programming that uses computer resources in a less 'bursty' way. For example, using a compiler that waits till you command it to compile you have a sudden demand spike in processing. If instead you are compiling in the background, as the user types, the computer resources are used much more evenly. The same compute resources seem more powerful.

One point about Google instant is that the early results may not actually arrive. If early in your query you hit an index that can't be served from RAM, the instant search suffers, but by the time you complete your query, or even just type a few more letters, it IS in RAM. Having a preview of what you are typing gave Google a head start on answering your complete query.

I would include collaborative editing in Google docs as part of the trend you are seeing. The small updates as users type are less bursty than the bigger updates when someone submits an updated page to Wikipedia. This has knock on effects from peak network traffic, to memory cache sizes, to the cost of rebalancing load. The net effect is that you can host more users on the same hardware - without it feeling unresponsive.

A second technical benefit of sites that do things as you type is analytics. They get more information, and are better able to improve their service. They see backspaces and pauses, fast and slow typing, that you don't see if you only capture on commit.


Your Answer

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