Do People Still Love Helvetica?

August 21st, 2018 No comments
helvetica

Do people still use Helvetica? Today, we will see what designers say about the notorious font. Are you curious to find out how many hate it and how many love it? So am I. Let’s find out!

Approximately 1000 years ago, the Chineseman Bi Sheng invented the mobile letter. An organic and geometric work that has revolutionized the writing in the western world. Five hundred years later, Johannes Gutenberd invented the typographic press using Bi Sheng’s idea of mobile letters.

helvetica

Back then, the letters were poured into matrixes and assembled in shapes, and after they were used, they were given separate boxes so that they can be reused any time. From that moment, the families of fonts started making their way into the world and they have been evolving ever since. So did the typographic techniques which, in 1880, have evolved into the automatic printing.

From the beginning of the 15th century to the present, thousands and thousands of fonts families have been designed. Some are called classic fonts, and their shape looks very much like the calligraphic hand writing. Other fonts are modern, with more abstract shapes and less organic, such as the one presented below.

Helvetica was created as a completion of an older one called Akzidenz Grotesk, which was created in 1896. It was initially named Neue Haas Grotesk, and it received the name Helvetica in 1960. Its name comes from the Latin name of Switzerland, Helvetia, and it is also known by the name of Swiss 721 BT. Its first rivals in the world are Times New Roman, Baskerville, Gill Sans, and Verdana. Arial is also a variation of Helvetica. Linotype, the company that owns Helvetica has released an improved version of the font in 1983, Neue Helvetica. The font is very legible and it can be purchased on many websites for about $40.

helvetica

The psychologists say that the first messages transmitted using Helvetica are: you won’t lose your plane; you’ll make it in time at the destination; your money is safe if you use our services; we won’t open the package; everything will be ok. That’s why, notorious companies such as Orange, American Airlines, Royal Bank of Scotland, Panasonic, Zanussi, Lufthansa, or Toyota, use this font when displaying their names. It never gets old.

Helvetica turned 50 years in 2017 since its creation in 1957 by Max Miedinger and Eduard Hoffman, from the Haas Type Foundry Institute in Muenchenstein, Switzerland. It is the most used font in the world in all areas of work, being called the font of the twentieth century.

helvetica

“It’s durable. Helvetica comes from natural design forms. The font doesn’t have an expression of fashion. It has very clear lines and characters, it looks like a very serious typeface,” says Frank Wildenberg, managing director of Linotype, the German firm that owns the font.

There are versions of the font for different alphabets: Latin, Cyrillic, Jewish or Greek. It is part of the “sans-serifs” fonts. Its lines are clean, equall, and has a faded geometrical shape that doesn’t “scream” for attention.

Mixed Feelings about Helvetica

Helvetica is so appreciated that some people decided to dedicate it books. Lars Muller is one of the most dedicated to the font. He published a book called “Helvetica: Homage to a Typeface.” Moreover, he donated a set of the first inscriptions of the font to the Modern Art Museum in New York. Muller believes that the font has a “modern attitude” that comes as a response to the aesthetical premises from the 50’s-60’s. Helvetica is a font used by both the big corporations, and the small make-up shops or fast food chains. “It’s like the butter on bread,” believes Muller.

helvetica

Adrian Frutiger believes “Helvetica is the jeans, and Univers the dinner jacket. The font is here to stay.”

Wim Crouwel: “Helvetica was a real step from the 19th-century typeface… We were impressed by that because it was more neutral, and neutralism was a word that we loved. It should be neutral. It shouldn’t have a meaning in itself. The meaning is in the content of the text and not in the typeface.”

Massimo Vignelli: “You can say, “I love you,” in Helvetica. And you can say it with Helvetica Extra Light if you want to be really fancy. Or you can say it with the Extra Bold if it’s really intensive and passionate, you know, and it might work.”

helvetica

Not everybody loves this font, though. There are people who condemn the domination of Helvetica, and they see it as an old-fashioned font that encourages normality and routine.

Erik Spiekermann: “Most people who use Helvetica, use it because it’s ubiquitous. It’s like going to McDonald’s instead of thinking about food. Because it’s there, it’s on every street corner, so let’s eat crap because it’s on the corner.”

Menar Irvin: “Pshhh, Helvetica was so 2006. ITC Avant Garde Gothic Pro with the new ligatures & unicase glyphs are what’s hot.”

Jack Earl: “Helvetica: typography’s equivalent to internet explorer.”

Read More at Do People Still Love Helvetica?

Categories: Designing, Others Tags:

ABeamer: a frame-by-frame animation framework

August 21st, 2018 No comments

In a recent post, Zach Saucier demonstrated the awesome things that the DOM allows us to do, thanks to the element. Taking a snapshot of an element and manipulating it to create an exploding animation is pretty slick and a perfect example of how far complex animations have come in the last few years.

ABeamer is a new animation ecosystem that takes advantage of these new concepts. At the core of the ecosystem is the web browser animation library. But, it’s not just another animation engine. ABeamer is designed to build frame-by-frame animations in the web browser and use a render server to generate a PNG file sequence, which can ultimately be used to create an animated GIF or imported into a video editor.

First, a little about what ABeamer can do

A key feature is its ability to hook into remote sources. This allows us to build an animation by using the web browser and “beam” it to the cloud to be remotely rendered—hence the name “ABeamer.”

ABeamer doesn’t only distinguish itself from other animation frameworks by its capacity to render elements in a file sequence, but it also includes a rich and extensible toolset that is still growing, avoiding the need to constantly rewrite common animations.


ABeamer’s frame-by-frame design allows it to create overlays without dropping frames. (Demo)

The purpose isn’t to be another Velocity or similar real-time web browser animation library, but to use the web technologies that have become mainstream and allow us to create pure animations, image overlays and video edits from the browser.

I have plans to create an interface for ABeamer that acts as an animation editor. This will abstract the need to write code, making the technology accessible to folks at places like ad networks and e-commerce companies who might want to provide their customers a simple tool to build rich, animated content instead of static images for ad placements. It can create titles, filter effects, transitions, and ultimately build videos directly from image slideshows without having to install any software.

In other words, taking advantage of all these effects and features will require no coding skills whatsoever, which opens this up to new use cases and a wider audience.


Create animated GIFs like this out of images. (Demo)

But if JavaScript is used, what about security? ABeamer has two modes of server rendering: one for trusted environments such as company intranets that renders the HTML/CSS/JavaScript as it was built by sending the files; and another for untrusted environments such as cloud render servers that renders teleported stories by sending them by AJAX along with the assets. Teleportation sanitizes the content both on the client side and the server side. The JavaScript that is used during interpolation process is not allowed, nor is any plug-in that isn’t on an authorization list. ABeamer supports expressions, which are safe, teleportable, and in many cases, it can replace the need of JavaScript code.


Example of an advertisement made with ABeamer (Demo)

The last key feature is decoupling. ABeamer doesn’t operate directly with the document DOM, but instead uses adapters as a middleman, allowing us to animate SVG, canvas, WebGL, or any other virtual element.


Several examples of the chart animations built into ABeamer. (Demo)

Getting started with ABeamer

Now that we’ve covered a lot of ground for what ABeamer is capable of doing, let’s dive into what it takes to get up and running with it.

Installation

The ABeamer animation library can be downloaded or cloned on GitHub, but in order to generate animated GIFs, movies, or simplify the process of getting started, you’ll want to install it with npm:

# 1. install nodejs: https://www.nodejs.org

# 2. install abeamer
$ npm install -g abeamer

# 2. learn how to configure puppeteer to use chrome instead of chromium
$ abeamer check

# 3. install a render server (requires chrome web browser) 
$ npm install -g puppeteer

# 4. install imagemagick: https://www.imagemagick.org

# 5. install ffmpeg: https://www.ffmpeg.org/

Puppeteer is installed separately, since other server renders are also supported, like PhantomJS. Still, Puppeteer running on Chrome will produce the best results.

Spinning up a new project

The best way to get started it’s to use the ABeamer CLI to create a new project:

abeamer create my-project --width 640 --height 480

This will create a project with the following files:

  • abeamer.ini – Change this file to modify the frame dimensions and recompile main.scss. This file will be used by the server render and main.scss.
$abeamer-width: 640;
$abeamer-height: 480;
  • css/main.scss – CSS can also be used instead of SCSS, but it requires to change the dimensions in two places.
@import "./../abeamer.ini";

body,
html,
.abeamer-story,
.abeamer-scene {
  width: $abeamer-width + px;
  height: $abeamer-height + px;
}

#hello {
  position: absolute;
  color: red;
  left: 50px;
  top: 40px;
}

ABeamer content is defined inside a story, much like a theater play. Each story can have multiple scenes.

  • index.html – This is inside a scene where the animation happens:
<div class="abeamer-story" id=story>
  <div class="abeamer-scene" id=scene1>
    <div id=hello>Hello
      <span id=world>World</span>
    </div>
  </div>
</div>
$(window).on("load", () => {
  const story: ABeamer.Story = ABeamer.createStory(/*FPS:*/25);
  const scene1 = story.scenes[0];
  scene1.addAnimations([{
    selector: '#hello',
    duration: '2s',
    props: [{
      // pixel property animation.
      // uses CSS property `left` to determine the start value.
      prop: 'left',
      // this is the end value. it must be numeric.
      value: 100,
    },
    {
      // formatted numerical property animation.
      prop: 'transform',
      valueFormat: 'rotate(%fdeg)',
      // this is the start value,
      // it must be always defined for the property `transform`.
      valueStart: 10,
      // this is the end value. it must be numeric.
      value: 100,
    }],
  }, {
    selector: '#world',
    duration: '2s',
    props: [{
      // textual property animation.
      prop: 'text',
      valueText: ['World', 'Mars', 'Jupiter'],
    }],
  }]);
  story.render(story.bestPlaySpeed());
});

Live Demo

You may notice some differences between ABeamer and other web animation libraries:

  • ABeamer uses load instead of a ready event. This is due the fact that the app was designed to generate frame files, and unlike real-time animation, it requires all assets to be loaded before the process begins.
  • It sets FPS. Every state change in the CSS or DOM will fall into a specific frame. Think of it the way movie editors operate on a frame-by-frame basis. This way, when it renders to a file sequence, it guarantees that each file will represent a frame and that it is independent from the time it takes to render.
  • addAnimations doesn’t trigger an animation like other web animation libraries. Instead it builds the animation pipeline for each frame. This method is more verbose than other libraries but it benefits from allowing the same infrastructure to animate CSS/DOM elements, SVG, canvas and WebGL.
  • addAnimations can also animate text, colors and images — not only position, but rotation and scale as well.
  • render will start the rendering process. In case there is client rendering, it will simulate run-time. But if it’s server rendering, ABeamer will render at full-speed.

To test this animation, go ahead and open the index.html in your web browser.

Server Rendering

Now that we have an animation project created, we want to generate PNG file sequences, animated GIFs, and movies without frame drops. The process couldn’t be more simpler:

# 1. generate PNG file sequence
# assuming that you are in the parent directory
$ abeamer render my-project

# 2. generate animated gif (requires the PNG file sequence)
$ abeamer gif my-project

# 3. generate movie (requires the PNG file sequence)
$ abeamer movie my-project

The previous commands will place the resulting files in the project/story-frames.

Handling CORS

In the previous example, the project didn’t require loading any JSON, so it can be executed as a local file. But due CORS, if it required to load a JSON, it needs a live server.

To solve this, ABeamer has included a live server. Spin it up with this:

# 1. runs a live server on port 9000
$ abeamer serve

This will assign your project to: http://localhost:9000/my-project/

The render command then becomes:

$ abeamer render my-project --url http://localhost:9000/my-project/

Cloud Rendering

At the moment, there is no third-party cloud rendering. But as the project gains traction, I’m hoping that cloud companies see the potential and provide it as a service in the same manner as Google provides computation of Big Data that server farms can use as cloud render servers.

The benefits of cloud rendering would be huge:

  • It wouldn’t require any software installation on the client machine. Instead, it can all be done on the web browser. While there is currently no ABeamer UI, online code editors can be used, like CodePen.
  • Heavy render processes could be designed in a client machine and then sent to be rendered in the cloud.
  • Hybrid apps would be able to use ABeamer to build animations and then send them to the cloud to generate movies or animated GIFs on demand.

That said, cloud rendering is more restrictive than the server render since it doesn’t send the files, but rather a sanitized version of the story:

  • Interactive JavaScript code isn’t allowed, so case expressions are required
  • All animations are sanitized.
  • The animation can only use plugins that are allowed by the cloud server provider.

Setting up a cloud render server

If you are working in an environment where installing software locally isn’t allowed, or you have multiple users building animations, then it might be worth setting your own cloud render server.

Due to CORS, an animation must either be in a remote URL or have a live server in order to be sent to the cloud server.

The process of preparing, sending, and rebuilding on remote server side it is called teleportation. Animations requires changes to be teleported:

$(window).on("load", () => {
  const story: ABeamer.Story = ABeamer.createStory(/*FPS:*/25, { toTeleport: true });
  // the rest of the animation code
  // ....

  const storyToTeleport = story.getStoryToTeleportAsConfig();
  
  // render is no longer needed
  // story.render(story.bestPlaySpeed());
});

By setting toTeleport=true, ABeamer starts recording every animation in a way that it can be sent to the server. The storyToTeleport method will hold an object containing the animations, CSS, HTML and metadata. You need to send this by AJAX along with the required assets to the cloud.

On the server side, a web server will receive the data and the assets and it will execute ABeamer to generate the resulting files.

To prepare the server:

  • Create a simple project named remote-server using the command abeamer create remote-server.
  • Download the latest remote server code, extract the files, and override them with the ones existing in remote-server.
  • Save the received object from AJAX as remote-server/story.json and save all assets in the project.
  • Start a live server as you normally would using the abeamer serve command.
  • Render the teleported story:
abeamer render 
--url http://localhost:9000/remote-server/ 
--allowed-plugins remote-server/.allowed-plugins.json 
--inject-page remote-server/index.html 
--config remote-server/story.json

This will generate the PNG file sequence of the teleported story. For GIFs and movies you can run the same commands as before:

$ abeamer gif remote-server
$ abeamer movie remote-server

For more details, here’s the full documentation for the ABeamer teleporter.

Happy animating!

Hopefully this post gives you a good understanding of ABeamer, what it can do, and how to use it. The ability to use new animation techniques and render the results as images opens up a lot of possibilities, from commercial uses to making your own GIF generator and lots of things in between.

If you have any questions at all or have trouble setting up, leave a comment. In the meantime, enjoy exploring! I’d love to see how you put ABeamer to use.

The post ABeamer: a frame-by-frame animation framework appeared first on CSS-Tricks.

Categories: Designing, Others Tags:

“Old Guard”

August 21st, 2018 No comments

Someone asked Chris Ferdinandi what his biggest challenge is as a web developer:

… the thing I struggle the most with right now is determining when something new is going to change the way our industry works for the better, and when it’s just a fad that will fade away in a year or three.

I try to avoid jumping from fad to fad, but I also don’t want to be that old guy who misses out on something that’s an important leap forward for us.

He goes on explain a situation where, as a young buck developer, he was very progressive and even turned down a job where they weren’t hip to responsive design. But now worries that might happen to him:

I’ll never forget that moment, though. Because it was obvious to me that there was an old guard of developers who didn’t get it and couldn’t see the big shift that was coming in our industry.

Now that I’m part of the older guard, and I’ve been doing this a while, I’m always afraid that will happen to me.

I feel that.

I try to lean as new-fancy-progressive as I can to kinda compensate for old-guard-syndrome. I have over a decade of experience building websites professionally, which isn’t going to evaporate (although some people feel otherwise). I’m hoping those things balance me out.

Direct Link to ArticlePermalink

The post “Old Guard” appeared first on CSS-Tricks.

Categories: Designing, Others Tags:

Introducing YOOtheme Pro – The New Theme and Page Builder for WordPress

August 21st, 2018 No comments
YOOtheme Pro

YOOtheme Pro

YOOtheme Pro, a powerful theme and page builder developed by YOOtheme, creates a new experience of building websites in WordPress. It shows designers an easy and exciting way to design and create websites thanks to the combination of premium layouts and an intuitive page builder, and it is also a great tool for developers due to its extendability and clean, semantic code. YOOtheme has been known as a leading theme provider since 2007, but with YOOtheme Pro they created the next page builder to be watched for in the WordPress world.

The Page Builder

YOOtheme Pro is a great choice for users who are already familiar with WordPress since it is seamlessly integrated into the native WordPress customizer. Divide your content into sections, rows and grids and create your layout with these building blocks. Using drag and drop you can design stunning responsive page layouts without having to write a line of code. Everything you change will be instantly shown in live preview.

YOOtheme Pro

Build Your Content Easily

YOOtheme Pro comes with a growing library that currently contains more than 30 content elements. You can of course expect common elements like the Heading, Video, Image or Panel. But there are also some advanced ones, for instance, the Slideshow, Slider, Gallery that includes the masonry effect and the filter option, and much more. All elements are built with the popular front-end framework UIkit, which provides a modern codebase with fast and lightweight JavaScript. You can even bring the functionality of WordPress widgets to YOOtheme Pro and place them anywhere in your layout.

YOOtheme Pro

Create Sophisticated Layouts in No Time

YOOtheme put a lot of effort into the development of their layouts. A team of professional designers regularly creates complete website concepts with a thought-out content structure and focus on modern design trends. Over 100 premium layouts with free-to-use images can be found in the Layout Library. You can filter layouts according to topics and purposes, mix and match them, save your own layouts and reuse them later. This gives you unlimited possibilities and makes creating websites in WordPress as simple as it gets.

YOOtheme Pro

Choose From Over 70 Beautiful Styles

Another feature that makes YOOtheme Pro stand out is their Style Library. Choose one of over 70 handcrafted styles, and the look of your whole website will change in one click. From minimalistic and classic to extravagant and bold – this substantial collection represents all style trends. With YOOtheme Pro you can customize next to anything. You can not only change the style of each item separately, but also apply changes globally. YOOtheme Pro gives you all the power to style your WordPress website with none of the coding.

YOOtheme Pro

Integrated Unsplash Library

YOOtheme Pro seamlessly integrates the popular Unsplash library that provides quality, free-to-use photos. Instead of downloading dozens of images and trying them out on your website, you can search through the library without having to leave YOOtheme Pro. Filter images, browse through collections and users and directly insert images into your layouts. This will really speed-up your design process and save you a lot of time.

YOOtheme Pro

Lightning-fast and Developer-friendly

YOOtheme Pro is fast, lightweight and easy like no other page builder – a true piece of German engineering. It is powered by Vue.js and UIkit to provide a great user experience. YOOtheme Pro really cares about speed. The small code size together with the latest web technologies will get the first meaningful paint quickly on the screen. And with lazy loading images, auto-generated srcsets and next-gen image formats like WebP, YOOtheme Pro will boost the Google PageSpeed rank for your WordPress website. Even Google Fonts are stored locally, which saves the request to Google and makes them GDPR compliant. Even Google Fonts are stored locally, which saves the request to Google and makes them GDPR compliant.

Thanks to the modular and extendable architecture YOOtheme Pro is extremely developer-friendly. You can override everything and add custom elements, CSS, JavaScript and even new theme settings. An extensive documentation including a Developers section and video tutorials will help you get started.

Get YOOtheme Pro

YOOtheme Pro simplifies and at the same time empowers website building. With the regular release of theme packages, including beautifully crafted layouts on a particular topic, six style variations and free hand-picked photos, YOOtheme Pro is the only thing you’ll need to create a website. And while we could talk more about how YOOtheme Pro supports WooCommerce, has many desktop and mobile header layouts and a Footer Builder, we would rather let you see for yourself. So get YOOtheme Pro and experience the future of website building today.

Read More at Introducing YOOtheme Pro – The New Theme and Page Builder for WordPress

Categories: Designing, Others Tags:

Onboarding Users Of Your Product: From Trial To Payment

August 21st, 2018 No comments

Onboarding Users Of Your Product: From Trial To Payment

Onboarding Users Of Your Product: From Trial To Payment

Joe Leech

2018-08-21T14:20:21+02:002018-08-21T13:33:03+00:00

(This is a sponsored article.) In part one of this series, we looked at the Attraction phase of the customer lifecycle. This three-part series outlines the three phases of the product lifecycle, the future for UX, and the skills and approach you’ll need to design modern digital products.

  • Part 1: Attraction
    Going out there to get users to evaluate your product.
  • Part 2: Activation
    Signing up, onboarding users, asking for payment.
  • Part 3: Retention
    Encouraging users to come back and keep using and paying for your product.

Part Two: Activation

Plotting Out The Journey

When we talk about the Attraction phase, we’re talking about users discovering they have a need, discovering our product and visiting our website to see if our product meets their needs.

Within the lifecycle, we can split the larger three phases into smaller phases to help us plan our approach. In this case, we can use Philip Kotler’s model (expanded to 6 steps by Bryony Thomas).

  • Awareness
    Realizing they have a need.
  • Interest
    Looking for something to help with that need.
  • Evaluation
    Looking at products that help with their need.
  • Trial
    Trying the product to see if it meets their need.
  • Adoption
    Choosing a product and using it for a while.
  • Loyalty
    Deciding to stay using the product or switch to a different one.

(Large preview)

We’re interested in the middle two parts that fall under the Acquisition phase.

In part one, we looked at the Evaluation phase. The user is now ready to sign up and get going with our product; we used the example of the money management app:


Homepage showing what our app does.

Homepage showing what our app does. (Large preview)

Let’s take that app forward into the Acquisition phase of the lifecycle.

A. Trial/Onboarding

In the Trial phase, our user is going to sign up and see if it is the product for them.

The first challenge is to onboard the user. Onboarding is a real challenge as it can be complex, involving the user entering personal information as well as getting to grips with what the product does. There is a huge potential for users to drop out and leave.

Joshua Porter sums it up:

“Onboarding should not be a separate function/consideration/afterthought. It should be an initial (and primary) focus of design.”

Joshua Porter

So with that in mind, let’s take a look at onboarding.

Onboarding: Steady Progress Showing Value

For our money management app to work well we need for our user we need to accomplish three goals:

  1. Collect some personal data from our users.
    Who they are (including email, mobile phone number, etc.).
  2. Bank account access, to auto pull in transactions.
    As we’re in the EU, open banking regulations mean that all banks have to provide API access to transaction data.
  3. Familiarize them with the product.

That’s a big ask. Let’s think about how we can soften that. We need a simple hook to get started. We use a concept in psychology called ‘incremental commitment.’ We ask for a low commitment to the product and then when the user gets something in return was ask for more.

We ask the simple question, “How much do you think you spend on coffee a month?”


A simple question to get started

A simple question to get started. (Large preview)

This can be done along with a hook to encourage people to compare their spend to others. There’s now a quick, easy win for the user.

We give something back, in this case comparing to the average. Then, we ask the next question.


incremental commitment in action. We ask a follow-up.

Incremental commitment in action. We ask a follow-up. (Large preview)

It allows us to build trust, and for the user to get value from our product early.

Next, the big ask. We want bank account access. If we’d asked for this early, we’d see a larger dropout. But we now have built some trust, and our user is invested in the product.


(Large preview)

We then go for the big ask, granting bank access. As you can see, we are gently guiding our user through the onboarding, showing useful content at each step, trying to make it feel natural.

Asking for what could be challenging data like the mobile phone number is much easier if we offer context and say what benefit there is to the user. We could include the following on the sign-up page asking for the mobile number.


showing how giving us your mobile number adds value

Showing how giving us your mobile number adds value. (Large preview)

We can then ask further questions, like email and for a password which will have less impact being asked later after we’ve shown value.

Interaction by interaction we’re asking a question, gathering some data and showing how the product works.

Things To Avoid During Onboarding

There are other pitfalls to designing a product onboarding flow.

  • Avoid the term registration, Registration is a meaningless concept, offer a reason for why you are asking for a pieces of information.
  • Similarly don’t ask too many questions, that might sound obvious, but the more you ask the more likely it is for users to drop out.
  • Answer these three simple questions when it comes to form fields:
    • Why are you asking the question?
    • What will you use the data for?
    • What value does the user get from giving us this data?
  • Avoid Captcha; it is a big cause of dropouts as captchas can harm conversion rates. Plus, they aren’t very friendly.
  • And, of course, if your users are located in the EU, you need to wrangle with GDPR.

B. Adoption

Onboarding doesn’t end when the user has signed up. This is a common mistake made by organizations big and small. “Great, our new registrations are up month on month. But our retention rate is really poor” is a common problem.

We need to support our users through the first few weeks and months of using our app. We need to give them a reason to come back to us.

In part one, we talked about SEO and Marketing skills and tools we can use to improve the experience.

We’ll be expanding our skill set to look at email, and how we can improve the email experience. To encourage product adoption, we need to understand and map the email user journey.

Any modern UX or product designer needs to know how to design multi-channel experiences, and after the product itself email is the most important.

Planning And Encouraging The Second Visit

For our money management app we have access to the users’ bank transaction data. Rather than hoping they return to our app, we need to reach out and give them a reason to come back.

The pull: using email to get users to come back to our app

Let’s look at an email we can send them the next day. But before we do that, let’s look back at one question we asked users:


Notice that the ‘on coffee’ can be changed for other spending items. (Large preview)

The user could have changed ‘on coffee’ to be ‘at Restaurants’ or ‘at Amazon’ or another discretionary purchase option.

This is a tiny piece of personalization, and the best follow-up emails are personalized.

When designing an email the most important element is the subject line. A good subject line encourages the user to open it.

Let’s look at the most common email provider of them all, Gmail. Like we did in part one when designing Facebook ads, we’ll design in context, in this case the crowded inbox. Actually, the promotions inbox on Gmail.


There’s one email in there that stands out, yes it’s us! (Large preview)

By referencing the Frotos we identified in part one (Frotos: are the current bad state the user has and their wish for a new state. The From and the To, Froto) we should get a better open rate.

And yes, that is an emoji you see. Two in fact. ?

This article is great at helping you decide if emojis are right for you: Emojis in email subject lines: smiley face, or smiley poop? as it has a lot of data.

TLDR, emojis can help boost open rates, and well…

What an emoji (in a subject line) does is one of two things:

  1. It makes a bad subject line worse;
  2. Or it makes a good subject line better.

We also need to think about other email design considerations:

Don’t forget to test your emails to make sure they look as designed — Litmus is great at this.

User Research And Email

It’s a good idea to user research your emails, you’ll be surprised at what useful ideas you’ll get back. Using the emails as prompt material will encourage users to answer the question “What could you offer me that would make me come back to the app?”

Drip, Drip, Drip That Email

That’s email one done, great job! But now we need to think about an ongoing programme of emails. It takes a while to form a habit, and that’s what we’re after. Getting our users to keep coming back. It can take from 18 to 254 days so we need to keep sending those emails.

These emails should offer value to our users. The key insights our product offers should be easy to deliver by email, SMS, or indeed any digital channel.

Our product promises a “Personalised Savings Plan” that’s what we need to deliver.

The best performing products work seamlessly across digital channels.

To encourage product adoption and to help our user save we could offer SMS messages.


(Large preview)

SMS is a neglected message format. Yes, it can be annoying if done badly, but it can equally be effective for our users.

Some SMS stats:

  • 98% of text messages are read within 2 minutes;
  • Open rates are around 99% for text messages compared to 20% for email;
  • Click through rates are around 30% for SMS and less than 5% for email.

That makes a compelling case for the effectiveness of SMS. Look at the success of startup Shine and learn more about how they use SMS.

We can encourage our user to save money by using SMS, sending an email once a day. A daily, personalized, money coach is a huge benefit to our user.


(Large preview)

This article is a great for planning your messaging approach: Level-Up Email Campaigns With Customer Journey Mapping — Smashing Magazine.

Here’s some more great advice on planning email drip programmes:

User Research And Email/SMS

Researching the effectiveness of email and SMS is best done through AB testing. Testing different variants to see which performs better.

User research can help understand what content users will find useful and by what channel.

The Secret To Onboarding And Adoption: It Takes Time

Onboarding should be done gently, in short chunks offering value immediately. When it comes to asking for precious information like mobile phone number, bank account or email we need to demonstrate how we will deliver value.

To get a user to adopt our service takes time. We need to be able to deliver useful content over a long period of time to encourage them to keep using the product.

Next Up, Retention

In the first part we talked about the beginnings of the customer journey how to attract or users.

Coming up next, we’ll talk about how to retain users and get them to pay for our product — that holy grail of our user taking out a monthly subscription. Stay tuned!


The parts of the user journey

The parts of the user journey. (Large preview)

This article is part of the UX design series sponsored by Adobe. Adobe XD tool is made for a fast and fluid UX design process, as it lets you go from idea to prototype faster. Design, prototype, and share — all in one app. You can check out more inspiring projects created with Adobe XD on Behance, and also sign up for the Adobe experience design newsletter to stay updated and informed on the latest trends and insights for UX/UI design.

(ra, yk, il)
Categories: Others Tags:

Introducing Crello Animation Maker

August 21st, 2018 No comments
Formats_Crello

Crello is an innovative design app from Depositphotos that’s simple to pick up and use, and outputs high-quality results. In an increasingly saturated design tool market, it could be the best tool you’ve never tried.

Now, after the popularity of Crello, Depositphotos are releasing Crello Animation Maker. A brand new set of features that enable anyone to convert design assets into engaging animation for the web, in just a few clicks.

Introducing Crello Animation Maker

Crello Animation Maker is designed to enable anyone to quickly and easily convert Crello designs into animated assets for use on social media, or in adverts.

It’s an incredible tool for marketing teams, who can take existing designs and create new campaigns in minutes, without having to pull the design team away from other tasks. Animation Maker gives you the tools to respond to the fast-paced world of social media, and maybe even take your brand viral.

Create animated posts for social media.

With Animation Maker you can easily add animated emojis, icons; combine video backgrounds with photos; even add illustrations to designs.

Crello Animation Maker gives you the option to output your designs in various formats, so you can export in the right format for Facebook, Instagram, and others. You can create 3 sizes of video: 1080×1080 for social media posts, full HD video clips, and Facebook cover videos.

Create Facebook cover videos.

Quickstart with Crello Animation Maker

Crello comes with over 12,000 professionally designed templates, which gives you a great starting point for any design. Once you’ve selected your template you can customize it to your heart’s content, or use it as-is as the basis of your Animation Maker design.

There are even dedicated Animated Maker templates you can use to kick-start your process. With templates, animated icons, illustrations, backgrounds and badges, all created by professional designers, it’s easy to get pro results.

Enhance_Crello

Crello Assets

Crello comes with a cornucopia of assets to grace your designs. The huge library of over 65,000,000 images and illustrations, and over 250 free fonts, means you’ll always find the right visuals to communicate your message.

The templates are split over 33 different formats, from posters, to fliers, to social media banners. Lacking inspiration? There are even themed collections to get you started.

Crello comes with millions of assets to use in your designs.

Who Should Try Crello?

Crello is designed to offer just as much help as necessary to get results. Beginners will find that they’re easily able to generate the kind of quality designs that usually require years of experience, and industry-tested pros will find everything they need to make life simple.

Perhaps the best use-case for Crello is in the vibrant startup scene; Crello enables teams to create all kinds of visual assets, without diverting the team’s graphic designer from key tasks like branding, and UI design. Professional developers will also appreciate Crello for those occasional jobs that previously had to be outsourced.

Crello is free to use, and all of the new premium motion features are free to try. If you decide that you want to keep on using the animation and video features you can upgrade to a pro account for just $9.99 per month.

Head over to Crello today, to try this incredible design tool for yourself.

[– This is a sponsored post on behalf of Crello –]

Add Realistic Chalk and Sketch Lettering Effects with Sketch’it – only $5!

Source

Categories: Designing, Others Tags:

Get to Know Knoed Creative(AOTW#9)

August 20th, 2018 No comments
knoed

In this week’s installment of Agency of the Week, we’re going to take a look at an amazing and one of a kind agency called Knoed Creative.

knoed Creative

About Knoed Creative

Based in Chicago and owned by Kim Knoll and Kyle Eertmoed, Knoed is a brand building agency with one thing on their mind – helping people build their brand and share things they’re passionate about.

“There’s nothing more exciting to us than working with go-getters to turn their vision into something tangible, putting it out into the world and watching others experience it. We may start out with handshakes, but our projects always end with hugs and high fives.”

knoed Creative

Branding

The folks at Knoed love their high fives and hugs, but they also love building brands as their specialty.

“Branding is our specialty. There’s nothing more exciting to us than conceiving a brand from a blank slate, or wiping that slate clean and starting fresh. Whether you’re new to this or have gone through it before, you’ll find that our branding process is designed to eliminate the guesswork and provide clarity and confidence as your brand evolves.”

Knoed is no stranger to building quality. As many brands as they’ve built, they’ve built top of the line websites to go along with them. They involve the client in every step of the process and make sure that the final product fits the exact needs of each individual.

knoed Creative

Projects

When you browse their website, it’s easy to notice exactly how passionate they are about their work and the people they work with. Every detail seems to be thought about, gone over, and executed perfectly. Reading through all their ideas and thoughts on each individual project is inspiring to say the least. Let’s take a look at one of their projects:

knoed Creative

Of course, this is just the logo. Knoed helped bring Scorched Earth Brewing Company to life. Under their work tab on the main site, you’ll read some of the main focuses of this particular project. For Knoed, it wasn’t just about creating another face in the brewing industry, it was about helping the company stay true to their roots and stand out wildly.

“Paying respect to their roots, old world brewing techniques and farmhouse style beers, we designed their brand to feel rugged, utilitarian, honest and hardworking like the good Midwesterners they are.”

knoed Creative

The amount of passion and dedication Knoed puts behind their work is astonishing. Thanks to them, Scorched Earth Brewing Company has an entire identity based on what they’re truly all about. It’s not just another face in the crowd, it’s Scorched Earth Brewing Company!

It’s not every day you find an agency that puts everything they have behind their ideas, and they are definitely some talented people. If you like their work or just want to get to know a little bit more about them, follow the links to their main page and give them a shout!

Read More at Get to Know Knoed Creative(AOTW#9)

Categories: Designing, Others Tags:

What I learned by building my own VS Code extension

August 20th, 2018 No comments

VS Code is slowly closing the gap between a text editor and an interactive development environment (IDE). At the core of this extremely versatile and flexible tool lies a wonderful API that provides an extensible plugin model that is relatively easy for JavaScript developers to build on. With my first extension, VS Code All Autocomplete, reaching 25K downloads, I wanted to share what I learned from the development and maintenance of it with all of you.

Trivia! Visual Studio Code does not share any lineage with the Visual Studio IDE. Microsoft used the VS brand for their enterprise audience which has led to a lot of confusion. The application is just Code in the command line and does not work at all like Visual Studio. It takes more inspiration from TextMate and Sublime Text than Visual Studio. It shares the snippet format of TextMate (Mac only) and forgoes the XML based format used in Visual Studio.

Why you should create an extension

On the surface, VS Code does not seem to provide many reasons for why anyone would create extensions for it. The platform has most of the same features that other editors have. The snippet format is powerful, and with extensions like Settings Sync, it is easy to share them over a Gist. Code (pun intended) is open source and the team is fairly responsive to requests. Basic support can be provided without a plugin by creating a “typings” file in the npm module.

Still, creating extensions for VS Code is something all web developers should try for the following reasons:

  • Playing with TypeScript: Many developers are still on the edge with TypeScript. Writing an extension in VS Code gives you a chance to witness how TypeScript works in action and how much its type safety and autocomplete features can help with your next JavaScript project.
  • Learning: The web gets a lot of slack for its performance. VS Code demonstrates how you can develop a performance-sensitive applications in Electron and some of the techniques — the multi-process and cluster-oriented architecture is so good that all Electron apps should just steal it for their own use.
  • Fun: Most important, it is a lot of fun developing VS Code extensions. You can scratch an itch and end up giving back to the community and saving time for so many developers.

Trivia! Even though TypeScript is an independent programming language with many popular uses including the Angular (2+) framework, VS Code is the sister project with the most impact on the language. Being developed in TypeScript as a TypeScript editor, VS Code has a strong symbiotic relationship with TypeScript. The best way to learn the language is by looking at the source code of Visual Studio Code.

What an extension can do

VS Code exposes multiple areas where an extension can create an impact. The exposed touch points could easily fill a book. But there’s unlikely a situation where you need all of them, so I’ve put together a listing here.

These outline the various places that can be extended as of version 1.25:

Area Description
Language grammar Variables, expressions, reserved words, etc. for highlighting
Code Snippets Items in autocomplete with tab-based navigation to replace certain items
Language configuration Auto-close and indent items like quotes, brackets, etc.
Hover action item Documentation tooltip on hover
Code Completion Autocomplete items when typing
Error Diagnostics Squiggly red underlines to indicate potential errors Signature Helper Method signature tooltip while typing Symbol Definition Location of the code where the symbol is defined in the inline editor and go to the definition (including a ?+Hover tooltip) Reference For the inline editor with links, all files, and places associated with the symbol Document Highlighter List of all positions where the selected symbol exists for highlighting Symbol List of symbols navigable from the Command menu with an @ modifier Workspace Symbol Symbol provider for an entire workspace Code Action Squiggly green underline to indicate fixable errors with a fix action on click Code Lens Always present inline metadata with clickable action items Rename Support for renaming symbols used in multiple places Document Formatting Fix indentation and formatting for the entire document Document Range Formatting Fix indentation and formatting for selected text On Type Formatting Fix formatting and indentation in real time Color Provider Color popup menu alternative Configuration Defaults Override settings and save as a new set of defaults Command Commands in the ?+P menu Menu Menu items in the top level menu, any menus alongside the document tab bar, and context menus Key bindings Keyboard shortcuts Debugger Debugger settings for debugging a new or existing language Source Control Overrides to support a custom source control system Theme Color theme Snippet Same as code snippets above View A new section in one of the docked panels on the left View Containers A new docked panel on the left bar TypeScript server plugins Overrides for the built-in TypeScript language server Webview Alternative page in parallel to a document to show a custom rendering of a document or any custom HTML (unlike a View Container that is docked to a side) Text Decoration Decoration on the gutter of the text area Messages Popups for error, warning and informational messages on the bottom-right Quick Pick Multi-select option selector menu Input Box Text box for the user to input values Status Bar Item Icon, button, or text in the status bar Progress Show a progress indicator in the UI Tree View Create a tree like the one used to define the workspace (which can be put inside a View or a View Container) Folding Range Custom code folding into the plus button on the gutter Implementation The implementation provider (languages like and TypeScript can have declaration and implementation as separate) Diff Provider Diff view in source control mode Commit Template For commits in source control mode

Apart from this, you can invoke any functionality that the user can invoke in any of the menus with whatever parameters the user can pass. There are events on almost every functionality as well as a lot of file systems and text file-related utility methods.

Let’s start building

Alright, enough with the preamble — let’s start putting an extension together with what we’ve just learned.

Creating the extension

To build an extension, start with the VS Code extension generator.

npm install -g yo generator-code
yo code

Next up, configure the options. Here’s how I set things up:


Extension Generator for VS Code

TypeScript is optional, but highly recommended. Just another way to remind you that VS Code works really well with TypeScript.

Now, you can open the folder in VS Code. I would recommend checking the initial commit. You can look at the quick start guide that gets generated in the project to understand the file structure. Take a quick stab at seeing it live. Go to the debug panel and launch the extension in debug mode. Place a breakpoint inside the activate method in extension.ts to walk through this in action. The “Hello world” application already registers a command that can launch an informational message in the footer. Go to the commands menu with ?+?+P (Ctrl+Shift+P on Windows) and select hello world.


Hitting the debugger

You can put another breakpoint in the registerCommand callback to get the command event.

Open package.json for a description of the plugin’s configuration. Change activationEvents to a more specific one based on what type of language or file protocol you want to support. All Autocomplete supports all file formats, indicated by an *. You should also look at the contributes section if you want to contribute to things like settings, commands, menu items, snippets, etc.


All Autocomplete in the contributes section with contribution points

Many of these contributions have additional JSON in the same package.json file with all the information. Some APIs require code that has to be used in the activate call like vscode.commands.registerCommand for creating a command. For an autocomplete extension, the contributes section is not required and can be removed.

To use the same All Autocomplete options in extension.ts, replace the activate function with the following:

export function activate(context: vscode.ExtensionContext) {
context.subscriptions.push(vscode.languages.registerCompletionItemProvider('*', {
    provideCompletionItems(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken) {
        return [new vscode.CompletionItem("Hello")];
    }
    }));
}

You can specify further details about the completion item, like attached documentation using more options in the object. Now, if you debug this and type H you should see Hello in the completion menu. The code to register most of the language-based providers is nearly the same.


The All Autocomplete menu

You can see the All Autocomplete menu in vscode.languages, which provides options to register providers. Each provider has its own set of parameters that we can fill up similar to the completion item provider.


All Autocomplete with the list of language-specific providers

The document object provides access to the document with utility methods to access text at specific positions and ranges. It is strongly encouraged to use the APIs to access all documents instead of the raw Node.js APIs.

You can parse the document on demand or keep a data structure (like the trie used in All Autocomplete) optimized to search for inputs as the user is typing.

Tip: If you are looking for some text selection/manipulation APIs, there will most likely be an API already available. No need to reinvent the wheel. You can precisely get text with document.getText(document.getWordRangeAtPosition(position)). Alt+Click on any VS Code object to get to the class structure and JSDoc documentation.

Publishing the extension

Once the extension is complete, it is time to publish it to the marketplace. VS Code has a command line tool (vsce) for publishing but it does require creating an account.

Here’s how to prep the extension for submission:

  • Clean up the package: The package.json and README.md files provide the description and details about your extension that get displayed in the marketplace. It is essential to spruce up those files and fill all missing information so that the documentation comes out clean. Good to add some badges and a self-describing GIF to the repo.
  • Create an account: You need to create a Visual Studio Team Services (VSTS) account. This is the only place where VS Code ties up with Visual Studio. You need to sign up and get an access token. The VSTS interface is slightly confusing, but you don’t need to learn a new code management tool to publish. Go to the security section to get the access token. (Don’t make the same mistake as me and confuse the gear icon in the menu with security.)
  • Install: Use the vsce command line tool to publish extensions. It is available in npm and is extremely easy to use.

Security Settings in VSTS

Tip: The access token for VSTS expires every year and therefore the account information is extremely important. It is also required to reply to the comments on the marketplace, though most users are active on GitHub and that is where you are more likely to get bugs and feature requests.

npm install -g vsce # One time installation
vsce create-publisher <name> # One time create publisher
vsce login # One time login. Asks for access token.
vsce publish <version> # Publish or update the extension

VS Code does not compile extensions on the server. Make sure the output folder created by compiling your extension is up to date. Also be sure to check case sensitivity of your file names because incorrect file paths will break in Linux. Native modules in Node are a huge pain and should not be used. It is impossible to compile and provide all platform variants for specific Electron versions. (Someone needs to create a PhoneGap build for npm!) This will get better over time with WebAssembly and N-API.

Support and Maintenance

The VS Code team is super active on GitHub and StackOverflow. GitHub is the right place to file bugs that you might discover in the API. The team is fairly responsive though you need to make the context extremely clear as you would with any helpful bug report.

You should have a GitHub repository for your extension and expect users to file issues directly on GitHub. Expect VS Code users to be proficient with tools and technology (some of them may have a lot more knowledge that you). Even though it’s a free endeavor, keeping humility and treating issue reporters as customers is the right behavior.

Tips on performance

VS Code has good performance because it is built with an architecture that isolates things like extensions that can cause slowness. If your extension does not return in time, your output might be ignored.

A few things that can help maintaining the performance of the editor include:

  • Using the official APIs: It is easy to ignore them and build your own. The “typings” file is wonderful and has documentation for all of the available APIs. A five minute search there can save a lot of time. If you need some files, it is better in most cases to request VS Code to open it in an editor than it is to read it from a disk (unless you are reading thousands of files and not leaving them open).
  • Expose options: Ensure there is a way for users to turn off capabilities that rely on heavy events, like every keystroke. It may not seem noticeable on your machines, but this is not the place for that. Developers maintain their dot files forever and they spend time going through options if there is an issue they to work around. There is no harm in exposing a way to gracefully degrade in case every keystroke is not possible.
  • Child process: Developer tools — especially on the command line — are extremely fast and well optimized. If you need something that involves a lot of files that could choke the JavaScript thread, call into a native tool and politely ask the users to install the dependency. Electron has limitations and we should accept them.

Wrapping up

VS Code is a very flexible application and provides almost all of its guts to extension developers. The workflow to develop and debug extensions is easy and every JavaScript developer should feel at home trying them out. The biggest advantage of developing extensions outside of improving our own lives is the possibility to see a huge TypeScript project in action. For that alone, I would recommend all users to definitely give it a go and share your extensions in the comments.

My extension is live on the VS Code marketplace and I would love to get your feedback on that as well. ?

The post What I learned by building my own VS Code extension appeared first on CSS-Tricks.

Categories: Designing, Others Tags:

UX And HTML5: Let’s Help Users Fill In Your Mobile Form (Part 1)

August 20th, 2018 No comments

UX And HTML5: Let’s Help Users Fill In Your Mobile Form (Part 1)

UX And HTML5: Let’s Help Users Fill In Your Mobile Form (Part 1)

Stéphanie Walter

2018-08-20T13:45:31+02:002018-08-20T12:35:21+00:00

Forms are one of the most basic primary interactions users will have with your websites (and mobile apps). They link people together and let them communicate. They let them comment on articles and explain to the author how they strongly disagree with what they’ve written. They let people chat directly on a dating app to meet “the one”. Whether for forums, product orders, online communities, account creation or online payment, forms are a big part of users’ online life.

It’s 2018, and we have more mobile than desktop users around the globe. Yet, we still treat those users as second-class citizens of the web. Everybody writes and speaks about user experience all the time. So, why, why, why are so many websites and products still doing it wrong. Why is their mobile user experience damaged for half of the world? Why is it still a pain, why is it still super-hard to book a flight and register an account in a mobile form today? Users expect better!

Recommended reading: World Wide Web, Not Wealthy Western Web

This is the first part of a series of two articles. In this one, I will sum up some essential best practices to improve your mobile forms, including scannability and readability. I will guide you through label and input placement, size and optimization. We will see how to choose the right form element to reduce interaction costs. Finally, you will learn how to prevent and deal with errors on mobile forms.

In the second part, I will take a closer look at specific mobile capabilities and HTML5 form elements, and we will go beyond classic form elements to make unique and enjoyable web applications and websites.

Note: While most of the code enhancement in this article are web-related (because I don’t know Swift or Java), the usability best practices hold true for mobile applications.

Form Design 101: Prioritizing Scannability And Readability

“A form is the name, value, pairs, in a structure for storing data on a computer barfed out as labels and input fields to human being.” This is a direct quote from Luke Wroblewski at a conference. Like him, I believe that most form usability issues come from this tendency to serve the structure of the database to users.

Strong Information Architecture

To build better forms, you first need to take a few steps away from your database’s structure. Try to understand how users want to fill in forms. This is where doing some usability testing and user research on your forms becomes handy. User mental models is a UX concept that can help you with that. Nielsen Norman Group describes it as “what the user believes about the system at hand”. Ask your tester to think aloud and tell you how they would fill the form. Which steps do they expect? What come first? What comes next? This will give you a better idea of how to structure your form in a more user-friendly way.

Visually grouping fields that belong together will also help users fill a form. In the code, use the fieldset tag to group them programmatically. It will also help screen readers understand the hierarchy.


example of visually grouped forms

Chunking information and grouping related pieces of information helps the human brain process this information in an easy, more readable way (Large preview)

If the form is long, don’t expose everything by default. Be smart about what you display. Use branching wisely to display only the fields that people need. In a checkout form, for example, don’t display all of the detailed fields for all of the shipment options. This will overwhelm the user. Display enough information to help them choose the right shipment option. Then, display only the details and fields related to that choice.

User attention spans get shorter with time: Ask for optional things at the end of the form. For instance, if your form is a customer-satisfaction survey, ask for demographic information at the end. Better yet, auto-fill them, if possible. Ask users only for what’s necessary.

Finally, plan ahead for localization: What will happen when your form gets translated? What will happen, say, for German? Will your design still work?

Label Placement And Input Optimization

Single-Column Layout Works Best

Due to the lack of space, you don’t get endless options for placing labels and fields on mobile screens:

  • Present fields in a single-column layout. There’s no room on mobile for multiple columns. Multi-columns forms are not a great idea on desktop either anyway.
  • In portrait mode, it’s better to place the label on top of the field so that users can see what’s in the field when they type.

portrait mode

In portrait mode, it’s better to put the label on top of the field. (Large preview)
  • In landscape mode, the screen’s height is reduced. You might want to put labels on the left and inputs on the right. But test it to make sure it works.

landscape mode

In landscape mode, you want to put labels on the left and inputs on the right. (Large preview)

For more on label placement, see Baymard Institute’s “Mobile Form Usability: Place Labels Above the Field”.

Labels Should Be Clear And Visible And Work Without Context

Remember that as soon as a field gets focus, the keyboard opens and will take at least one third of the screen’s area. On small mobile screens, users will also have to scroll to fill the form. This means that they will lose part of the context while filling the form. Plan accordingly:

  • Your labels should be clear, visible text that can be read and understood without context. User should be able to complete each label and field pair as a separate task, even if they lose context.

labels should be clear

Just “Address” without context is more complicated to process that “Shipping Address”. (Large preview)
  • Avoid jargon, abbreviations and industry-specific language whenever you can.
  • Be consistent. If you use “customer” in a label once, stick with that word. Avoid using “clients” later because it might confuse users.
  • The font size should be big enough. Test your form on real devices as soon as possible, and adjust the size accordingly.
  • All-caps text can be hard to read for some users. You might want to avoid using all-caps text on labels.
  • The label copy should be short and scannable. If a field needs clarification, don’t put it in the label. Use a field description instead.

Avoid full caps, jargon and very long labels.

Avoid full caps, jargon and very long labels. (Large preview)
Input Size Best Practice

If possible, the size of the input element should match the size of the expected content. This will help users quickly fill in the form and understand what’s expected.


Properly sized inputs help the user scan the form and understand what is expected in the fields.

Properly sized inputs help the user scan the form and understand what is expected in the fields. (Large preview)

Using Masks To Avoid Splitting Inputs On Mobile

Don’t split inputs just for the sake of formatting. It’s especially annoying on mobile, where users can’t use the keyboard to navigate between fields. It requires extra taps just to go to the next field to fill in the form. You might be thinking, “But I’ll automagically put the focus on the next field when I get the required number of characters in that field”. That could work. But you will have taken control of the UI, which becomes unpredictable for the user. Also, it would be a pain if you automagically sent them to the next field and they needed to correct something in the last field. Finally, it’s more complicated to guess what’s mandatory with split inputs. So, let’s stop playing the “But what if” game and simply not split inputs.


Don't split the phone number into many little inputs.

Don’t split the phone number into many little inputs. (Large preview)

I get it: You still want to be able to format your user’s data in small pieces to help them fill in your fields. And you are perfectly right about that. To do so, you could use masks. Instead of splitting an input, just put a mask on top of it, to visually help the user fill it. Here is a video example of what a mask would look like to help users fill in a credit-card field:

Masks help to prevent errors by guiding users to the correct format. Avoid gradually revealing them — show the format directly. Also, avoid putting fake values in the mask. Users might think it’s already filled. That’s why I’ve replaced the numbers with a little “X” in my demo. Find what works best for your type of input.

Finally, remember that some data can vary between countries, and sometimes the format changes, too (phone numbers, for example). Plan accordingly.

Efficient Fields Descriptions

Displaying efficient field descriptions can make the difference between a seamless and a painful form experience.

What Can Descriptions Be Used For?

Descriptions can help users in so many ways. Here are a few examples.

  • What Exactly Are You Asking For?

    For whatever database-related reason, some shipment companies ask for “Address 1” and “Address 2” fields. This is highly confusing for users, but you might not have a choice here. Add description fields to help users understand what they need to put in each field.


    Inline descriptions help users understand why you need this information.

    Inline descriptions help users understand why you need this information. (Large preview)

    The same goes for acronyms and abbreviations. I know I said that you should avoid them, but sometimes you can’t. If you work on complex forms for a particular industry, for instance, they might have their own set of abbreviations. Any new user who needs to fill in the form might not be familiar (yet) with those abbreviations. Having a description available somewhere will help them.

  • Why Do You This Information?
    Users might be reluctant to give you personal information if they don’t understand why you need it and what you will do with it. But sometimes you still need to ask for such information for legal reasons (like date of birth for a website that sells alcohol). Using field descriptions here will help users understand why this kind of information is needed.

    On e-commerce websites, you might want to ask for the user’s phone number in case the delivery person needs to contact them. This is a legitimate reason. So, again, use descriptions to explain to e-commerce users why you need their phone number.


    Sometimes you need information for legal or practical reasons. Again, tell the user why.

    Sometimes you need information for legal or practical reasons. Again, tell the user why. (Large preview)
  • “Where Do I Find the Information?”
    If your users need to find certain information somewhere else in order to fill a form, tell them where to find it. I worked on a mobile app that lets user track their house. Users needed to pair the app to the monitoring device using a serial number. It’s not very easy to find this serial number on the device; it requires some instruction. We added a little ? button next to the serial number field. The button opens a modal that shows a picture and some indication to help the user understand where to find the serial number on the monitoring device.
    E-commerce websites do the same with promo codes: They give indicators that tell users where to find the codes.


    Users can tap to open a pop-up in which they can find extra information to help them fill in the field

    Users can tap on the link (left) or the question mark (right) to open a popup where they can find extra information to help them fill in the field. (Large preview)
  • “How Should I Format The Information?”
    Some fields need a particular format. In this case, use descriptions to let users know the formatting rules up front. Here are a few examples:
    • Phone number: do I need to put the international dialing code (+xx) in front of the field?
    • Is there a maximum length? Twitter on mobile does a good job with that one.
    • When dealing with monetary amounts, is the format with comma (like 10,000) or a space (like 10 000)?
    • What format do you expect for dates? I’ll let you check on Wikipedia what a nightmare that is. The difference between DD MM YY and MM DD YY can cause a *lot* of trouble to users when booking online.

    Note that a lot of those formatting issues can be solved by input masks. We will come to that later in the article (or you can jump right in if you are impatient).


    In the old 180-character days, Twitter used to tell you exactly how many characters you had left. Also, the date format varies from one country to another, so you might want to explain what to expect.

    In the old 180-character days, Twitter used to tell you exactly how many characters you had left. Also, the date format varies from one country to another, so you might want to explain what to expect. (Large preview)
How To Display Descriptions

In the examples, above, we saw a few ways to display field descriptions. Here is a summary of what to do:

  • Inline descriptions should be directly visible and displayed next to the field.
  • If you need more in-depth descriptions with heavy content, you can use tooltips or modals. Tooltips are generally triggered on hover on desktop and on tap on mobile. The same goes for the modals: Open it when the user taps the help icon or “see more” link, for instance.

Be Careful With Placeholders

I get it: it’s tempting to remove fields on mobile to gain space and use placeholders instead. We’ve all gone down that road. But please don’t. The HML5 specification is clear about this: “The placeholder attribute represents a short hint (a word or short phrase) intended to aid the user with data entry”. And here is why:

  • The placeholder disappears when the user starts typing. The user must then rely on short-term memory to remember what they are supposed to put in the field. If they can’t, they will need to empty the field to see the indication.
  • It’s hard for users to double-check fields before submitting because the fields no longer have any label indications.
  • It’s hard to recover from errors once a field has been submitted because, again, there’s no label to help the user.

Placeholders rely on short-term memory

Placeholders rely on short-term memory. They make forms hard to check before submission. And recovering from errors is hard, especially when error messages don’t help much. (Large preview)

Even if you use placeholders with labels, you might still have some issues. It’s hard to tell the difference between a filled field and a field with a placeholder. I’m a UX designer who writes about mobile form design and even I got tricked last week by one of those. If it happens to me, it will happen to your users — trust me on that one. Finally, most placeholders have light-gray text, so you might have some contrast issues as well.


It's easy to mistake some form fields for being filled in

It’s easy to mistake some of these fields for being filled in. The right screenshot is something I’ve seen online. I’ll let you guess what is filled in and what is not. (Large preview)

If you want to go deeper in this topic, there’s a great article named “Placeholder Attribute Is Not A Label, and also Joshua Winn and FeedbackGuru go into detail on why this is a bad idea. Nielsen Norman Group also wrote a piece on the topic, named “Placeholders in Form Fields Are Harmful.”

Placeholders are not mandatory in HTML5. From a usability point of view, you most certainly don’t need a placeholder in every field of your form. But with the massive adoption of Bootstrap and other frameworks, it looks like a lot of people just copy and paste components. Those components have placeholders, so I guess people feel kind of obligated to add something to the placeholder in the code? If your form’s placeholders look like “Please fill your — label — here”, you’re doing it wrong.


form example

I’m not joking: I’ve actually seen forms with 12 fields, with each placeholder less useful than the last. (Large preview)

Labels inside fields could, nevertheless, work well for short forms in which fields are predictable. Login forms are a good candidate for this. But please don’t use the HTML5 placeholder to code this. Use a real label in the code and move it around with CSS and JavaScript.


Labels inside fields can work on really short forms, like login forms, where users don't have a lot of information to remember.

Labels inside fields can work on really short forms, like login forms, where users don’t have a lot of information to remember. (Large preview)

Since the success of Android’s material design, a pattern has started to emerge: the floating label. This label is inside the field when the field is not filled in, so it takes a bit less vertical space on mobile. When users start interacting with the field, the label moves above the field.

This looks like an interesting way to gain some space, without running into the “placeholders in place of labels” issues cited above. Nevertheless, it does not solve the problem of users possibly mistaking a placeholder for filled-in content.


The floating label, even if not perfect, is an interesting alternative to gaining vertical space on the screen.

The floating label, even if not perfect, is an interesting alternative to gaining vertical space on the screen. (Large preview)

Interaction Cost Reduction For Successful Forms

Reducing the interaction cost (i.e. the number of taps, swipes, etc.) of users achieving their task will help you build a seamless form experience. There are different techniques to achieve that. Let’s look at a few of them in detail.

A Magic Study On The Internet Told Me To Reduce The Number Of Fields

More fields mean fewer conversions, right? You might have encountered the “we reduced our subscription form from 11 to 4 fields, and it drove up conversions by 160%” study. It’s a classic. And if you look at their contact form, it kind of makes sense. Why would users want to fill in 11 fields just to contact the company? You can’t ask such a big commitment of people who barely know you, right?

Start by asking only for useful information. Why do you need a person’s gender to create an account for them? Why do you have two lines for the address if your subscription form is for an online service?

Ask only for the information you need. And then ask for the information in context. If you have an e-commerce website, users might be more inclined to give you their address in the shipping section of the checkout process than when they register. It will make your e-commerce registration form so much easier to fill on mobile!


Ask only for the information you need

Ask for the user’s address in the shipping section of the checkout, not when they register. (Large preview)

Also, don’t blindly trust every statistic and study you find on the Internet. Remember the 11-fields-to-4 study? Well another more recent study showed that by reducing fields from 9 to 6, conversions dropped by 14%. Shocking, isn’t it? Why? Well, they removed the most engaging fields. Long story short, they then went back to 9 fields, put the most important on the top, and voilà, conversions increased by 19.21%.

The bottom line is that while these studies are interesting, those websites are not your website. Don’t blindly trust the first study you find on the Internet.

So, what can you do? Test. Test. And test!

  • Do some user testing to see the time to completion of your mobile form.
  • Measure drop outs.
  • Measure problems with certain fields.
  • Measure the frustration associated with certain fields. How willing are users to give that information? How personal is that information?

Optimizing Touch Interactions

Making Controls Touch-Friendly

If your fields are too small or hard to reach, users will make errors and will need extra interactions to achieve their goals. Remember Fitt’s law? You could apply it to mobile design as well: Make your labels, fields and form controls easy to tap by increasing the touch target size. For labels on the web, a little more padding can increase the touchable area. Sometimes you will also need to add some margins between elements to avoid missed taps.

Also, don’t forget to link labels with their components by pairing for and ID values. That way, if the user misses a tap on the label, the corresponding field will still get focus.


On mobile, respect mobile touch-optimized best practices, and make sure inputs are big enough to be easily tappable.

On mobile, respect mobile touch-optimized best practices, and make sure inputs are big enough to be easily tappable. (Large preview)

Steven Hoober conducted some user research on touch areas. You’ll find a summary in “Designing for Touch”. Based on what he discovered, he built a little plastic ruler tool: the mobile touch template. The tool could help you make sure your touch areas are big enough for mobile forms and more generally for mobile design.


Image from Steven Hoober

Image from Steven Hoober’s mobile touch template. (Large preview)

To learn more about designing for touch you can read the following:

Providing Feedback

Mobile users don’t have a mouse (no kidding), so they don’t get the “click” feedback that desktop users get when hitting a button. Mobile form users need clear feedback when interacting with elements:

  • Provide a focus state for the form field that the user is interacting with.
  • Provide visual feedback when the user interacts with a button.

I’m not a big fan of material design’s ripple effect on buttons. But I must admit that the animations on Android provide clear feedback when the user interacts with a button.

Honor The Next And Previous Button Order

Finally, honor the next and previous buttons on mobile keyboards. Users can use them to quickly navigate fields. The tabindex order should match the visual order of fields and components.


iOS has small arrows on the keyboard to go from one field to another.

iOS has small arrows on the keyboard to go from one field to another. (Large preview)

Avoid Dropdowns On Mobile If Possible

Dropdowns (the HTML select element) on the web require a lot of tabs and interactions. Therefore, as Luke Wroblewski said, they should be the UI of last resort. Many other UI components work better than dropdowns in many situations.

Segment controls and radio buttons are good alternatives to dropdowns if you have between two and four options. Why hide the options under a dropdown when you can show them all directly on one screen? Note that, like radio buttons, segment controls are mutually exclusive.


Example of segment controls in the iOnic library.

Example of segment controls in the iOnic library. (Large preview)

A country list is a good candidate for a component. A dropdown of over a hundred countries is an interaction nightmare on mobile. It’s OK if you are looking for Afghanistan (at the beginning of the list) or Zimbabwe (the end of the list). If you’re looking for Luxembourg, you will end up in a game of scrolling to reach the middle of the list, going too far to the letter M, trying to come back to L, and so on.

Long dropdowns can be replaced by predictive text input fields. When the user starts typing L, the interface would propose nine countries. If they add a U — voilà! — Luxembourg it is. Four interactions instead of two, versus as many as six or seven scrolling interactions with the dropdown.


Long dropdowns are a nightmare when you're searching for France. Predictive fields work better.

Long dropdowns are a nightmare when you’re searching for France. Predictive fields work better. (Large preview)

If you need users to pick a date, forget about splitting it into a day, month and year dropdown like people are used to doing on paper forms. Replace multiple date dropdowns with a date picker. The HTML5 input type=date works in most cases. But you might have some special needs and end up building your own date picker in JavaScript, especially if you are in the booking business (hotels, cars, flights).


A double date-picker built in JavaScript makes it easy to pick arrival and departure dates with a minimum of interaction

A double date-picker built in JavaScript makes it easy to pick arrival and departure dates with a minimum of interaction (Large preview)

In his article “Mobile DropDowns Revisited”, Klaus Schaefers explains how using a date-picker for arrival and departure dates made interactions 60% faster.


A date-picker, using HTML5 or JavaScript, instead of dropdowns, via Mobile DropDowns Revisited

A date-picker, using HTML5 or JavaScript, instead of dropdowns, via Mobile DropDowns Revisited. (Large preview)

Let’s stick with the booking business. Suppose the user needs to add multiple travellers to their itinerary. You can **replace the dropdown *with a* stepper** to select the number of passengers. A stepper is a control that allows the user to increase and decrease values simply by tapping on + and - buttons. That tends to be faster when fewer than six persons have to be added. It’s also more intuitive. Below is an example of a stepper used in the Android-native Airbnb app to select guests, and on the mobile-optimized website of Kayak to add passengers.


A stepper is used in the Android-native Airbnb app to select guests and on the mobile-optimized website of Kayak to add passengers.

A stepper is used in the Android-native Airbnb app to select guests and on the mobile-optimized website of Kayak to add passengers. (Large preview)

A final alternative to dropdowns is the list view. The options would be listed in a specific subview, as radio buttons, for instance. This is mostly how Android settings work.


In our monitoring app, when the user clicks on “notification type 1”, it opens a list view with the options.

In our monitoring app, when the user clicks on “notification type 1”, it opens a list view with the options. (Large preview)

Getting Smart With Auto-Completion

If you want to decrease the interaction cost of your form, be smart. Don’t ask for information that you can auto-detect or guess based on other information users have given you. Autocomplete and prefill as much as you can.

Places and Addresses

If the user searches for a place or needs to enter an address, you can offer auto-completion to help them. As they type, an API would fill in the rest of the address for them. This also reduces errors.

You could use:

In the Algolia Place demo, as the user types, it offers suggestions and can autocomplete the field.

In France and many other countries, you can guess the city based on the area code. So, if a French user enters an area code, you could automatically auto-complete or at least propose the city. My country, Luxembourg, is small (don’t make fun of me). My area code is linked to my street. So, if I enter my area code, the form should even be able to suggest my street.

Credit Cards

Another area where auto-detection is easy is credit cards. You don’t need to ask the user what type of credit card they have. You can auto-detect this based on the initial numbers they enter. There’s even a library that can do the job for you.

A demo of the payment script that detects credit card type.
Using HTML5 Autocompletion (Autofill)

The HTML autocomplete attribute can prefill fields based on the user’s earlier inputs. This attribute has an on and off state. Some smart people have started working on a specification to make this more powerful and to extend the autocomplete attribute for form fields. The WHATWG also has an interesting list.

Chrome and other mobile browsers already support some of the extended values for credit cards and names. This means that users can prefill forms with their name and credit card data that they use on other websites.

Help users check out faster with Autofill (Source: Google Developers) (Large preview)

In short, when you must choose between different systems, count the number of interactions each is going to require.

Mistakes Happen: Handling Errors In Mobile Forms

The last step on our journey towards better mobile forms is handling errors and mistakes. We can try to reduce mistakes to ease the user’s cognitive load. We can also help them recover from errors, because no matter how great your form design is, mistakes happen.

Avoiding Errors While Filling The Forms

“Prevention is better than a cure,” my mother used to say. That’s also true of form design: Preventing errors will improve your mobile form’s experience.

Explicit Format Limitation

“Be conservative in what you do. Be liberal in what you accept from others.” This robustness principle can be applied to form fields as well. If possible, let the user enter data in any format.

If you think you need to limit what a user can enter in the field, start by asking yourself “why”. In the user experience field, we have a technique called “the three whys”. If the answer is “because blah blah database”, maybe it’s time to change things. For instance, why do you refuse special characters like é, à and ö in the user name field? I wrote an article explaining how rude forms are to me when I try to enter “Stéphanie” as a user name. I’m still trying to figure out a good reason for that (apart from database reasons).

If you have a good reason to require a specific format from users, state this up front. You can use HTML5 placeholders to give users a hint about what the data should look like, but again, be careful with those. You could also use all of the field description techniques explained at the beginning of this article. Finally, input masks can guide users towards the right format.

Marking Mandatory Fields (And Optional Ones)

Don’t wait for users to submit a half-completed form to tell them about required fields. If a field is mandatory, users should know about it. Marking mandatory fields with an asterix (*) and a legend has become a standard pattern for forms. The good part is that it does not take much space. The problem is that it has no semantic value, so it can cause accessibility issues if poorly coded and if you rely on people’s habits with form interaction.

You could instead explicitly mark both mandatory and optional fields with the words “required” (or “mandatory”) and “optional”. Both Baymard Institute and Luke Wroblewski agree on that. This avoids ambiguity with long forms on mobile, such as when using a scroller, proceeding with something else, then coming back and not remembering if mandatory fields were marked with an asterisk or something else.


A form with both mandatory and optional fields marked.

A form with both mandatory and optional fields marked. (Large preview)

Eventually, the decision on how to mark those fields will depend on the design and length of the field and on the context. The best way to know whether you’ve made the right decision is, again, to test the form.

Sensible Defaults

Be careful about default selected options in forms. When I applied for my previous job, there was an information form. The marital status was optional. They made the first element in the dropdown, “divorced”, the default field. So, I could either not answer (because it was an optional field) and let the system believe that I was divorced, or correct this and disclose my actual marital status even if I did not want to.

Also, be careful about gender. Again, have an option for people who don’t want to disclose it; make clear why you’re asking for their gender; better yet, ask for pronouns, or don’t ask if you don’t really need to. If you are interested in this topic, I recommend “Designing Forms for Gender Diversity and Inclusion.” And if the gender is optional, again, don’t auto-check the first choice, otherwise people won’t be able to uncheck that radio button and choose not to answer.


Should I leave the default and lie, or put the right information even I don't want to?

Should I leave the default and lie, or put the right information even I don’t want to? (Large preview)

Smart defaults, on the other hand, can help users avoid mistakes when filling a form. Unless you’re in a Dr. Who episode, you’re not supposed to book a hotel in the past. Booking.com understands that. When you open the date-picker on the website, the default date is set to the current date and you can’t select a date in the past. When you select a return date, the default is the day after the departure date.


Booking.com's smart defaults help users avoid mistakes. You can't search in the past or before your arrival date.

Booking.com’s smart defaults help users avoid mistakes. You can’t search in the past or before your arrival date. (Large preview)
Less Painful Password Experience

I’ve written about password-less authentication, but you can’t always use those techniques. Users will eventually have to create a password and enter it in a mobile form. And most of the time, that experience sucks. Here are a few ideas on how to make it better and help users avoid mistakes.

  • When Creating An Account
    I won’t get into the details of what kind of passwords you should require and how many characters they should be composed of — plenty of articles on that topic are on the web — just make up your mind about your password criteria. When users create an account, be proactive, not reactive. For the love of Cthulhu, don’t let people guess. Tell users your password criteria up front.

    A lot of websites now show you a gauge for password strength telling you in real time what is missing. This is an interesting and excellent pattern. KLM uses it in its sign-in form:


    KLM sign-in form example

    KLM sign-in form example (Large preview)

    But there are still some big problems with this design.

  1. They don’t tell users their password criteria up front. Users who want to generate a password (using a password manager, for instance) must first guess that they need to first interact with the field in other to see the password criteria.
  2. They limit the password’s length to 12 characters, but they never tell users how many characters are left. Sure, let’s add “counting the dots” to the cognitive load of building a password with so many criteria. After 12 characters, you can keep on typing on the keyboard, and nothing will happen.
  3. What happens if, like me, you reached the 12-character limit but haven’t met all of the criteria? Well, you would just have to delete the entire password and start over again.
  4. Finally, you must enter the password twice. How is a user supposed to remember and retype the password that they just created based on those criteria while counting the dots?
  5. Back to 1, generating a password with a password manager.

If KLM wanted to make this form better, it could provide a mask/unmask option for the password. Doing so, it would not need to ask for the same password twice. Users could visually check that the password they typed is the one they want.

TransferWise doesn’t solve my first problem in the list, but at least I can unmask while typing.
  • When Logging In
    In a login form, a mask/unmask password option would tremendously improve the user experience.

    A button to show and hide the password in a form.

    Amazon has an interesting history of iterating on passwords in its login form. It used to have a version in which you could not see the password. The next iteration allowed users to reveal it. Then, the password was revealed by default, and you could hide it. This is what is looked like in 2015:


    Showing Passwords on Log-In Screens by Luke Wroblewski (2015)

    Showing Passwords on Log-In Screens, Luke Wroblewski, 2015 (Large preview)

    Amazon tested the last version, and 60% people got suspicious. So, they replaced the “hide password” unchecked checkbox with a “show password” checked box. This would show the password in smaller characters, under the field, while the user typed. This is what it looks like at the time of writing this article:


    Amazon's show and hide password functionality

    Amazon’s show and hide password functionality (Large preview)

    As you can see, there’s always room for improvement.

Inline Validation

If you are familiar with usability principles, you might know the Gestalt law of proximity. On mobile, avoid the summary of errors at the top of the page, with no contextual information, after the user has tapped the submit button.

Instead, error messages should be located close to the errors themselves.


An example of inline validation

An example of inline validation (Large preview)
Real-Time Validation

You also don’t need to wait until users hit the submit button. You can validate fields and display feedback while the user is filling them in.

A few tips:

  • As mentioned earlier, password fields would benefit from real-time validation and feedback on each keystroke.
  • You might also want to validate user names in real time when accounts are being created, to make sure they’re available. Twitter does a good job of that.
  • Don’t validate every keystroke. Wait until the user has finished typing. (Use JavaScript blur for web forms, or just wait a few seconds to detect inactivity.)

Note: *Mihael Konjevi? has written a nice article on “Inline Validation in Forms: Designing the Experience.” He explains the concept of “reward early, punish late.”*

“If the user is entering the data in the field that was in a valid state, perform the validation after the data entry.”

“If the user is entering the data in the field that was in an invalid state, perform the validation during the data entry.”

Example from Keechma based on the article.

Color Matters

I’m not saying that color matters just because of my current ginger, pink and purple hair color. Color really matters in form design.

There are some conventions on the web that you don’t want to break. Non-colorblind users know that red is for errors, yellow is for warnings, and green is almost always for confirmation or success. It’s best to stick with these three colors. Red can make people anxious, though. The user might think they’ve made a really serious mistake. Using orange or yellow for error messages could cause less panic. The problem with yellow and orange is that it’s hard to find colorblind-friendly hues of them.


Colors have different connotations across countries and cultures. Be careful with them.

Colors have different connotations across countries and cultures. Be careful with them. (Large preview)

Speaking of colorblindness: Color should not be the only way to convey an error message. This is an accessibility criterion.

In the example below on the left, the field with an error is in orange, and the field that has been corrected has turned green. I used a colorblind testing tool to take the screenshot in the middle: You can’t distinguish between the default gray border and the green one anymore. Adding some icons in the last screenshot ensures that the error messages are conveyed to colorblind people.


Color should not be the only way to convey error messages. The colorblind simulation in the middle shows that the green border cannot be seen by a colorblind person.

Color should not be the only way to convey error messages. The colorblind simulation in the middle shows that the green border cannot be seen by a colorblind person. (Large preview)

Recovering From Errors: Writing User-Friendly Error Messages

At this point, we’ve done everything we can to help users fill our forms and avoid errors. But sometimes, despite our best effort, mistakes happen. It’s time to figure out how to help users recover from those mistakes.

First, remember: Don’t hijack control of the system. If a problem isn’t critical, the user should be able to continue interacting with as much of the rest of the interface as possible. Avoid those JavaScript alert error message and modals that blocks users whenever possible. Also, if your form needs some permission, request it in the flow of use. If permission is not granted, do not consider this an error because it is not. Be careful about the copy you use here.

You’re Not A Robot, And Neither Are Your Users

Robots are cool, I know. But you’re not a robot, and neither are your users. Yet so many error messages are still so poorly written. Here are a few tips when it comes to human-friendly error messages:

  • Never show a raw error message, like “An error of type 2393 has occurred. Server could not complete the operation.” Instead, explain what happened in human language and why it happened.
  • Never show a dead-end error message, like “An error has occurred.” Instead suggest ways to recover from the error. Write actionable copy.
  • Never show a vague error message, like “A server with the specified hostname could not be found”, with a “Try again” button. Instead, make error messages informative and consistent. Please don’t sound like a robot.
  • Don’t assume that people know the context of a message. Your users are not tech-savvy geeks. Instead, explain to them in plain language, without technical jargon, how to recover from this error.

Examples of non-human-friendly error messages. Eek!

Examples of non-human-friendly error messages. Eek! (Large preview)
Beware The Language You Use In Messages

Whatever you write, avoid making people feel stupid about a mistake. If possible, leave out negative words; they tend to scare people and make them even more anxious. Use a courteous, positive, affirming tone instead.

Don’t blame users for mistakes; blame the system instead. The system won’t hold a grudge, I promise. Shift the user’s attention to how the system could not process the action, and explain to them how to find a solution.

A little trick is to read your own message out loud. It will help you hear whether it works or is too harsh or too casual, etc.

You could also get creative with error messages and incorporate imagery and humour to make them less threatening. This will really depend on your brand’s identity and tone, though.

To help you write better error message, I suggest you read the following:

Time To Submit The Form

The user has filled in the form, there are no more errors, and everything looks good. Finally, it’s time to submit the form!

The first rule is, don’t mask the submit button. Seriously! I wonder what twisted mind came up with this idea, but I’ve seen it in some forms. The submit button would be displayed only once all required fields were filled in without any errors. It’s disturbing for the user to wonder whether something is wrong or the form’s button has not loaded or the website is broken and so on.

If you don’t want users to be able to hit the submit button if there’s missing mandatory fields or there are validation errors, use the disabled HTML attribute on the submit input. You will need to re-enable the button using JavaScript once the form is valid and ready for submission.


Do not hide the submit button. Instead, deactivate it until users have filled in the required information.

Do not hide the submit button. Instead, deactivate it until users have filled in the required information. (Large preview)

If you have a primary and secondary call to action, use color, size and styling to show the hierarchy.


Example of primary and secondary actions

Example of primary and secondary actions (Large preview)

If are wondering whether the confirmation button should come before or after the cancellation button, so am I (and a lot of other people). If you are building a native app, stick to the OS guidelines. It’s become particularly fun since Android changed the button positions in its fourth version. On the web, it’s more complicated because there are no real guidelines. Regardless of the OS, here are some general guidelines for mobile-optimized submit buttons:

  • Give the call to action descriptive, actionable verbs.
  • Provide visual feedback when the user taps it.
  • If you have two buttons, make the primary action stand out.
  • Unless you’re working on a very specific back-office enterprise form (in which case, you’ll have a lot of challenges optimizing for mobile), avoid a reset button. Users might confuse it with the submit button and will lose all of their data by accident.

Conclusion

In this first part, I’ve discussed a lot of little techniques to take your form to the next level and help users fill it in. Some of these general guidelines and mobile best practices might not work 100% of the time — that’s the catch with best practices. So, always test your forms on real users and real devices, and adapt the guidelines to your users’ specific needs and experience.

Also, do some regression and automated functional testing — again, on real devices. Chrome’s mobile emulator won’t be enough to test touch-optimized forms. I say this because I had launched an e-commerce website with a search form that didn’t work on mobile. We only did automated testing using an emulator. Here is what happened. The search form was hidden under a search icon. You could tap on the button, which opened a box with the search field. It worked by emulating a mouse hover as a touch event. We tested tapping on the button, and it opened the box. Nobody tried to launch a search. So, nobody (not even the client) saw that the search field disappeared as soon as users tried to interact with it. What happened? When the input element got focus, the button lost the hover state, so it closed the box with the field. Automated testing was not able to catch this because the input was not losing focus. So, we launched an e-commerce website without search functionality on mobile. Not a super experience.

In the second part of this series, we will see more advanced mobile-specific techniques. We will see how to use cool HTML5 features to format fields and how to use mobile capabilities to take the mobile user experience to the next level.

Smashing Editorial(lf, ra, al, il)
Categories: Others Tags:

20 Freshest Web Designs, August 2018

August 20th, 2018 No comments

Welcome to our roundup of the best websites launched (or relaunched with significant updates) this August. The Summer’s almost over, vacations are less frequent, and we’re starting to see businesses gearing up for the Fall. This month we’ve included some great e-commerce, some design agencies with a difference, and some products with marketing challenges.

There’s a huge trend for bold color, subtle animations, and scrolling effects this month. And not before time, big type is making a comeback. Enjoy!

Epicurrence

The creative conference for creatives that don’t do conferences, Epicurrence 2018 takes place in Yosemite later this month. The accompanying site uses stunning illustrations and subtle parallax to draw the user into the spirit of the event.

Angelo Sanvito

Angelo Sanvito is an illustrator, UI and UX designer, and motion graphics designer from Milan, Italy. His simple site shows off the very best of these skills with a series of portraits of famous artists. When it comes to personal sites, it’s the epitome of “Don’t tell, show”.

Atomize Design System

The Site for the Atomize Design System is beautifully minimal. It of course follows its own best practices, but there are also some excellent details. Take a look at the custom icons for the different features all based on the branding. Detail like that takes time.

Lisa & Ryan

Picking a design agency to take your brand forward is a difficult task. Lisa & Ryan do a great job of explaining who they are, why they’re a great team, and why you should pick them.

Bellvoye

If you’re looking for a wee dram, then the Scottish Highlands is probably your first port of call. But if you’re looking for something a little different, then you might consider meandering south to France, thanks to this exquisite website for Bellvoye.

Swiss Typefaces

Swiss Typefaces is a type foundry with an audacious attitude to color. With so many type designs presented in black and white, it’s refreshing to see hot pinks, acid greens, and lots of magenta all thrown into a single design.

Eleven Plants for Dum Dums

Part design exercise, part typography sampler, part horticultural guide, Eleven Plants for Dum Dums is a beautifully designed single page site with awesome illustrations galore. You’ve rarely seen green so lovingly applied.

Posthaste

Do you remember the video arcade classic Paperboy? No, me neither (ahem). For those too young to have wasted hours on Atari’s worldwide smash, MailChimp have released this fun game. Steer Freddie through the streets delivering as much mail as you can.

Boy Smells

Purveyor of scented candles for men and women, Boy Smells have gone super bold with their type, and super committed with their restricted color palette. The result is a site that feels very modern, and very confident.

End Family Fire

Family fire is the unhappy occurrence of an accidental shooting as a result of an improperly stored firearm. The End Family Fire website leverages art direction and interaction to educate on the potential risks, so you can keep your family safe.

Appointed

Great work is helped by a great workspace, and of course by great design tools. Appointed‘s site perfectly captures the spirit of the workspaces it is trying to create by exuding pure calm.

Goat

Goat are selling something difficult: second hand shoes. Professionally cleaned, and graded, they offer everything from rare sneakers to everyday kicks. To grab your attention, Goat uses intrigue right from the get-go, this is a great high-impact design.

Coralie Reiter

Coralie Reiter makes exquisite jewellery out of natural materials like shells. The delicate nature of the items being displayed is perfectly balanced by the use of pastels throughout the site to add life, and energy to the collection.

Art & History Museum

We’re used to hero images featuring smiling models peering out at us. Art & History Museum brilliantly subverts the cliché with a comical look from a stone figure. The rest of the site for the Brussels museum is just as carefully curated.

Renegade Craft

Renegade Craft is another site using bold typography, subtle (and not so subtle) animation, and bold color blocks. Promoting craft practices across the USA, the site’s a positive use of parallax.

Hawkins New York

Selling interior design products is difficult in a competitive market, but sites like Hawkins New York are finding a new design direction by merging classic minimalism and a new-found love of color to ply their wares.

Arche68

The color blocking and dynamic typography of Arche68 is almost an assault on the senses. It takes some clicking to discover the purpose of the site (they sell accessories) but the bold approach to design is right on-brand.

Curate Labs

There are lots of design ideas on the web, but rarely does a design agency lay its cards on the table to the extent that Curate Labs have. They tell you what they believe, because that’s at the heart of what they do.

Moving Brands

Moving Brands present their portfolio split across the screen using the unique geometry of their logo. With clients ranging from Apple to Sony, you’d be right to expect a creative approach, and they deliver.

Stack

Stack offers subscriptions to a diverse range of magazines for those who like their print media a little more random. As a source of design inspiration, not least thanks to its bold color palette, it’s fantastic to browse through.

Add Realistic Chalk and Sketch Lettering Effects with Sketch’it – only $5!

Source

Categories: Designing, Others Tags: