I often dash off emails to people and still I forget attachments. I am using an email client which does keyword sniffing, e.g. if I type 'attachment' or similar it will pop up a warning, but more often than not this fails to trigger because the email body is something like "Here you go" or something.
I can't help thinking there must be a UX solution this. How can I design an email compose screen that prevents users sending attachment-less emails?
One way may be to allow a file-first Email creation process. If you often send files + some text, rather than text + rarely files, you may want to allow users to start a new Email in different ways:
Drag + drop a file into the application window opens a new Email to which it is attached, waiting for just a description and To: address.
Provide (Send Email) and (Send File) buttons to create a new Email. The technology behind this is the same generic Email functionality, although (Send File) would require a file to be attached.
This is about making the application understand the intent more explicitly than keywords would allow. At te same time the users uses a different thought process for file-first emails and would be less likely to make the mistake you describe.
You may also try and extend the range of keywords to include 'Here you go' etc - but this approach has a lot of problems, such as language/translation, and that it's just a very fuzzy area.
You may also want to think about a mechanism allowing people to still edit the Email after pressing Send, for example to add the attachment. You could make this work in the application by not actually sending the Email for 60 Seconds, giving the user time to fix their mistake. (This should be obvious in the interface). 'Undo send' in Gmail works simlar to that.
I also think that keyword analysis will help but can fail in some cases. The following is meant as a backup and is based on the assumption that quite a number of users seem to notice immediately after sending the email that they forgot to attach something (based on email I receive).
Probably a small change could make a difference? - user composes email and hits "send" when finished - technically delay sending for something b/w 15-60 seconds - show a confirmation message including a link 'Wait, I forgot the attachment!' - clicking the link will stop sending (as it was delayed anyway) and bring the user back to composing screen - just in case the user has this question in mind display a note on top of the composing screen saying something like 'Message has not been sent'
download bmml source – Wireframes created with Balsamiq Mockups
(nice copywriting tbd)
GMail does this already with similar wording as above. I have written attached in the email, but have not attached the file. This has been a feature for about 3 years I think.
if (/attach/i.test(emailBody)) {var answer = confirm("you forgot to attach a file"); if (answer) {sendEmail();}}. You'll have to define emailBody and sendEmail() yourself.
This might be a lot more programming work than UX work, but you could probably implement something similar to a Bayesian spam filter, only instead of the two categories being "spam" and "not spam", the categories would be "email with attachment" and "email without attachment". This would actually be easier than filtering spam, because spammers are actively trying to evade the filters, while your users are probably not trying to forget attachments. You could train the filter with the user's archive of sent messages (assuming they use Gmail or any other email service that archives sent mail), split into those messages with attachments and those without. (You probably want to detect cases where a message with an attachment is a direct reply to one without, since that would indicate that the first message was supposed to have an attachment.) As the user continues to send mail, your filter will get better and better. And unlike the keyword-based approach, each message would have a numeric score instead of just a boolean yes or no answer, and based on this score you could have several "levels" of reminders. At a low score, you could just have the attachment button glow a little or something, and at a higher score when you're pretty sure the user wants an attachment, the attachment button can start flashing and you can give them the "Did you forget?" dialog box when they click the send button (and maybe change the appearance of the send button to indicate an "Attach and send" action. Later, if feedback from your users indicates that the attachment warnings are too intrusive, rather than kill the feature entirely, you can just make the thresholds more stringent to get the right balance.
In your particular example, if you frequently send messages with a body text of "here you go" without an attachment, and then immediately send a reply with an attachment to the same person before they've even replied to you, then the attachment filter would learn to associate that phrase with a high likelihood of needing an attachment, even though no single word in that phrase indicates a need for an attachment.
On the Mac OS X Mail program, attachments appear inline with your text instead of at the end of the document. This means you get to write things like this:
download bmml source – Wireframes created with Balsamiq Mockups
Since you reference the attachment right inline with your text, it's pretty obvious if it's missing or not. I never forget an attachment when authoring mail with Mac OS X's mail program because of this.
You got good solutions of design interface, but this could also be solved on the artificial intelligence road, which is probably what gmail does.
If you want to go down the Natural Language Processing road, you can try to adapt applications designed to classify spam (like spamassassin and others) to classify messages that probably would have files attached based on the text.
Those applications usually employ a very simple model (naïve Bayes classifiers, bag-of-words models, etc...) to analyze the text and decide if it belongs to a given class. The classifier is trained with examples, so if you have a base of e-mails which are already correctly classified in a "files attached"/"no files attached" you can train one of those classifiers already abundantly available around. This can also be improved locally for each user, as the classifier learns what wording each particular user probably employs when there are files attached.
This is probably what gmail does. They have one clear advantage: gazillions of e-mails to serve as examples to train the model. This approach would only work if you have enough examples to train the classifier.
The problem here is identifying key words or phrases that indicate that there is likely to be an attachment. You need to divine the user's intent from what they've typed as the e-mail title and body - no easy task. What you don't want to do is have an extra step that ask the user if they've remembered the attachment for every single e-mail they send.
The obvious trigger words are "attached" and "attachment" but you can, and should go further. Thunderbird prompts if you include the word "CV" for example. Other words could be things like "video" (as in "Here's that video"), "photo", etc. Adding a training system that analysed e-mails sent with and without an attachment would be useful here. It could record the occurrence of the words in the e-mail and correlating them to whether there was an attachment or not would help.
If your example "Here you go" doesn't really have any distinguishing words but it is a distinguishing phrase when it's the only text in the e-mail. Therefore you could design a system that looked for phrases when that phrase is the only text in the body of the e-mail or makes up 80% of the text.
However, such a system won't be foolproof. There will be false positives ("Here you go again, spouting off", "I saw a great video at the weekend", etc.) and false negatives. You could improve the system by recording how many times the "Have you forgotten the attachment?" message was dismissed without adding an attachment to reduce the number of false positives. Reducing the false negatives is somewhat harder, but you could record whether the e-mail was resent (check the title and/or body against the last sent message?) with an attachment.
One way i have seen this done in and 'outlook' + 'exchange' environment was to create a rule that applies to all outbound items and reschedules the email to be sent in 2mins time.
This gives users 2 mins to go to their outbox and delete the email or start working on it again before it actually goes anywhere.
Possibly you could work this idea into your client.
If you often sent messages with attachments and very little text, a subtle solution would be to accentuate the attachment related elements when a message has very little text. You could of course turn it back to normal after an attachment was added. It doesn't interrupt the user from sending a message, but it sure draws your attention to attachments.
You could also use the keyword search to search the message subject/body for 'attachment', 'file', for hints to highlight the attachment button as well as the message length.
download bmml source – Wireframes created with Balsamiq Mockups
Create a drop-down send button that includes two rows, "Add Attachment", and "Send Email". (Also keep the separate "Add Attachment" button.) When the user goes to send, they must click the button to drop down the menu, and then click again to send, like a safety switch. Since "Add Attachment" is right there, they will be reminded as well.
This is 2x the clicks however. Maybe make this the default and have an option to turn it off and keep "Send" as one click button.
I myself set Outlook Express to a delayed send of every 10 minutes, in case I forgot something.
This is a problem which can be best solved by improving the client's data about the behavior of its user(s). In my case, I primarily send emails with attachments to people I know. That'll usually be email addresses that have previously been used and they'll often be stored in my address book.
Some people more commonly send attached files to people they don't know, haven't emailed, and may never email again. For example, someone who's unemployed might send lots of resumes.
I'm a very novice programmer, so I'm sure this isn't the most elegant solution... but I'd begin tracking every email which went out with an attachment and start looking for patterns. If every email to [email protected] contains an attachment and then I try to send one without an attachment, it'd make sense to ask me if that was intentional. If 95% of my emails to [email protected] don't have an attachment but every email on Friday at 5pm has one, it'd make sense to ask me on Friday at 5pm and not otherwise.
I don't know of an email client which has this functionality or even a plugin that does it. However, I haven't spent much time searching... it'd be worth looking around to see whether one already exists.
I don't think the compose screen is typically the main culprit, though... I think it's more that it's easier to remember things that you do routinely. Unless the majority of the emails you send include attachments, your routine is to quickly hit send or a keyboard shortcut. Visually emphasizing the method to send an attachment would be annoying for most users because more emails are sent without attachments than with attachments.
You could subtly change the display based on whether you expect the user to send or not send an attachment. However, the advantage of asking them directly "Did you mean to send an attachment?" is that it provides more information that can be used to improve future guesses.
Though I personally think Google does a good job at this ,their analysis is based upon the detection of the word "attached" and hence if the user decides to use another word or phrase his sentence differently,this method fails.
A company which I had interned for (Docusign) during my graduate studies does this in a pretty interesting way in which it does the entire mailing process step by step i.e.
In your case,since you are trying to design a email system where attachments may or may not need to be sent,you could flip the order by asking the user to add attachments at the last stage.I personally like user12999 solution of providing a feature of adding an attachment after the email has been sent within a time frame but I am not sure if your proposed email system will support that feature of calling back emails.
Well, what about putting a notification with the number of attached files below the email body, followed by the "attach" button, and then followed by the "send" button? That way is impossible to miss!
I think all the problem comes from bad possitioning of the elements:
If there is a top bar, the "attach" button should be the FIRST thing a user sees, and the "send" button the LAST one. If there is a bottom bar, there should be a notification of the number of files attached, and the "attach" and "send" buttons should be CLOSE and to the RIGHT of the bar.
I think all the problem comes from lazy positioning of the elements on the user interface. Usually there is no close relation between the "attach" and "send" buttons, they are visually disconnected, so the natural flow to write emails with attachments (attach->write->send or write->attach->send) gets broken because actions and elements do not follow a visual progression, they are scattered all over the UI and you have to wander over the form to compose the email correctly (... and then, wander one more time to check if everything is in place before sending it).
I think you just have to support the two natural flows (attach->write->send and write->attach->send) to avoid the problem.
