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?

  • 2
    +1 very good question, and a problem I find myself and see many others in all the time Commented Mar 12, 2012 at 11:12
  • 2
    I prefer to link people to documents rather than cluttering up mailservers with gigabytes of copied data.
    – zzzzBov
    Commented Mar 13, 2012 at 2:36

13 Answers 13


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:

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

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

  • 4
    I like the idea of having a "Send File" option.
    – ChrisF
    Commented Mar 12, 2012 at 11:06
  • 11
    +1 - I like this 'file first' approach. What is happening here is what in Human Error terminology is called a 'slip' interaction-design.org/encyclopedia/…
    – PhillipW
    Commented Mar 12, 2012 at 11:09
  • It may look strange but you should still leave the option to attach a file even though the 'Send Email' button is pressed. If the user suddenly wants to attach something, it should be possible without rewriting the email after pressing the other button... Commented Aug 20, 2014 at 11:21

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)

  • 1
    Btw, for Gmail they have something called 'Undo Send' in Labs. Commented Mar 12, 2012 at 11:24
  • 3
    'Undo Send' is my favourite feature of Gmail bar none. However it's not possible to use it with my work account.
    – fredley
    Commented Mar 12, 2012 at 11:36
  • @fredley Love it and use it as well. Labs is working for Google Apps but the Apps admin in your domain needs to enable it. Commented Mar 12, 2012 at 11:43
  • 10
    It's a nice backup option if the email does get sent without the attachment. However I'd worry that if this confirmation is always shown to them everytime an email is sent then they will cease to actually read this message each time; they're just used to it so don't visually process it each time. I'm not sure of the psychological term for this, perhaps Inattentional Blindness?
    – JonW
    Commented Mar 12, 2012 at 11:56
  • 1
    @JonW I agree some would get used to it and sort of ignore it, thus it's not the ultimate solution. On the other hand I got so many emails where the sender would send an update with attachment a minute later - this is why I assume it would help many users. Commented Mar 12, 2012 at 13:06

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.

enter image description here

  • 2
    I'm aware of this, but this relies on a keyword filter which has a fairly light touch in my experience!
    – fredley
    Commented Mar 12, 2012 at 15:47
  • 1
    javascript: 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.
    – JoJo
    Commented Mar 12, 2012 at 16:04
  • I can't think of any other way to predict whether or not an attachment was intended short of some form of text parsing--including keywords.
    – DA01
    Commented Mar 12, 2012 at 17:28
  • 2
    Ah I see. English (British is not sure about other forms) is very idiomatic, and I cannot see how you can trap everything. You will have generate a 'send attachment' list, like a swearword list. If you wish to trap them, that way. Good luck Commented Mar 12, 2012 at 17:33
  • 1
    -1. OP already mentioned that this happens in his e-mail client. He's looking for a solution that will help him when it write stuff like "Here you go.".
    – kba
    Commented Mar 13, 2012 at 0:40

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.

  • 4
    +1 for learning specific user patterns, rather than applying a blanket pattern for all users. Commented Mar 12, 2012 at 19:52
  • 1
    +1 - this may not be the easiest way to accomplish the objective, but it's definitely the coolest. Commented Mar 13, 2012 at 5:11

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.

  • +1 Lotus notes does this too and i rarely forget attachments. It is the only good thing about LN though, but that's a separate issue :)
    – Isak Savo
    Commented Mar 15, 2012 at 19:49

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.

  • Good idea to start with, but then the important thing is tracking of how any false positives and true negatives happened, and estabilishing a process of regularly going over failed cases and improving detection. Commented Mar 12, 2012 at 11:36
  • Ideally the logic updates would not be manual, but rather designed into the system at the start. This is not, however, an easy task to accomplish.
    – Dan
    Commented May 12, 2016 at 13:15

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.

  • 1
    I'm not following, how's this solution reminding the user to include attachments? Commented Mar 12, 2012 at 14:12
  • true its not actively reminding them but how often do you click send and realise as you do it you've forgot to attach your document. Gives you chance to amend the email before it goes.
    – JTotham
    Commented Mar 12, 2012 at 14:21
  • 1
    maybe that's true in some cases. But from my experience the mishap is always brought to light by the receiver of the email having to answer with that the attachment is missing. Commented Mar 12, 2012 at 14:59
  • 1
    Unless the user knows they have a two-minute 'undo' window, then this solution likely wouldn't help much. And I'd argue that, at times, the two minute delay could be just annoying. Sometimes I need to send an email NOW.
    – DA01
    Commented Mar 12, 2012 at 17:30
  • 1
    @DA01: what circumstances would require an "instant" e-mail? Serious question, no derision intended. Personally I can't think of any circumstance which would be important enough that a 2-minute delay would be detrimental. Circumstances that require instant action are generally served better by audible/visible alarms (ie fire - fire siren) than by mails. Circumstances that do not require instant action, generally don't get worse as a result of a 2 minute delay? Commented Mar 12, 2012 at 21:47

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.

  • first the user is asked to select the attachment (which is the most significant step for them since they are a e-signature company and the document is needed for the signature process)

enter image description here

  • Then the email address to which the document has to be sent

enter image description here

  • Then the Email message and content if applicable

enter image description here

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.

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.