Archive

Archive for July, 2020

How to Make a List Component with Emotion

July 8th, 2020 No comments

I’ve been doing a bit of refactoring this week at Sentry and I noticed that we didn’t have a generic List component that we could use across projects and features. So, I started one, but here’s the rub: we style things at Sentry using Emotion, which I have only passing experience with and is described in the docs as…

[…] a library designed for writing css styles with JavaScript. It provides powerful and predictable style composition in addition to a great developer experience with features such as source maps, labels, and testing utilities. Both string and object styles are supported.

If you’ve never heard of Emotion, the general idea is this: when we’re working on big codebases with lots of components, we want to ensure that we can control the cascade of our CSS. So, let’s say you have an .active class in one file and you want to make sure that doesn’t impact the styles of a completely separate component in another file that also has a class of.active.

Emotion tackles this problem by adding custom strings to your classnames so they don’t conflict with other components. Here’s an example of the HTML it might output:

<div class="css-1tfy8g7-List e13k4qzl9"></div>

Pretty neat, huh? There’s lots of other tools and workflows out there though that do something very similar, such as CSS Modules.

To get started making the component, we first need to install Emotion into our project. I’m not going to walkthrough that stuff because it’s going to be different depending on your environment and setup. But once that’s complete we can go ahead and create a new component like this:

import React from 'react';
import styled from '@emotion/styled';

export const List = styled('ul')`
  list-style: none;
  padding: 0;
`;

This looks pretty weird to me because, not only are we writing styles for the

    element, but we’re defining that the component should render a

      , too. Combining both the markup and the styles in one place feels odd but I do like how simple it is. It just sort of messes with my mental model and the separation of concerns between HTML, CSS, and JavaScript.

      In another component, we can import this and use it like this:

      import List from 'components/list';
      
      <List>This is a list item.</List>

      The styles we added to our list component will then be turned into a classname, like .oefioaueg, and then added to the

        element we defined in the component.

        But we’re not done yet! With the list design, I needed to be able to render a

          and an

            with the same component. I also needed a version that allows me to place an icon within each list item. Just like this:

            The cool (and also kind of weird) thing about Emotion is that we can use the as attribute to select which HTML element we’d like to render when we import our component. We can use this attribute to create our

              variant without having to make a custom type property or something. And that happens to look just like this:

              <List>This will render a ul.</List>
              <List as="ol">This will render an ol.</List>

              That’s not just weird to me, right? It’s super neat, however, because it means that we don’t have to do any bizarro logic in the component itself just to change the markup.

              It was at this point that I started to jot down what the perfect API for this component might look like though because then we can work our way back from there. This is what I imagined:

              <List>
                <ListItem>Item 1</ListItem>
                <ListItem>Item 2</ListItem>
                <ListItem>Item 3</ListItem>
              </List>
              
              <List>
                <ListItem icon={<IconBusiness color="orange400" size="sm" />}>Item 1</ListItem>
                <ListItem icon={<IconBusiness color="orange400" size="sm" />}>Item 2</ListItem>
                <ListItem icon={<IconBusiness color="orange400" size="sm" />}>Item 3</ListItem>
              </List>
              
              <List as="ol">
                <ListItem>Item 1</ListItem>
                <ListItem>Item 2</ListItem>
                <ListItem>Item 3</ListItem>
              </List>

              So after making this sketch I knew we’d need two components, along with the ability to nest icon subcomponents within the . We can start like this:

              import React from 'react';
              import styled from '@emotion/styled';
              
              export const List = styled('ul')`
                list-style: none;
                padding: 0;
                margin-bottom: 20px;
              
                ol& {
                  counter-reset: numberedList;
                }
              `;

              That peculiar ol& syntax is how we tell emotion that these styles only apply to an element when it’s rendered as an

                . It’s often a good idea to just add a background: red; to this element to make sure your component is rendering things correctly.

                Next up is our subcomponent, the . It’s important to note that at Sentry we also use TypeScript, so before we define our component, we’ll need to set our props up first:

                type ListItemProps = {
                  icon?: React.ReactNode;
                  children?: string | React.ReactNode;
                  className?: string;
                };

                Now we can add our component that will size an component within the ListItem. If you remember from the example above, I wanted it to look something like this:

                <List>
                  <ListItem icon={<IconBusiness color="orange400" size="sm" />}>Item 1</ListItem>
                  <ListItem icon={<IconBusiness color="orange400" size="sm" />}>Item 2</ListItem>
                  <ListItem icon={<IconBusiness color="orange400" size="sm" />}>Item 3</ListItem>
                </List>

                That IconBusiness component is a preexisting component and we want to wrap it in a span so that we can style it. Thankfully, we’ll need just a tiny bit of CSS to align the icon properly with the text and the can handle all of that for us:

                type ListItemProps = {
                  icon?: React.ReactNode;
                  children?: string | React.ReactNode;
                  className?: string;
                };
                
                const IconWrapper = styled('span')`
                  display: flex;
                  margin-right: 15px;
                  height: 16px;
                  align-items: center;
                `;

                Once we’ve done this we can finally add our component beneath these two, although it is considerably more complex. We’ll need to add the props, then we can render the above when the icon prop exists, and render the icon component that’s passed into it as well. I’ve also added all the styles below so you can see how I’m styling each of these variants:

                export const ListItem = styled(({icon, className, children}: ListItemProps) => (
                  <li className={className}>
                    {icon && (
                      <IconWrapper>
                        {icon}
                      </IconWrapper>
                    )}
                    {children}
                  </li>
                ))<ListItemProps>`
                  display: flex;
                  align-items: center;
                  position: relative;
                  padding-left: 34px;
                  margin-bottom: 20px;
                	
                  /* Tiny circle and icon positioning */
                  &:before,
                	& > ${IconWrapper} {
                    position: absolute;
                    left: 0;
                  }
                
                  ul & {
                    color: #aaa;
                    /* This pseudo is the tiny circle for ul items */ 
                    &:before {
                      content: '';
                      width: 6px;
                      height: 6px;
                      border-radius: 50%;
                      margin-right: 15px;
                      border: 1px solid #aaa;
                      background-color: transparent;
                      left: 5px;
                      top: 10px;
                    }
                		
                    /* Icon styles */
                    ${p =>
                      p.icon &&
                      `
                      span {
                        top: 4px;
                      }
                      /* Removes tiny circle pseudo if icon is present */
                      &:before {
                        content: none;
                      }
                    `}
                  }
                  /* When the list is rendered as an <ol> */
                  ol & {
                    &:before {
                      counter-increment: numberedList;
                      content: counter(numberedList);
                      top: 3px;
                      display: flex;
                      align-items: center;
                      justify-content: center;
                      text-align: center;
                      width: 18px;
                      height: 18px;
                      font-size: 10px;
                      font-weight: 600;
                      border: 1px solid #aaa;
                      border-radius: 50%;
                      background-color: transparent;
                      margin-right: 20px;
                    }
                  }
                `;

                And there you have it! A relatively simple component built with Emotion. Although, after going through this exercise I’m still not sure that I like the syntax. I reckon it sort of makes the simple stuff really simple but the medium-sized components much more complicated than they should be. Plus, it could be pretty darn confusing to a newcomer and that worries me a bit.

                But everything is a learning experience, I guess. Either way, I’m glad I had the opportunity to work on this tiny component because it taught me a few good things about TypeScript, React, and trying to make our styles somewhat readable.

                The post How to Make a List Component with Emotion appeared first on CSS-Tricks.

Categories: Designing, Others Tags:

How to delete all node_modules directories from your computer

July 8th, 2020 No comments

Nice tip from Chris Ferdinandi:

My node_modules directories contained 50mb of stuff on the small side, and over 200mb of files in some cases. Over a few dozen projects, that really adds up!

Two dozen projects with 200 MB worth of node_modules? That’s nearly 5 GB of space for a bunch of stuff you’ve probably forgotten is even there, isn’t doing anything, and if you need again is a single command away. I feel like there should almost be a reaper app for these folders, deleting them if they haven’t been touched in a few weeks.

Nuke ’em:

# Mac/Linux
find . -name "node_modules" -type d -prune -print | xargs du -chs

# Windows
FOR /d /r . %d in (node_modules) DO @IF EXIST "%d" echo %d"

Direct Link to ArticlePermalink

The post How to delete all node_modules directories from your computer appeared first on CSS-Tricks.

Categories: Designing, Others Tags:

Creating Tiny Desktop Apps With Tauri And Vue.js

July 8th, 2020 No comments
Smashing Editorial

Creating Tiny Desktop Apps With Tauri And Vue.js

Creating Tiny Desktop Apps With Tauri And Vue.js

Kelvin Omereshone

2020-07-08T11:00:00+00:00
2020-07-09T03:35:13+00:00

Technology makes our lives better, not just users, but also creators (developers and designers). In this article, I’ll introduce you to Tauri. This article will be useful to you if:

  • you have been building applications on the web with HTML, CSS, and JavaScript, and you want to use the same technologies to create apps targeted at Windows, macOS, or Linux platforms;
  • you are already building cross-platform desktop apps with technologies like Electron, and you want to check out alternatives;
  • you want to build apps with web technologies for Linux distributions, such as PureOS;
  • you are a Rust enthusiast, and you’d like to apply it to build native cross-platform applications.

We will look at how to build a native cross-platform application from an existing web project. Let’s get to it!

Note: This article assumes you are comfortable with HTML, CSS, JavaScript, and Vue.js.

What Is Tauri?

The official website sums up Tauri well:

  • Tauri is a polyglot toolchain for building more secure native apps with both tiny and fast binaries. By “polyglot”, I mean that Tauri uses multiple programming languages. At the moment, Rust, JavaScript, and TypeScript are used. But there are plans to let you use Go, C++, Python, and more.
  • It lets you use any HTML and JavaScript-based front-end framework, such as Vue.js, React, or Angular, to build a native desktop app, and it can be integrated into any pipeline.
  • It helps you build and bundle binaries for major desktop platforms (mobile and WebAssembly coming soon).

So, basically, Tauri allows you to use web technologies to create tiny and secure native desktop apps.

On its GitHub page, Tauri is described as a framework-agnostic toolchain for building highly secure native apps that have tiny binaries (i.e. file size) and that are very fast (i.e. minimal RAM usage).

Why Not Electron?

A popular tool for using web technologies to build desktop applications is Electron.

However, Electron apps have a rather large bundle size, and they tend to take up a lot of memory when running. Here is how Tauri compares to Electron:

  • Bundle
    The size of a Tauri app can be less than 600 KB.
  • Memory
    The footprint of a Tauri app is less than half the size of an Electron app.
  • Licence
    Relicensing is possible with Tauri, but not with Electron. Electron ships with Chromium right out of the box. However, Chromium includes a digital rights-management system named Widevine. The inclusion of Widevine in Chromium makes apps created with Electron frowned upon by users of platforms such as PureOS for the sole reason that it is not free/libre open-source software (FLOSS). Platforms like PureOS are verified by the Free Software Foundation (FSF). This means that they can only publish free and open-source software in their app stores.

In a nutshell, if your app is built with Electron, it will never be shipped officially in the PureOS store. This should be a concern for developers targeting such distributions.

More Features Of Tauri

  • Security is really important to the Tauri team. Apps created with Tauri are meant to be secure from the get-go.
  • Tauri is compatible with any front-end framework, so you don’t have to change your stack.
  • It has many design patterns to help you choose important features with simple configurations.

Pros Of Tauri

  • Tauri enables you to take the code base you’ve built for the web and turn it into a native desktop app, without changing a thing.
  • Although you could use Rust in a Tauri-based project, it is completely optional. If you did, you wouldn’t need to change anything in your original code base targeted for the web.

Real-World Tauri

If you have been part of the Vue.js community for a while, then you’ll have heard of Guillaume Chau, a member of the core team of Vue.js. He is responsible for the Vue.js command-line interface (CLI), as well as other awesome Vue.js libraries. He recently created guijs, which stands for “graphical user interface for JavaScript projects”. It is a Tauri-powered native desktop app to visually manage your JavaScript projects.

Guijs is an example of what is possible with Tauri, and the fact that a core member of the Vue.js team works on the app tells us that Tauri plays nicely with Vue.js (amongst other front-end frameworks). Check out the guijs repository on GitHub if you are interested. And, yes, it is open-source.

How Tauri Works

At a high level, Tauri uses Node.js to scaffold an HTML, CSS, and JavaScript rendering window as a user interface (UI), managed and bootstrapped by Rust. The product is a monolithic binary that can be distributed as common file types for Linux (deb/appimage), macOS (app/dmg), and Windows (exe/msi).

How Tauri Apps Are Made

A Tauri app is created via the following steps:

  1. First, make an interface in your GUI framework, and prepare the HTML, CSS, and JavaScript for consumption.
  2. The Tauri Node.js CLI takes it and rigs the Rust runner according to your configuration.
  3. In development mode, it creates a WebView window, with debugging and Hot Module Reloading.
  4. In build mode, it rigs the bundler and creates a final application according to your settings.

Setting Up Your Environment

Now that you know what Tauri is and how it works, let me walk you through setting up your machine for development with Tauri.

Note: The setup here is for Linux machines, but guides for macOS and for Windows are also available.

Linux Setup

The polyglot nature of Tauri means that it requires a number of tool dependencies. Let’s kick it off by installing some of the dependencies. Run the following:

$ sudo apt update && sudo apt install libwebkit2gtk-4.0-dev build-essential curl libssl-dev appmenu-gtk3-module

Once the above is successful, proceed to install Node.js (if you don’t already have it), because Tauri requires its runtime. You can do so by running this:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.2/install.sh | bash

This will install nvm (Node.js version manager), which allows you to easily manage the Node.js runtime and easily switch between versions of Node.js. After it is installed, run this to see a list of Node.js versions:

nvm ls-remote

At the time of writing, the most recent version is 14.1.0. Install it like so:

nvm install v14.1.0

Once Node.js is fully set up, you would need to install the Rust compiler and the Rust package manager: Cargo. The command below would install both:

$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

After running this command, make sure that Cargo and Rust are in your $PATH by running the following:

rust --version

If everything has gone well, this should return a version number.

According to the Tauri documentation, make sure you are on the latest version by running the following command:

$ rustup update stable

Voilà! You are one step closer to getting your machine 100% ready for Tauri. All that’s left now is to install the tauri-bundler crate. It’s best to quit your CLI, and run the command below in a new CLI window:

$ cargo install tauri-bundler --force

Eureka! If everything went all right, your machine is now ready for Tauri. Next up, we will get started integrating Tauri with Vue.js. Let’s get to it!

Yarn

The Tauri team recommends installing the Yarn package manager. So let’s install it this way:

npm install -g yarn

Then run the following:

yarn --version

If everything worked, a version number should have been returned.

Integrating Tauri With Vue.js

Now that we have Tauri installed, let’s bundle an existing web project. You can find the live demo of the project on Netlify. Go ahead and fork the repository, which will serve as a shell. After forking it, make sure to clone the fork by running this:

git clone https://github.com/[yourUserName]/nota-web

After cloning the project, run the following to install the dependencies:

yarn

Then, run this:

yarn serve

Your application should be running on localhost:8080. Kill the running server, and let’s install the Vue.js CLI plugin for Tauri.

vue-cli-plugin-tauri

The Tauri team created a Vue.js CLI plugin that quickly rigs and turns your Vue.js single-page application (SPA) into a tiny cross-platform desktop app that is both fast and secure. Let’s install that plugin:

vue add tauri

After the plugin is installed, which might take a while, it will ask you for a window title. Just type in nota and press “Enter”.

Let’s examine the changes introduced by the Tauri plugin.

package.json

The Tauri plugin added two scripts in the scripts section of our package.json file. They are:

"tauri:build": "vue-cli-service tauri:build",
"tauri:serve": "vue-cli-service tauri:serve"

The tauri:serve script should be used during development. So let’s run it:

yarn tauri:serve

The above would download the Rust crates needed to start our app. After that, it will launch our app in development mode, where it will create a WebView window, with debugging and Hot Module Reloading!

src-tauri

You will also notice that the plugin added a src-tauri directory to the root of your app directory. Inside this directory are files and folders used by Tauri to configure your desktop app. Let’s check out the contents:

icons/
src/
    build.rs
    cmd.rs
    main.rs
Cargo.lock
Cargo.toml
rustfmt.toml
tauri.conf.json
tauri.js

The only change we would need to make is in src-tauri/Cargo.toml. Cargo.toml is like the package.json file for Rust. Find the line below in Cargo.toml:

name = "app"

Change it to this:

name = "nota"

That’s all we need to change for this example!

Bundling

To bundle nota for your current platform, simply run this:

yarn tauri:build

Note: As with the development window, the first time you run this, it will take some time to collect the Rust crates and build everything. On subsequent runs, it will only need to rebuild the Tauri crates themselves.

When the above is completed, you should have a binary of nota for your current OS. For me, I have a .deb binary created in the src-tauri/target/release/bundle/deb/ directory.*

Going Cross-Platform

You probably noticed that the yarn tauri:build command just generated a binary for your operating system. So, let’s generate the binaries for other operating systems. To achieve this, we will set up a workflow on GitHub. We are using GitHub here to serve as a distribution medium for our cross-platform app. So, your users could just download the binaries in the “Release” tab of the project.
The workflow we would implement would automatically build our binaries for us via the power of GitHub actions. Let’s get to it.

Creating The Tauri Workflow

Thanks to Jacob Bolda, we have a workflow to automatically create and release cross-platform apps with Tauri on GitHub. Apart from building the binary for the various platforms (Linux, Mac, and Windows), the action would also upload the binary for you as a release on GitHub. It also uses the Create a Release action made by Jacob to achieve this.

To use this workflow, create a .github directory in the root of nota-web. In this directory, create another directory named workflows. We would then create a workflow file in .github/workflows/, and name it release-tauri-app.yml.

In release-tauri-app.yml, we would add a workflow that builds the binaries for Linux, macOS, and Windows. This workflow would also upload the binaries as a draft release on GitHub. The workflow would be triggered whenever we push to the master.

Open release-tauri-app.yml, and add the snippet below:

name: release-tauri-app

on:
  push:
    branches:
      - master
    paths:
      - '**/package.json'

jobs:
  check-build:
    runs-on: ubuntu-latest
    timeout-minutes: 30

    steps:
      — uses: actions/checkout@v2
      — name: setup node
        uses: actions/setup-node@v1
        with:
          node-version: 12
      — name: install rust stable
        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          profile: minimal
      — name: install webkit2gtk
        run: |
          sudo apt-get update
          sudo apt-get install -y webkit2gtk-4.0
      — run: yarn
      — name: build nota for tauri app
        run: yarn build
      — run: cargo install tauri-bundler --force
      — name: build tauri app
        run: yarn tauri:build

  create-release:
    needs: check-build
    runs-on: ubuntu-latest
    outputs:
      RELEASE_UPLOAD_URL: ${{ steps.create_tauri_release.outputs.upload_url }}

    steps:
      — uses: actions/checkout@v2
      — name: setup node
        uses: actions/setup-node@v1
        with:
          node-version: 12
      — name: get version
        run: echo ::set-env name=PACKAGE_VERSION::$(node -p "require('./package.json').version")
      — name: create release
        id: create_tauri_release
        uses: jbolda/create-release@v1.1.0
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tag_name: ${{ matrix.package.name }}-v${{ env.PACKAGE_VERSION }}
          release_name: 'Release nota app v${{ env.PACKAGE_VERSION }}'
          body: 'See the assets to download this version and install.'
          draft: true
          prerelease: false

  create-and-upload-assets:
    needs: create-release
    runs-on: ${{ matrix.platform }}
    timeout-minutes: 30

    strategy:
      fail-fast: false
      matrix:
        platform: [ubuntu-latest, macos-latest, windows-latest]
        include:
          — platform: ubuntu-latest
            buildFolder: bundle/deb
            ext: _0.1.0_amd64.deb
            compressed: ''
          — platform: macos-latest
            buildFolder: bundle/osx
            ext: .app
            compressed: .tgz
          — platform: windows-latest
            buildFolder: ''
            ext: .x64.msi
            compressed: ''

    steps:
      — uses: actions/checkout@v2
      — name: setup node
        uses: actions/setup-node@v1
        with:
          node-version: 12
      — name: install rust stable
        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          profile: minimal
      — name: install webkit2gtk (ubuntu only)
        if: matrix.platform == 'ubuntu-latest'
        run: |
          sudo apt-get update
          sudo apt-get install -y webkit2gtk-4.0
      — run: yarn
      — name: build nota for tauri app
        run: yarn build
      — run: cargo install tauri-bundler --force
      — name: build tauri app
        run: yarn tauri:build
      — name: compress (macos only)
        if: matrix.platform == 'macos-latest'
        working-directory: ${{ format('./src-tauri/target/release/{0}', matrix.buildFolder ) }}
        run: tar -czf ${{ format('nota{0}{1}', matrix.ext, matrix.compressed ) }} ${{ format('nota{0}', matrix.ext ) }}
      — name: upload release asset
        id: upload-release-asset
        uses: actions/upload-release-asset@v1.0.2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ needs.create-release.outputs.RELEASE_UPLOAD_URL }}
          asset_path: ${{ format('./src-tauri/target/release/{0}/nota{1}{2}', matrix.buildFolder, matrix.ext, matrix.compressed ) }}
          asset_name: ${{ format('nota{0}{1}', matrix.ext, matrix.compressed ) }}
          asset_content_type: application/zip
      — name: build tauri app in debug mode
        run: yarn tauri:build --debug
      — name: compress (macos only)
        if: matrix.platform == 'macos-latest'
        working-directory: ${{ format('./src-tauri/target/debug/{0}', matrix.buildFolder ) }}
        run: tar -czf ${{ format('nota{0}{1}', matrix.ext, matrix.compressed ) }} ${{ format('nota{0}', matrix.ext ) }}
      — name: upload release asset with debug mode on
        id: upload-release-asset-debug-mode
        uses: actions/upload-release-asset@v1.0.2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ needs.create-release.outputs.RELEASE_UPLOAD_URL }}
          asset_path: ${{ format('./src-tauri/target/debug/{0}/nota{1}{2}', matrix.buildFolder, matrix.ext, matrix.compressed ) }}
          asset_name: ${{ format('nota-debug{0}{1}', matrix.ext, matrix.compressed ) }}
          asset_content_type: application/zip

To test the workflow, commit and push your changes to your fork’s master branch. After successfully pushing to GitHub, you can then click on the “Actions” tab in GitHub, then click on the “Check build” link to see the progress of the workflow.

Upon successful execution of the action, you can see the draft release in “Releases” on the repository page on GitHub. You can then go on to publish your release!

Conclusion

This article has introduced a polyglot toolchain for building secure, cross-platform, and tiny native applications. We’ve seen what Tauri is and how to incorporate it with Vue.js. Lastly, we bundled our first Tauri app by running yarn tauri:build, and we also used a GitHub action to create binaries for Linux, macOS, and Windows.

Let me know what you think of Tauri — I’d be excited to see what you build with it. You can join the Discord server if you have any questions.

The repository for this article is on GitHub. Also, see the binaries generated by the GitHub workflow.

(ra, il, al)

Categories: Others Tags:

Eye Vs AI: Harnessing Technology to Successfully Track User Attention

July 8th, 2020 No comments

Attention is the new gold; brands are in a constant competition for our attention.

A big portion of our time we spend online, where we are bombarded with insane amounts of information and advertisements. It’s hard not to become overwhelmed in this world of consumerism. We have had to become good at quickly evaluating which information is important, especially on the internet.

Good marketing specialists know that they have mere seconds to turn a potential customer into a lead. People are not going to spend a lot of time examining your advertisement or landing page, either it clicks or not. Moreover, most users do not read the articles, they scan them. First impression plays a huge role in the success of your business, so do not leave that to a chance.

You really don’t want your customer to ignore that special sale, subscription option, or another call to action on your webpage. That is why you need to know where that gold-worthy attention goes when a user opens your landing page. Here’s where technology can come in handy.

Eye-Tracking in Web Design

It is very important to know where your website visitor’s attention goes first. How to get that info? Eye-tracking is the answer.

Eye-tracking technology can be used to optimize your website conversions. By tracking eye movements, technology will recognize which content is most intriguing for the users. It will reveal whether people pay most attention where you want them to, which elements are distracting or not visible enough, and where sales are lost. This information is invaluable if you want to succeed in the current market.

This information is invaluable if you want to succeed in the current market

How does it work? An eye tracker, such as webcam or goggles, measures movement of an eye. Collected data is analyzed and presented as a heatmap, highlighting which elements of your design attract most attention. Having in mind that browsing time rarely exceeds a few seconds, this information is very valuable when you try to understand your audience.

You wouldn’t want to spend much time on your website design just to discover it does not generate desired conversion rate. By employing this technology you can make changes based on reliable data rather than intuition and guarantee your business future success.

By now you may think that you definitely need to carry out this eye-tracking study, but there is a catch. A high-quality behavioral observation or eye-tracking is a time-consuming, budget eating complicated process.

If you want to draw conclusions from heatmaps, you would need to include at least 39 participants in a study. One individual test may last from 20 minutes to an hour. Time quickly adds up when you include preparation and analysis of the results. The average eye tracker price is around $17,500 and it may vary between several thousand dollars and $50 000. Of course you can hire a company to carry out this research for you but it may cost you several hundred dollars a month. Luckily, technological innovations allow us to acquire the same insights about users’ attention flow much cheaper and faster than conducting or buying an actual eye-tracking study.

Technological innovations replace real eye-tracking study

AI-Powered Automatization of Eye-Tracking

In this task of understanding how internet users are interacting with your website, Artificial Intelligence (AI) seems to be an answer. AI-based technologies already have become prevalent in various services we use on a daily basis. For example, Netflix’s highly predictive algorithm offers viewers personalized movie recommendations. Medical researchers utilize eye tracking to diagnose conditions like Alzheimer’s disease or Autism. As these algorithms become better every year, AI also becomes an irreplaceable tool in business.

Over the years researchers have collected so much data that human behavior becomes really predictable

How can AI help you to understand your customer’s attention? The main feature of AI is that it can mimic human intelligence and constantly improve itself by learning from data. Predictive eye-tracking is based on deep learning and trained with previous eye tracking study data. Over the years researchers have collected so much data that human behavior becomes really predictable. Technology predicts which specific areas of your website attract most interest. In this way, AI enables you to speed up the UX research process and get insights about your design in a matter of seconds.

Too good to be true? There are already several available tools on the market, such as Attention Insight or EyeQuant. These predictive design tools are based on deep learning and trained with previous eye-tracking studies data. Up to date, they have achieved an 84-90% accuracy.

AI-powered attention heatmap

AI solutions for designers and marketers have already become major competitors to traditional eye-tracking studies. Due to active competition, predictive eye-tracking tools are constantly innovating and recently started generating heatmaps for videos. Another useful feature that provides decision-makers with quantitative data is a percentage of attention. Users can define an object that they want to test and get an exact percentage of attention that the object receives.

Conclusion

Since all digital products are competing for user’s limited attention, it has become one of the most valuable resources. Due to fierce competition, it is not enough to rely on your intuition and gut instinct while making important decisions anymore. Designers have a choice in this economy of attention, though.

Yes, there are eye-tracking studies that require a significant amount of time and financial resources.

However, you can make user-centric, data-driven decisions in a quick, scalable, and private way while your product is still under development. AI-powered predictive eye-tracking tools might be an answer. Attention is a new currency, and you must measure it.

Source

Categories: Designing, Others Tags:

Email Marketing Productivity: 9 Tips For Success

July 8th, 2020 No comments

Email marketing has been around for a long time, and with a good reason. It’s an effective method of generating, nurturing, and converting leads into loyal customers.

Email marketing also enables you to consistently reach out to your customers. As long as your subscribers are getting valuable content, influencing them to buy from you would be easy.

Why email marketing still matters

Considering that 99% of consumers check their email every day, email marketing is still one of the best communication channels. It also converts better and generates an ROI of 4200%, which is a lot higher than that of social media.

And if this doesn’t sound convincing, here are a few more stats showing the effectiveness of implementing email marketing strategies:

Implementing email marketing tactics in your business offers a lot of benefits. Some of the advantages include:

Saving time and budget

Email marketing is cheaper than most mainstream marketing channels. It requires no printing or postage costs, except when investing in automation or tracking software.

Boosting revenue and traffic

Using email is excellent for maximizing impulse buying. With its help, you can drive higher sales as compared to other marketing strategies, as well as generate leads faster and more effectively. Besides, including relevant links in your email content can help drive targeted traffic to your website.

Improving customer relationships

Email marketing makes it easy to engage and involve your subscribers with your brand. It’s also important in providing value to your audience and gradually driving the user to a final buying stage.

Positively affecting brand recognition

With its help, you can develop a solid brand identity. Email marketing connects you directly with the customers’ inbox. Providing value is the key to standing out among other competitors.

Reaching the right people at the right time

You can segment your list and send emails depending on this email segment to generate the desired conversion.

How to boost email marketing productivity

Focus on personalization

Email personalization deals with sending targeted content to your subscribers by taking advantage of specific information about them. Personalizing emails helps increase email open rate by 26% and increase email revenue by 760%. Personalization shows your subscribers that you care about who they are and your achievements together.

Take a look at how Grammarly and Mint do this:

The first step to successful personalization is collecting relevant data about your audience by offering a valuable product or information. It will then be used to create a personalized email message. This goes beyond using someone’s name in the subject line. It involves creating engaging content that addresses their pain points, objectives, and desires.

Automate for better result

Email automation involves sending a transactional or promotional email to your subscribers based on specific events or triggers. For example, you can send a welcome email after a customer joins a mailing list:

Or you can send a reminder to a client who has a product in their cart without checking out:

Automation runs in the background and handles repetitive tasks, which creates more time for other valuable goals. Of course, it doesn’t mean that the content would be boring, ineffective, or generic. Advanced automation can be highly convertible, personalized, and filled with engaging content.

Write short emails and test subject lines

Long emails waste not only your time but also the time of your audience. To increase productivity, learn to write letters that are brief and straight to the point.

The ideal email length is between 50 to 125 words, as such letters have a response rate that is above 50%. Emails with the highest click-through rate have about 20 lines of text and up to 200 words. So, it’s better to keep your copies short and below 200 words.

The subject line of your email plays an important part in your open rate. Therefore, deciding on shortcodes to use in your subject lines is one of the efficient ways of increasing your email productivity.

Make sure your email list is clean

A clean email list is required to achieve peak performance for your email marketing campaign. Email verification can help discover and remove invalid addresses, increase your deliverability, and improve sender reputation. Also, users who constantly validate emails experience higher conversion rates, lower bounce rates, and more accurate email statistics.

An unsubscribe link is another important solution that can help avoid being marked as spam. With its help, you can keep your audience happy and create a healthy email list.

Use segmentation and email preferences

In email segmentation, you divide your mailing list based on specific conditions and similarities to send relevant messages to a targeted group of people. It helps you turn mass emails and email blasts into a more logical and specific process.

Segmentation can be based on the users’ behavior, interests, geographical location, buying history, age, gender, and other factors. You can also add an “update your email preferences” link to let your subscribers choose what kind of content they want to receive.

For example, these are options that Zapier offers:

Perform A/B testing

The main objective of A/B testing is to optimize your email marketing metrics, increase engagements, and improve conversion rates. You can discover the type of emails that are more engaging and converting after sending two different types of letters to your audience.

Typical elements that can be A/B tested in your email campaign are your email subject lines, content, personalization, design, preview text, sending time and frequency, CTAs, and so on. A/B testing is about creating assumptions about any of these elements and performing a test to validate them. The best results can then be used to improve and launch better email campaigns.

Track and analyze your results

One major advantage of email marketing is the ability to track everything from the opens, clicks, and location. Tracking the performance of email campaigns will enable you to focus on more effective strategies, compare them with other marketing channels, and prioritize your time accordingly.

Besides, marketers need to go beyond measuring just the traditional KPIs such as the number of subscribers, opens, clicks, and delivery rates. It’s important to also consider long-term subscriber activity, the health of email lists, as well as optimization and engagement trends, to get the most from your marketing strategy.

Get the time and frequency right

The time and frequency of your email sending have a lot of impact on your open and unsubscribe rates. Studies have shown that the first letter often has the highest open rates. But the more you launch your email campaigns, the higher open rate can be generated.

Of course, you can’t just send more emails. The best time for generating a positive response from your mailing list without seeing a rise in unsubscribes is every two weeks. However, it’s important to test and discover the perfect time and frequency that works best for you.

Ensure emails are mobile-friendly

Sending mobile-friendly email campaigns is no longer a choice, it’s a necessity. About 68% of email recipients view their emails on a mobile device. Therefore, it’s important to consider the appearance of your email on all devices to avoid missing out on the possibilities of engaging a considerable number of your subscribers that will generate results.

What you can do:

  • Shorten your subject line (mobile devices don’t display more than 25 to 30 characters as opposed to 60 characters on a desktop)
  • Use images as optional since some mobile devices don’t display them
  • Don’t forget to test across all devices to make sure your email displays correctly before launching your campaign
  • Place your call-to-action at the center close to the top to enable the on-the-go audience to discover it quickly. This is how Airbnb places it:

Wrapping it up

Productive email marketing requires time, effort, and most importantly, an effective strategy. It goes beyond creating a message and hitting the “send” button. It requires maintaining a healthy email list and ensuring that your audiences are happy with your offers.

Email marketing is still one of the most effective ways to grow your business. And integrating automation can help generate results without spending too much time working on them repeatedly.


Marketing vector created by stories – www.freepik.com

Categories: Others Tags:

Ways Big Data Teams Can Leverage DevOps Solution Automation

July 8th, 2020 No comments

Several changes are seen in the IT architecture as Big data is rolled out within the system, especially big data teams to handle such a vast amount of information.

Today DevOps procedures are implemented throughout the software development cycle to collect more actionable insights from unstructured data. And DevOps automation is one of the significant keys that can streamline the product development for enhanced productivity. The activity of such nature reduces the risk of losing time which is the most essential in the world of business.

With the emergence of 5G and IoT, big data is now a reality as businesses are looking to secure maximum information to assist them in decision making. Cuelogic is a leading DevOps service provider for global businesses to assist big data teams by effectively incorporating DevOps Automation.

Here are the 5 ways Big data teams can efficiently leverage the DevOps automation for benefiting their organizations.

Build a Systematic platform

Big data organizations need a more stable, sophisticated, and manageable environment for multiple teams of developers and operators to work on the same project. Here DevOps automated systems can help organizations with a more collaborative environment. DevOps provides that additional agility and flexibility for businesses to discover more opportunities instantly. Especially when building large and new complex products, these platforms assist with the complete software development cycle. These DevOps solutions offered by DevOps solution providers can accurately identify, plan, design, build, test, and deploy new products with more reliability.

Hera a System must be able to adapt to the changes when presented with new data. Artificial Intelligence algorithms play a major role in altering their operations to meet the organization’s goals and objectives. They can quickly bring more insights, trends, and patterns for businesses to use efficiently.

Streamlining operational procedures

Today, Big data can have sizes of around petabytes 250 bytes or one thousand million million data information. So, these DevOps automation becomes the foremost criteria for organizations to shorten the mundane tasks by incorporating streamlined workflows and thus, assisting professionals to quicken the pace to get a more structured date from the unorganized information. Similarly, several testing processes are also automated to find bugs and issues for fixing instantly.

Overall the focus should be to streamline the whole process for the software development lifecycle (SDLS). Slow results can impact the progress of the organization while too fast results can bring bugs on release. So this balance of speed with quality solutions is a must. Especially for developing new products, this DevOps automation can bring more optimized results. Continuously delivering new products can be quite complex as quicker solutions are demanded without compromising on the quality factor.

Seamless integration from multiple teams

Big data projects are huge, making it impossible for a single business to cover all the important aspects of the organization. And one of the key challenges of Big data is to organize the efforts of hundreds of professionals working remotely for helping businesses to get more actionable insights. Herewith DevOps automation can even group these vast amounts of information to develop strategic plans and projection into the future by prioritizing the key factors for success and vertical growth. So, working in this collective environment is easy and more purposeful with DevOps automation.

Several platforms offer this transparency and accessibility to manage this large data environment such as JFrog with artefact repository for combining cloud and on-premises infrastructure.

Uncover bottlenecks and their solutions

In managing Big data, several organizations face certain issues or problems affecting their performance. DevOps automation can help you discover these potential bottlenecks and then build solutions to further refine the process for more productivity. DevOps services focus on collaboration from each team member and easily streamline the mundane tasks to pave the path for quick development as well as pinpoint the success factors for optimized performance. Big Data teams provide a lot of actionable insights for businesses to use in their strategic planning.

The key point in this DevOps success lies with continuous monitoring and continuous improvement. The system is always looking to improve from its current situation and further smooth the business operations in bringing more profits for the organization.

Implementing Uniform Standards through the System

All organizations look for uniformity and a specific level of quality control in their procedures. And generally, it is one of the biggest challenges to maintain this consistency throughout the whole cycle. As thousands of professionals work together on the same project, a lot of variable practices result in inconsistencies. With DevOps automation, organizations can follow and implement uniform standards across complex projects for better productivity.

Here consistency is crucial to lowering the error percentage in business operations thus keep delivering at a higher potential.

Awareness, Transparency, and Adaptability

DevOps can seamlessly build data transparency while still following security protocols by promoting data locally near the team. With DevOps, organizations can build a centralized collaboration environment, thus closing the gap between the developers, project managers, security, and even the IT operators. This transparency in the DevOps procedures helps to bring more productivity and drive innovation for continuous improvement.

With a huge amount of data coming from the inter-connectivity of devices in IoT, organizations have to be more adaptable to handle various streams of data simultaneously. DevOps automation eases the path for organizations to understand unstructured data efficiently and discover hidden patterns to further refine the development cycle by self-assessing.

Conclusion

DevOps automation is one of the main factors in handling Big Data as organizations face several challenges in handling multiple teams, remote collaboration, constant releases, and maintaining optimum performance. Though the process looks quite simple and easy, in real-time, it is full of complexities as big data requires constant improvisation in the complete software development cycle.

Organizations are always looking for smarter solutions, and these benefits highlight the reason for big data companies to follow the DevOps process and automation. Professionals nowadays are continuously searching for more optimized solutions with huge demand for big data and data analysis in the market.


Photo by You X Ventures on Unsplash

Categories: Others Tags:

Displaying the Current Step with CSS Counters

July 7th, 2020 No comments

Say you have five buttons. Each button is a step. If you click on the fourth button, you’re on step 4 of 5, and you want to display that.

This kind of counting and displaying could be hard-coded, but that’s no fun. JavaScript could do this job as well. But CSS? Hmmmm. Can it? CSS has counters, so we can certainly count the number of buttons. But how do we calculate only up to a certain button? Turns out it can be done.

Thanks to Jan Enning for emailing in about this trick, it’s very clever!

HTML

It doesn’t have to be buttons; it just needs to be some sibling elements we can count. But we’ll go ahead and use buttons here:

<div class="steps">

  <button class="active">Shop</button>
  <button>Cart</button>
  <button>Shipping</button>
  <button>Checkout</button>
  <button>Thank You</button>

  <div class="message"></div>

</div>

The empty .message div there will be where we output our step messaging with CSS content.

CSS

The trick is that we’re actually going to use three counters:

  1. A total count of all the buttons
  2. A count of the current step
  3. A count of how many remaining steps are after the current step
.steps {
  counter-reset: 
    currentStep 0 
    remainder 0 
    totalStep 0;
}

Now let’s actually do the counting. To count all buttons is straightforward:

button {
  counter-increment: totalStep;
}

Next, we need another thing to count that will also count the buttons. We can use a pseudo-element that’s only purpose is to count buttons:

button::before {
  content: "";
  counter-increment: currentStep;
}

The trick is to stop counting that pseudo-element on all the elements after the active element. If we’re using an .active class that looks like this:

button.active ~ button::before {
  /* prevents currentStep from being incremented! */
  counter-increment: remainder;
}

We’re counting the remainder there, which might also be useful, but because we’re only incrementing the remainder, that means we’re not counting the currentStep counter. Fancy, fancy.

Then we can use the counters to output our messaging:

message::before {
  content: "Step: " counter(currentStep) " / " counter(totalStep);
}

Here it is!

CodePen Embed Fallback

There is a little JavaScript there so you can play with moving the active state on the button, but the counting and messaging is all CSS.

The post Displaying the Current Step with CSS Counters appeared first on CSS-Tricks.

Categories: Designing, Others Tags:

WooCommerce on CSS-Tricks

July 7th, 2020 No comments

I always get all excited when I accomplish something, but I get extra excited when I get it done and think, “well, that was easy.” As much as I enjoy fiddling with technology, I enjoy reaping the benefit of well set-up technology even more. That’s why I still get so excited about WordPress — I feel so powerful being able to accomplish big things without a huge amount of time and effort.

I had that exact feeling this past month when I was getting WooCommerce set up here on CSS-Tricks (again).

Lemme show you how I’ve got it set up, because I bet there are plenty of you who could do the same thing and make even more use of this setup than what I’m doing!

WooCommerce Powered Membership

Let’s say you want to have a membership site. Perhaps you have a fitness website and you make training videos and you build a membership paywall for pages that display those videos and training regiments. Or perhaps you have a cooking website, and paid members have access to additional features, like saved shopping lists.

Having a system for paid members is a foundational concept for making money online, and is typically no small task. Fortunately, WooCommerce makes quick work of it. Aside from the (free) WooCommerce plugin, you’ll need the ($199) WooCommerce Memberships plugin.

If you’re eying up some paid plugins for WooCommerce, you might circle July 21st on your calendar. That’s WooCommerce Day and there are going to be some big sales.

Once you have that installed, you’ll see a Memberships tab within your WooCommerce area in the WordPress admin. In there is a Membership Plans area where you can set up your plans. We have a very simple one-plan setup: CSS-Tricks Member.

You could have a whole variety of plans if you like (e.g. bronze, silver, gold).

These plans don’t do anything all by themselves just yet —they are just user roles, and the access control stuff comes later. You could make these plans such that only admins can add people to them, that anybody can register for them for free, or that they require the purchase of a product to join. That last one is the useful one for an eCommerce setup!

As a side note, you’ll probably want to limit the time length of the membership. You could make it unlimited, but it’s probably smarter to start with memberships that expire after a set time so you aren’t promising things for life.

Since I’m selling memberships, I’ve tied the Membership Plan to the sale of a product: MVP Supporter.

Buy this product, activate subscription, activate membership

The way to get access to that membership plan is to purchase this product. You’ll also always be able to manually add people to plans as an admin.

This product could have been a one-off charge, which supports the idea of an unlimited length membership, but like most memberships in the world, I wanted to set it up as a recurring billing product. That means we need a little additional setup.

Subscriptions to Memberships

I found this a tiny bit confusing. You might assume a membership plugin would support the idea of recurring billing for that membership, but it doesn’t do that out of the box. We need a second plugin for that: WooCommerce Subscriptions.

The subscription plugin is another $199, making this setup just shy of $400. That’s it for upfront costs though — you only need to renew the licenses next year if you need support and updates (I would). I find that cost to be more than fair for a system that works this efficiently, but you’ll have to do the business math for yourself.

Once you have that plugin installed, any product you create has the possibility of being a subscription product.

Here at CSS-Tricks, we’re charging $20/year for the membership. When someone signs up, they’ll be re-charged the next year at $20. That matches the length of the membership plan, which is an important step. Nothing forces you to do that but it would be weird to place a charge on a different date from the actual renewal.

Membership-Only Access to Posts

Wwe’ve done the two biggest parts of setup:

  1. Created a Membership Plan
  2. Created a product people can buy that subscribes them to that plan

Now for the part that actually gives the members some benefit! I am planning to sell access to a “book” that’s hosted on this site. The book is actually just a collection of posts. They are Custom Post Types we’ve set up called “Chapters.” In the editor for the chapter, below the content, there will be a Memberships area you can use for locking the chapter to a Membership Plan.:

This is in the post editor, underneath the post content.

Again, this example uses a Custom Post Type, but it could be any page or post type at all! It’s literally the flip of a switch to put something behind the membership wall.

There are two “faces” of a post with a content restriction:

  1. What members see: the content
  2. What non-members see: an excerpt and message on how to unlock the content

I think that’s a nice system. It shows people exactly what they could be reading if they were a member and shows them exactly how they can become a member.

Now there is some custom CSS happening here, but not much! I just use the default features, see what gets output onto the page, and there is always a sensible class name to hook onto to do styling — just how it should work.

Doing Things Programmatically for Members

In our case, the primary benefit to being a member is probably gaining access to the book, but it doesn’t have to stop there. I think giving as much as possible to a paying member is generally a good idea. And since advertising is the primary business model on this site, it seems fair to remove those ads if you have a paid supporter membership.

There are all kinds of APIs for these plugins to hook into whatever you need, but I like to keep things as simple as I can. For example, in any template, I can check to see if you’re a member or not.

<?php if ( !wc_memberships_is_user_active_member() ) { ?>
  <div>
     <!-- Show an ad if you're not a member. -->
  </div>
<?php } ?>

I also do this before I run any other of the site’s JavaScript, so I can know in the JavaScript if a user is a member or not.

<?php if ( wc_memberships_is_user_active_member() ) { ?>
    <script>
      window.activeMember = true;
    </script>
<?php } ?>

Some of the ads on this site are JavaScript-powered, so I can wrap the call for them in a !window.activeMember logic to not request them at all.

On-Demand Printing & Fulfillment

Memberships and subscriptions are just two of the things I’m doing with WooCommerce. The other is selling physical products, which is something I’ve dabbled in over the years. In fact, we used to hand-fulfill each and every order by taking products to the post office! We’ve also partnered with fulfillment companies in the past, but we still had to physically print up a bunch of inventory ahead of time.

Things have come a long way since then and there are lots of companies that print on demand! One such company (and I have no affiliation with them) is Printify. They sell all kinds of stuff, including what you’d expect from a printing company: t-shirts, hoodies, mugs… and the best part for me is that it connects directly to WooCommerce.

So far, we’ve stocked the store with posters! On the Printify side, I pick the product, upload the art, choose some options, and that’s that!

The last step in the process is to “Publish product to your WooCommerce store” which has worked perfectly for me so far. I trust that it works, as it must be forming the connection between Printify and WooCommerce such that Printify receives the order and fulfills it when they come in.

From there, the products appear on my site and I can edit or customize them from WordPress if I need to (like the copy and such):

Products in my WooCommerce admin

I can check orders at any time and watch as they are ordered, produced, prepped, and shipped:

Order dashboard on Printify

I ordered some posters myself, of course, so I could try it out before putting it in front of other people. The poster came in a nice triangular tube thing in perfect condition on thick bright white paper. I hung it right up next to my office computer:


Mobile App

If you’re like me and get excited to look at how your little store is doing and get notifications for sales, there is a mobile app.

I haven’t had the need to update order statuses or manage reviews and the like, but that’s all in there too.


There is a lot of technology at work here!

But my actual time commitment has been minimal. I’ve spent longer writing this blog post than I have setting up all of this eCommerce stuff. I’m just an integrator here. I’m not inventing anything — just taking advantage of some best-in-class software to make my ideas happen.

The post WooCommerce on CSS-Tricks appeared first on CSS-Tricks.

Categories: Designing, Others Tags:

Improving Chromium’s browser compatibility in 2020

July 7th, 2020 No comments

This is exactly what I love to hear from any browser vendor:

When it comes to browser compatibility, there are still too many missing features and edge-case bugs. But it doesn’t have to be this way. Things can and will get better, if browser vendors can understand what is causing the most pain, and take action to address the causes. In Chrome we’re doing our best to listen, and we’re doing our best to address what we’re hearing. We hope it helps, and we’re looking forward to a more compatible 2021.

I love the nod to that super clever div that looks different in every browser. This is a solid list from Stephen McGruer. My favorite:

Like Flexbox, CSS Grid is an important component of modern layout. Looking at the early survey results it seems like the story for CSS Grid support in Chromium is fairly good (we have our friends from Igalia to thank for that!). There is one clear exception – Chromium still doesn’t support subgrid.

Hopefully, it won’t be an exception for much longer. It’s still early days, but I’m excited to share that a team at Microsoft Edge are working on rearchitecting Chromium’s Grid support to use the new LayoutNG engine – and as part of this are intending to add subgrid support!

Not that anyone should relax, but I think right now is probably the best level of browser compatibility we’ve ever seen.

Direct Link to ArticlePermalink

The post Improving Chromium’s browser compatibility in 2020 appeared first on CSS-Tricks.

Categories: Designing, Others Tags:

Email Marketing

July 7th, 2020 No comments
email marketing

Remember when your mailbox was inundated with postcards, mail order catalogs, and flyers advertising sales?

Not too long ago, snail mail was the best way to reach prospective customers or clients, but that’s gradually changing as more people rely on email to get work done, exchange ideas, and communicate with one another quickly.

email marketing

A 2019 study by The Radicati Group found that close to 3.9 billion people worldwide — more than half of the world’s population — use email for personal or business reasons.

If this upward trend continues to grow by 3 percent each year, more than 4.3 billion people will be using email by the end of 2023.

You need an email address to create all kinds of accounts, from social networking sites and software solutions to loyalty programs and online banking services, but it’s clear that email is growing as a popular form of communication.

In fact, The Radicati Group study estimates that the more than 293.6 billion emails exchanged each day in 2019 will grow by 4 percent each year and exceed 347.3 billion by the end of 2023.

For businesses of all sizes, this stable growth in email usage presents an opportunity to reach more people in more places.

Since people receive so many emails each day, they are particular about which ones they read. But there’s a good chance that they’ll take action immediately after seeing a message about a sale, new product, or even the latest blog post from a thought leader.

Quite a bit of strategy goes into creating, building, and maintaining an effective email marketing campaign.

Getting people to read an email that’s marketing your products or services is only half the battle. You’ll want to know how many people opened an email and what they clicked on. You also need to master the art of grabbing their attention within seconds, avoiding their spam filters, and creating customized messages that stand out among competitors. There are even ways to analyze a marketing campaign’s potential success by sending out different versions of an email.

That may sound like a lot to digest, but this step-by-step guide to email marketing will touch on all of these points and more. We’ll explore

  • The definition of email marketing
  • Why email marketing is important
  • The benefits of email marketing
  • Creating and executing an email marketing strategy

Crafting an effective email marketing campaign requires time, creativity, and planning, but the gains you earn can be significant over time. Engaging email content can not only motivate people to take action but also turn them into loyal customers, clients, or users.

What is email marketing?

Before venturing too deep into the weeds, let’s define email marketing.

Email marketing involves sending emails to external stakeholders, such as clients, customers, or business partners. These messages typically provide promotional or educational content and encourage people to take some sort of action, whether it’s to buy a product or donate to a cause.

promotional email

Marketers define email marketing as a digital strategy that uses email to reach people who are existing or potential customers. Email gives marketers the ability to reach people almost anywhere. They can interact with their target audience, promote their business, and, above all, drive sales or web traffic to their company.

As people spend more time online and carry out daily tasks there, it’s becoming increasingly important for businesses to have some sort of digital presence. A user-friendly website and social media account used to be enough, but those are now staples for almost any business. The same can be said of marketing campaigns, which historically consisted of print advertisements and direct mail strategies, such as postcards, brochures, and letters.

Nowadays, businesses should have a visually appealing website that works well on desktops, laptops, and mobile devices. They also need accounts on several social media platforms where they post engaging content. Marketing campaigns should also consist of some digital strategies, including online advertisements and — you guessed it — email marketing.

Why is email marketing important?

Good question. Here are a few answers.

There’s a high likelihood people will see your message

Research has shown that checking emails is becoming a regular routine for many adults in the United States.

A 2018 study by digital marketing company Fluent found that 81 percent of Americans check their personal email at least once a day. Of the 2,667 survey participants who had a work email address, 74 percent of them said they check it a few times each day.

ckecking email

Although there’s no guarantee people will read your email, connecting with them on a platform they use each day is a good idea. And, as surprising as it may seem, there’s also a good chance that people will open your email.

The Fluent study found that 49 percent of people open marketing emails at least sometimes. The remaining 51 percent said they either never or rarely open marketing emails. Almost 50-50 odds is good enough to make creating relevant, engaging, thoughtful, and attention-grabbing content a cornerstone of your digital strategy.

Email marketing is becoming a must-have strategy for businesses

Companies need some sort of email marketing strategy to keep up with the times — and competitors.

An annual report from Salesforce found that 74 percent of senior marketing leaders use email marketing to reach existing and prospective clients. Another 21 percent of the 4,100 marketing leaders surveyed said they would integrate email marketing into their workflows within the next year.

Even though businesses see the value of social media platforms as marketing vehicles, it’s clear that email marketing isn’t going anywhere.

In fact, email marketing even secured a slight lead in the Salesforce study over social advertising and publishing, which is projected to be used by 94 and 91 percent of marketing leaders, respectively, by the end of 2019.

Email marketing provides a high return on investment

On the whole, email is the most cost-effective marketing medium compared to other options, including social media marketing.

A 2018 report from the Data & Marketing Association, a trade organization for marketers, found that companies spent an average of $10.23 on email marketing campaigns to acquire a single paying customer. By comparison, it would take about $21.95 in social media campaigns and $27.35 in direct mail marketing, respectively, to secure a paying customer.

You can send a message to your intended audience in a number of ways. The methods you use should be determined by your budget, the nature of your business, and how people want to hear from you.

Above all, it’s important to select communication channels that your customers use regularly and that will generate a positive response from them, whether it’s to buy a new product or read a new company blog post.

Benefits? Yeah, we got ’em

These are just a few of the benefits that give email marketing an edge over other alternatives, such as social media, direct mail, and search engine marketing (SEM):

benefits of email marketing
  1. Emails don’t contribute directly to paper waste. That seems like a no-brainer, but you may be surprised to hear how many pieces of direct mail, such as postcards or letters, are processed and delivered each year.

    The Print Industries Market Information and Research Organization estimates that 77.9 billion pieces of direct mail — except catalogs — were sent out in 2014, a 16.3 percent drop from 93.1 billion in 2008.

    It doesn’t take a statistician to realize that’s a lot of paper, and not all of it is filed away or thrown into recycling bins.

    Direct mail suppliers have made strides to reduce their environmental impact, such as adopting sustainable sourcing practices and supporting reforestation efforts, but at the end of the day, there’s no way for marketers to control where all of that paper goes.

    People can always print the marketing emails they receive, but they usually do so for a good reason. They may, for instance, want to print out a coupon or details about an offer as a reference during their visit to a store.

    Direct mail can sometimes complement your digital marketing efforts, especially if you need to reach large groups of people, but the costs to carry out both strategies can add up and ultimately limit a campaign’s overall effectiveness.

  2. Email is cheaper than other marketing channels. By and large, there’s very little doubt among marketers that email is the cheapest way to reach out to existing or potential customers.

    According to the Data & Marketing Association report from 2018, securing a paying customer through direct mail or social media advertisements is more than twice as expensive as email marketing.

    Advertising on search engines and websites or applications will generally cost businesses an average of $21.50 and $19.50, respectively, to secure a paying customer. The Data & Marketing Association report notes that the overall return on investment hovers around 25 percent for search engine marketing and 18 percent for display marketing. Email marketing, meanwhile, generates a 122 percent return on investment for businesses.

  3. Emails allow you to create targeted appeals for specific audiences. People are gravitating to marketing campaigns that are less generic. With email, marketers can make relevant pitches based on key insights about their target audience, such as where they live or what they’ve bought in the past.

    This practice, called market segmentation, can be expensive or difficult to achieve with digital and direct mail marketing, which typically relies on a single message to jibe with a broad group of people.

    You may, for example, want people to buy a new product, but it’s likely that your pitch to existing customers will be different from the one you’d give to people who know little about what your business offers in the first place.

  4. Emails can be personalized quickly and inexpensively. With a wide range of companies vying for attention from many of the same people, it’s becoming increasingly important for companies to craft marketing messages that align with the behaviors of their intended audience.

    Personalization goes beyond market segmentation to take into account individual behaviors and characteristics, as opposed to demographic and other group characteristics. Whereas market segmentation is based on marketers’ needs, personalization is based on consumers’ needs.

    Like market segmentation, personalization can be costly with digital or direct mail marketing campaigns. In both cases, you must come up with a meaningful pitch, create design assets for it, put up some money, and wait until ads are published or distributed before determining whether they’re resonating with people.

    Email marketing campaigns, on the other hand, are cheaper to carry out. If you want certain groups of people to receive different messages, you can create separate email distribution lists, draw up unique designs for each email, and write content for each one based on the unique needs of your customers, clients, or buyers. You can also autopopulate the recipient’s name in each email.

  5. Emails are easy to analyze and change quickly based on data. There are a number of ways to gauge how well a specific marketing campaign is performing on a number of communication channels.

    If you’re using an email marketing automation platform that can send out emails and analyze who’s interacting with them, you can tell if your emails are getting the results you want.

    Before launching the entire campaign, you can run an A/B test by sending out at least two variations of the same email with slight changes to each one, such as different subject lines or design elements. This low-cost testing method allows you to see how your emails resonate with a portion of your overall target audience.

    The results, in turn, allow you to refine your email marketing strategy and select which email the rest of your target audience will receive.

    In practice, email A/B testing doesn’t require you to spend a lot of money before you can tell whether your email marketing campaign is on the right track. Not so for advertising, whether print or online.

    You have to pay to run an ad before determining whether it’s working or not. And though digital marketing provides valuable information about people who interact with an advertisement, changing an ad isn’t easy or quick.

    Making edits to a search engine, display, or social media marketing campaign can take time, since ad platforms, such as Google, Facebook, Instagram, and Bing, must vet and approve content before it can go live.

Creating and executing your email marketing strategy

Once you’ve decided to roll out an email marketing campaign, putting together a game plan will help you carry out your ideas effectively and stay on the right path. Your strategy should be comprehensive and cover everything from creating engaging content to mobile-friendly design elements that help your message stand out.

email marketing strategy

At the same time, your plans should be flexible so you can test which type of emails work best, analyze the results, and use those findings to adjust your approach. This could mean rethinking who your target audience is, reprioritizing content, and modifying how your emails are written or designed to make them more appealing.

Creating an email marketing strategy can be tedious, but it will help you organize your ideas and channel your energy toward targeted goals.

Here are a few things to keep in mind when you’re developing an email marketing campaign:

  1. Follow best practices when writing emails.
  2. Craft and send emails that target specific groups of people.
  3. Get to the point and personalize your message.
  4. Create customized emails that display well on mobile devices.
  5. Use email marketing software to save time.
  6. Conduct A/B tests to see what sticks.
creating an email strategy

Follow best practices when writing emails

When it comes to email marketing, the devil is in the details.

Even if your emails are visually appealing and look great on any computer or mobile device, it won’t matter if people ignore or discard your message once it lands in their inbox.

Investing effort into your content and following some time-tested methods that actually entice people to open your emails will ensure your message reaches your target audience.

Above all, knowing how to write emails like a marketing pro will help you establish a good rapport with your target audience and motivate them to take action, whether it’s to check out a flash sale, participate in a contest, or try out a new product or feature.

If done right, your emails could turn prospective leads into regular patrons, users, visitors, clients, customers, or even fervent fans.

Here are a few quick and dirty tips on how to write a marketing email that can deliver results:

  • Choose wisely when determining whose name — a person, business, or organization — should appear in the “from” line. This may seem like a trivial detail in the grand scheme of things, but it’s actually more important than you might expect.

    A 2016 survey of 1,361 U.S. adults by Fluent and email marketing platform Litmus, found that 42 percent of all respondents looked at the sender or “from” name in an email before deciding whether to open it.

    This suggests that people look for names they know and trust while filtering through their emails. It’s also no secret that the prevalence of phishing scams and spam emails have led people to be more careful about what they open.

    Using a reputable name as the sender of a marketing email reduces the chances that your message will be deleted or end up in someone’s spam folder.

    Choosing a name and email address that are familiar to your target audience is an important step in getting their attention. This could mean using the name of your company or a well-known person in your organization that an email recipient will recognize immediately.

    from line of JotForm newsletter

    You could even lean on your company’s brand recognition or reputation to reach your target audience.

    email from line

    As a general rule, it’s also important for the email address and name in the sender field to match so your target audience won’t mistake your message for spam.

    That said, you should try to avoid using a “no-reply” email address for marketing emails. No-reply addresses can be disregarded as spam or overlooked. It also gives people the impression that you don’t want to hear from them. This strategy can backfire when people have support-related questions and need an easy way to contact you. Replying to you directly is easier than searching for contact information buried in the body of your email.

    There are always exceptions, though. For instance, you could use a “no-reply” email address or get away with having a sender name and corresponding email address that don’t match if people have signed up for regularly scheduled product updates, newsletters, or promotions from your company.

  • Create a catchy email subject line. The subject line of your email is like the headline of an article or blog post. It tells readers why they should care about what you have to say and what they can expect from you. Great subject lines are usually written in active voice and avoid adverbs.

    The 2016 survey by Fluent and Litmus found that 34 percent of the 1,361 respondents initially looked at the subject line of an email when deciding whether or not to open it.

    That same survey, however, also found that 54 percent of all respondents said they’ve felt cheated, tricked, or deceived into opening an email based on its subject line.

    This means the subject line of each email serves as a promise between you and your target audience. It’s important for these people to see your message and take action, but if you mislead them, they may either ignore future emails from you or mark you as spam.

    Email subject lines should accurately summarize your intended message so you can establish some credibility off the bat and build on it over time. Making subject lines relevant, pithy, and descriptive will not only make your message easy to read but also allow your target audience to decide whether it may benefit them.

    Subject lines carry a lot of power because they can motivate people to take action immediately, even if they don’t actually open an email and read it. As counterintuitive as that may sound, the 2016 Fluent and Litmus survey found that 35 percent of all respondents visited a company’s brick-and-mortar store or website after receiving a marketing email but not opening it.

    In a similar fashion, 33 percent of all survey respondents said they bought something from a business after receiving a marketing email but not opening it.

    Perhaps there’s some rhyme and reason after all behind those emails that declare “Your pick-up-in-store order is ready for pickup” or “Don’t delay — Save 50 percent today only.”

  • Highlight direct benefits for readers to grab their attention quickly. It’s easy to assume people won’t dedicate a lot of time to filter through their emails, but research by Litmus has found that this belief may be more of a misconception.

    In fact, Litmus’s analysis of billions of opened emails found that the average time people spent reading emails increased by nearly 7 percent between 2011 and 2016, from 10.4 to 11.1 seconds. This average increased to 13.4 seconds in 2018, when Litmus conducted a follow-up analysis of 10 billion opened emails.

    Perhaps more surprising is that the percentage of emails read for more than 18 seconds rose to 44.4 percent in 2016 from 38.4 percent in 2011. By 2018, 61 percent of emails were read for more than 8 seconds.

    The most important benefits for readers should appear in the top half of an email, or above the fold, to grab their attention. It may be tempting to cram as much information as possible into that space, but Litmus’s findings suggest that people will read longer emails with relevant, meaningful, and engaging content. That means you should develop momentum at the beginning of your email and keep readers engaged with your content until the very end.

  • Use images or graphics to complement your message. There’s a reason for the saying, “a picture is worth a thousand words.” Photos, images, and interactive graphics can make the reading experience more enjoyable and aesthetically pleasing for your target audience.

    In some cases, these visual design elements can convey your message to readers without relying too much on text to do the heavy lifting. This can be particularly helpful since marketers have seconds, not minutes, to capture a reader’s attention.

    There is, however, a caveat to this strategy: Too many photos, images, or graphics can increase the amount of time that it takes for an email to load.

    Delays that last longer than two seconds can convince people to close an email and either ignore or delete your message. Reducing the size of the photos, images, and graphics in your email and conducting tests on multiple devices should ensure that your message loads properly.

  • Use bullet points for emails with a lot of text. Since people often read emails quickly, bullet points should highlight the most important information. Bullet points are effective in email because they stand out and can grab a person’s attention immediately.

    Even if someone scans through an email, they can still glean enough information to make an informed decision. The key, however, is to keep your bullet points brief and start each one with an action verb.

  • For longer emails, break up your content into manageable chunks. Emails with a lot of text can make your target audience feel like they’re reading a college research paper. This can be particularly problematic since it likely takes longer for people to order and pay for a cup of coffee than read an email.

    If you’ve already trimmed down the amount of text in an email, try dividing the remaining text into sections with subheads, bullet points, images, or video files. This strategy will make your message more engaging, easier to read, and less daunting.

    Determine whether infographics, instructional videos, or other visual aids can replace some of your written content. Using these elements will allow you to get your point across without bogging readers down with blocks of text.

  • Include clear, direct, and succinct calls to action. A call to action, often abbreviated as CTA, is a prompt that asks your target audience to do something specific.

    Although it’s typically placed at the end of an email, a CTA can also appear at the end of each section in an email. This strategy is particularly important when you’re introducing several topics and asking your target audience to carry out different actions for each one.

    As an example, a newsletter with sections about a flash sale, an ongoing contest, and a new product will likely have a CTA in each one, asking readers to see what’s on sale, participate in the contest, and check out the new product.

    In many cases, a CTA is a command button or hyperlink in a sentence that encourages readers to do something, whether it’s to read a blog post, watch a video, or upgrade their account.

    A CTA within a command button should contain only a few words, be written in active voice, and clearly explain what you want people to do. Sentences with a CTA, meanwhile, should highlight the value, timeliness, usefulness, or importance of the desired action.

    command button CTA from JotForm newsletter
    CTA hyperlink in a sentence

Craft and send emails that target specific groups of people

There was a time when businesses could get away with crafting generic messages to successfully reach a broad range of people. These days, traditional one-size-fits-all emails will likely end up in someone’s spam folder, and you may lose these current or potential customers altogether.

You can cut through the white noise and make your message stand out by dividing your email subscribers into smaller groups based on a wide variety of factors, such as geographic location, income, job title, and previous purchases or interactions with your business.

Once you do that, you can craft messages that cater to a group’s specific needs, wants, or interests. This process, called email segmentation, allows you to share relevant information with all of your email subscribers and outline benefits that they can actually use.

A 2017 analysis by Mailchimp found that campaigns were more effective when businesses separated email subscribers into smaller segments and developed unique messages for each group. The in-house analysis covered 2,000 Mailchimp users who used the platform’s email segmentation tools and collectively sent about 11,000 campaigns to almost 9 million people.

The results of these campaigns were markedly different than ones carried out by Mailchimp users who didn’t employ email segmentation.

The analysis looked at key metrics that gauge the success of campaigns, including total open rates, which track the total number of times an email was opened or reopened, and click rates, which measure how often at least one link in an email was clicked.

Mailchimp found that total open and click rates for segmented campaigns were 14.31 and 100.95 percent higher than those that were unsegmented, respectively. Unique open rates, which track how many individual recipients opened an email, were 10.64 percent higher for segmented campaigns than those that were unsegmented.

Unsubscribe rates, which monitor how often people removed themselves from an email subscription list, were 9.37 percent lower for segmented campaigns, compared to unsegmented ones.

Get to the point and personalize your message

People get dozens of emails each day, so it’s no wonder they quickly scan through a message and discard it in a matter of seconds. The same can be said for traditional, direct mail alternatives, which were long seen as the best way to connect with people on a personal level.

As more businesses turn to email as a cheaper and arguably more effective marketing tactic, software solutions are developing ways to personalize messages intended for different groups of people.

A 2018 Salesforce report found that 72 percent of consumers and business buyers worldwide expect vendors to personalize engagement efforts to their unique needs. Of the 6,723 people who participated in the double-blind survey, 84 percent said the key to winning them over is to treat them like a person, not a number.

The bottom line is that email personalization is now an essential marketing strategy. Here are a few general tips on writing emails that speak directly to your target audience:

  • Craft content around your target audience’s behaviors and interests. This is generally a good practice since it’s now possible to track how customers — or prospective ones — interact with a business online and in person.

    For instance, you can use loyalty programs to track a customer’s purchases, as well as how and when they take advantage of certain services or products. You can then use this data to determine what kind of promotions, notifications, offers, or other content certain people will receive.

    As this level of email personalization becomes more common, people increasingly expect businesses to direct relevant information, products, services, and offers their way based on what they want or need.

    The Salesforce report found that 70 percent of survey respondents felt it was important for businesses to understand how they use products and services. Another key factor for 59 percent of survey respondents was seeing engagement efforts tailored around their past interactions with a business.

    Targeted email marketing campaigns that leverage data about existing or prospective customers will not only provide them with engaging, helpful, and relevant information but also allow you to become a reliable resource.

  • Include the names of people in your marketing emails. Addressing people by name is a time-tested strategy that can forge or reinforce a personal connection between a business and its customers. In some cases, it gives readers the impression that your email was written just for them.

    This strategy, however, depends on the relationship you’d like to have with your target audience and vice versa. There are also instances when your target audience may not expect this level of personalization. An email promoting a flash sale may not need to address someone by name since the message is broadly intended for all loyalty program members.

    You can test whether this method works for your business by sending out separate emails — one with a person’s name and one without it — to a small portion of your target audience and see if it has a measurable impact on open and click rates.

  • Consider including a P.S. at the end of your email. This traditional writing practice, formally known as a postscript, has been around longer than emails, but it can still be useful when you want your message to include a personal touch.

    Since it essentially serves as a final appeal to your target audience, a P.S. can underscore why customers should take action immediately, provide an enticing offer that could push them to take action, pitch a final important key benefit, or showcase a customer success story that demonstrates value.

    If you use a P.S. in an email, it should be quick and snappy, no more than a few sentences.

Create customized emails that display well on mobile devices

There was a time in the not-so-distant past when people could only check their emails on their desktops or laptops.

But with smartphones and tablets, you can now check your emails almost anywhere. As a result, these mobile devices have gradually reshaped the way people access, view, and respond to their emails.

A Litmus analysis of 10 billion opened emails from 2018 to 2019 found that 42 percent of emails were opened on mobile devices.

Since most people access and read emails on mobile devices, marketers must adapt by ensuring their messages can be viewed on any computer, smartphone, or tablet.

If mobile-friendly emails aren’t incorporated into an email marketing strategy, a business’s messages may fall on deaf ears.

A 2016 survey by Litmus and Fluent found that 43 percent of the 1,107 U.S. adults who responded said they marked promotional emails as spam because they didn’t display or work well on their smartphones.

Of the 1,212 people who responded to another survey question, 51 percent said they unsubscribed from a brand’s promotional emails because the emails or website didn’t display well on their smartphone.

To that end, there are several different design approaches that marketers can take to create mobile-friendly emails:

  1. Mobile-aware design. This particular approach employs best practices to ensure that email loads and displays well across a wide range of screen sizes, especially those on smartphones.
  2. More specifically, mobile-aware emails typically adhere to at least three key principles:

  • Building narrow emails by stacking content and design assets on top of each other to create a single column. Two-column sections can also be built into the layout to break up the content, highlight products, or drive viewers to a website for more information.
  • Using large text, images, and buttons that will look nice on a smartphone.
  • Spreading out the amount of space between links and buttons so it’s easy to click on them.
  • Responsive design. Responsive design allows the layout of an email to change based on the device, orientation, and platform used to view it. This is done by rearranging an email’s design elements based on the screen size of the device the viewer is using.

    This type of approach, however, is a little more complex because it requires some knowledge of CSS, a coding language used to define the layout of an email, including the font size, font color, image size, page orientation, and order of sections.

    In the case of emails with responsive design, a CSS technique, called media queries, detects the screen size of a device and makes the appropriate style or layout changes based on preset conditions and size limits for specific elements.

    The problem is that these emails generally require some planning and testing to ensure everything looks nice on mobile devices and computers.

  • Hybrid design. Hybrid email coding, also known as spongy coding, is very similar to the responsive design approach and was championed at a time when some email clients, such as Yahoo! Mail and Gmail, didn’t support media queries.

    Rather than enabling different styles when screen sizes reach a specific threshold, hybrid design elements are set and adjusted based on changes to the area around them. Emails, in turn, are restricted to a maximum width so elements don’t appear too large on desktops and laptops.

    Although hybrid email coding will allow you to send messages that display and work well in any email client, it’s also time-consuming when you want to design a complex email layout that covers more than two columns.

  • Use email marketing software to save time

    Trying to do email marketing all on your own can be tedious and exhaust your resources.

    Investing in email marketing automation tools will cut the amount of time you need to carry out campaigns that can help you raise money, drive sales, convert prospects into customers, convince people to take action, and build awareness around your products and services.

    Email marketing automation services, including Constant Contact, Mailchimp, and HubSpot, can be particularly helpful if you plan to roll out more than just a few campaigns or send segmented ones with a series of emails.

    Email marketing automation tools can streamline the process by helping you build an email list, manage it, and segment users. Once you create the designs for each email, write the content, and determine when you want to send the emails, these platforms can send targeted messages at specific times or when people conduct certain actions.

    The best part is that many email marketing automation platforms have reporting tools that provide key insights, such as open and click rates, so you can gauge whether or not your campaign is working as it should. This data can also empower you to make informed decisions and strategic changes to your campaign quickly.

    With email marketing platforms, you no longer need to send individual marketing emails, keep track of when specific people should receive follow-up messages, and measure the overall progress of your campaign manually.

    Data-collection tools like JotForm can supplement these efforts by providing email marketing platforms with the information needed to build or kick off a campaign, such as names, email addresses, interests, and preferences.

    Native integrations, or connections through third-party integration tools, allow information to flow seamlessly from a data-collection tool to an email marketing automation platform. This process creates a frictionless workflow so you don’t need to manually copy information from one place and paste it into another.

    Conduct A/B tests to see what sticks

    Your email marketing platform should allow you to see which messages resonate with your target audience. This is especially helpful when you can’t seem to pick a clear winner from your options.

    You may, for instance, want to promote two great products but can’t decide which one should take precedence in the subject line and body of your email.

    Or let’s say you’re planning to run a flash sale during an upcoming holiday, offering two particular promotions that should appeal to your customers — 50 percent off of everything in-store and a $10 credit for every $25 spent.

    Which promotion should appear at the top of an email that’s going out to everyone who signed up for exclusive deals from your business? It’s a tough decision that could impact how many people read your email, visit your website, go to your store, and ultimately buy something.

    In this case, A/B testing should make your decision a little easier, since you can send two versions of a message to a small sample of your target audience. Although the content and design elements should be similar, each email should prioritize different promotions in the subject line and body of the message.

    For a little more context, let’s say you select 20 percent of your overall audience to receive emails as part of the A/B test. Half of those people, or 10 percent of your overall audience, will receive an email called Version A, which highlights the 50-percent discount. The remaining people, the other 10 percent of your overall audience, will receive a different email called Version B, which promotes the $10 credit for every $25 spent.

    With the help of email marketing automation platforms, you can then analyze key metrics, including open, click, and bounce rates, that will help you determine whether people are opening your emails, taking the time to read them, clicking on hyperlinks, and spending time on your website.

    Email A/B testing does take some time, but it helps you to nail down a message that can really resonate with people and prompt them to take action. At the end of the day, the strategic changes that you make to your email marketing campaign can drive sales, signups, website visits, web page views, and brand awareness.

    Just to be clear, here’s a breakdown of the A/B methodology:

    Version A: This is the unaltered, or original, version of your email without any changes. This email, sent to your control group, will serve as an established standard and be compared against a new version of your email that has all the changes you’d like to make.

    Version B: This email includes all the changes that you have in mind. Your A/B test will compare interactions with this email — sent to your experimental group — to similar interactions with your original, unaltered email.

    Use these tips to ensure that your results are as accurate as possible:

    • Set clear objectives, and make predictions to get started. Like any scientific experiment that you conducted in high school or college, it’s important to create a hypothesis and determine which metrics matter the most before running your test. This allows you to establish clear expectations and compare them against the results of your A/B test. More important, these basic steps help you set up the test correctly to produce the best results.

      There is, however, a key caveat that you should take to heart. It’s best to have an open mind and not make any assumptions about your target audience before conducting an A/B test. That’s because preconceived notions may make it easier for you to overlook valuable yet counterintuitive insights that arise from your experiment.

    • Identify who should participate in the A/B test. Limit your test to a small portion of your overall target audience so you can get the most statistically accurate results. Although the size of this group should be small, it should also be large enough to divide in half so you can test the two versions of your email — version A and version B.

      As an example, an A/B test aimed at 30 percent of your overall target audience should be divided in half, so 15 percent will receive version A, and the remaining 15 percent will receive version B.

      You should choose a test group based on strategic factors, such as geographic location, industry, level of interest in your business, or type of customer. Regardless of which or how many factors you consider, they should be consistent throughout your test because any changes may generate inaccurate data and make it difficult to draw definitive conclusions.

    • Control key variables when running your tests. While setting up your experiment, ensure there’s an equal chance that anyone in your test group will receive either Version A or Version B. Randomizing which people receive Versions A or B will generally decrease the likelihood that unrelated variables will taint your results.

      In many cases, you should isolate a single element that you want to test in the two emails, such as an image, content, a call to action, a design element, or the subject line. Doing this will help you tie test results to specific changes in an email. Although a test with changes to multiple elements can work, it will be more difficult to determine which one will have the most significant impact.

      Since emails display differently on desktops and mobile devices, there’s a chance that this may affect your test results, especially open and click-through rates. For example, when your emails look good on desktops but not mobile devices, key metrics may be skewed if a disproportionate number of people receive Version A or Version B and try to read it on their mobile devices. Creating emails that display well on both mobile devices and desktops should ensure key metrics, such as open and click-through rates, aren’t impacted by the devices people use to access your emails.

    • Set up a reasonable time line for your test. When it comes down to it, the duration of your test should be just right to generate results that are as accurate as possible.

      If you run a test that’s either too short or too long, you may either base important decisions on incomplete data or encounter issues that could undermine the integrity of your data.

      While experiments on web pages can last for days, weeks, or months, it generally takes no more than two days to complete an email A/B test and declare a winner, especially if there are only two variants — a control and challenger — to test.

      The duration of your test, however, will vary based on several key factors, including the size of your email list, the percentage of email subscribers included in your test, your desired conversion rate, and your current conversion rate.

      To save you some time, several software solutions offer free online tools that can help you determine the length of your email A/B test, including

      Some benchmarks that determine the length of your test are subjective and will likely align with the goals that your team — or company as a whole — wants to achieve. You should work with your team and key stakeholders in your company to establish clear goals and expectations before setting up an A/B test.

    • Don’t stop a test just because the results are statistically significant. Although software tools can determine how long a test should run, the decision to pull the plug ultimately rests in your hands.

      But when should you stop an A/B test? Is it when you see the statistical significance level in your A/B testing tool inching closer to 100 percent?

      Statistical significance is achieved when there’s high confidence that the patterns observed in your A/B test aren’t happening by chance. Statistical significance is an important metric to monitor when you’re running your experiment, but it shouldn’t be the deciding factor in stopping your A/B test.

      As a general rule, the chance of having incorrect findings should be no higher than 5 percent — this means there should be at least a 95-percent chance that your findings are correct.

      The size of your test group also needs to be large enough for your results to be statistically significant. There are free sample size calculators that can help you determine the size of your email A/B test group, including

      But if you stop a test just because your results have reached a statistically significant point, there’s a chance that your analysis may be based on incomplete data. This could, in effect, lead you to draw inaccurate conclusions and formulate faulty recommendations.

      The key here is stopping your test once your email variations have been sent out to your entire test group, especially if you’re sending out your emails in phases over a period of hours or days.

    • Don’t make changes in the middle of your test. After spending the time and effort to set up an email A/B test, it’s important to take a hands-off approach and let the experiment run its course.

      Changing anything, including the test settings and the design of any of the emails, will erode the integrity of your test, pollute your data, and perhaps lead to outcome bias.

      Even reallocating the number of people who receive each variation during your email A/B test will skew your results and produce results that are inconclusive at best.

    • Conclusion

      Email marketing can seem like a daunting, time-consuming, and frustrating task, and let’s be honest, sometimes it is. But if you put some effort into it, and you’re willing to learn by trial and error, the seeds you sow today will allow you to reap benefits over time. That ultimately translates to gaining more customers, users, clients, sales, and subscriptions without making a huge dent in your marketing budget.

    Categories: Others Tags: