How we Activate New Users with Email

Onboarding new users. It's a big deal. But it's not just an in-app exercise. Too often, software builders view "onboarding" as exclusively an in-app exercise. While building a good onboarding tutorial/flow inside the app is important, it's not enough to convert new users into active users.

The real key guessed A good onboarding email flow is absolutely essential.

@SamuelHulick says it briliantly in his post on life cycle emails:

"Unless your product is eyebrow-raisingly basic, there's a very, very good chance that a new user won't get to experience all the value you have to offer in their very first sitting."

In his post, Samuel does a great job defining the value of lifecycle emails, so I don't need to repeat that here. What we wanted to do with this post is outline the process we went through to build out our own 'activation' email flow in the hopes of helping you design a beautiful activation flow of your own.

What is an 'activation' email flow?

You can call them whatever you want - onboarding emails, lifecycle emails, etc - we just happen to call them 'activation' emails because the term is consistent with our goal for these emails.

The goal of these emails is very simply, to help convert new sign-ups into 'active' users.

Every app is unique - so every app will have a different definition of an 'active' user. But for us, an active user is one who sends a 'real' email (versus a test email) to his/her users through Knowtify.

So...our goal is to get every new user (or a very high % of new users) sending real emails to their users via Knowitfy as quickly as possible.

Building out our activation email flow

As with any good user engagement effort, this was a team effort for us - a collaborative effort between Customer Success, Design & Engineering.

The steps we took to build out this initiative looked something like this:

  1. Map out and understand our "activation funnel"
  2. Build out email paths that would coorespond with that flow
  3. Create copy and design emails
  4. Iterate
  5. Let 'em fly!

Like any creative process, our actual process wasn't as clean as this list might suggest, but it's fun to dream :)

Step One:

It was important for us to start this process by defining our activation funnel - in other words, the steps/stages that a user must pass through in order to become 'active'. It is the answer to the question:

What activities do my users need to take in order for us to consider them an 'active user"?


At what point do I consider my users 'hooked' to my app?

Every app is different, but a basic activation path would look something like this:

For us, it looks like this:

New User Signup >> Create email >> Integrate data/Add Contacts >> Send first real email >> ACTIVE USER!

Once we had this foundation, we could start to frame out the emails we should be sending - as well as the rules that would trigger their delivery - to facilitate this path.

Step Two:

This was the real meat of our planning process. This is where we started to map out what emails we need to send in order to meet our goal of driving new users to activation. The two big decisions we had to make at this stage were:

  1. What emails should we be sending; AND
  2. When should we be sending them

We used a work flow visualization tool (Lucidchart - great piece of software) to map out these paths. This is how our flow looks on paper:

I know this looks a bit crazy, but don't run away screaming just yet :)

It's actually just a basic flow chart.

  • We have a timeline of 'days since signup' across the top to help visualize the timing of the flows.
  • Each square in the chart represents an email that a user will receive.
  • Each diamond in the flow represents an 'inflection point' - a question about the user's activity. These questions align with the major steps in our activation funnel from Step 1).

  • Did the user signup?

  • Did the user create an email?
  • Did the user add contacts/integrate data?
  • Did the user send a real email?

The answer to each question determines the next step in that user's email path.

For example, after a user signs up, we ask the first question - "did the user create a real email?" If the answer is yes, the user moves onto the "Yes" track and receives an email about integrating contacts - encouraging him/her to move ahead to the next step in the activation funnel.

If, however, after 3 days, the answer to this first question is "no" - then the user moves down to the "No" path and receives an email about how easy it is to create emails in Knowtify.

If after 9 days, the user still hasn't created a real email, he/she will receive another email in the "No" path. And so on.

I won't go though the rest of the flow in detail, but you can see that at each major step of our Activation Path, we have a question:

Every question has a "Yes" and "No" path until he/she reaches the end of a path.

If the user becomes an active user and reaches the end of the Yes path, he/she will receive a congratulatory email:

At the end of any "No" path, a user is added to a long-term "nurther" track (not shown in the email flow in this post).

Setting rules to trigger emails

Obviously, this flow is dependent on trigger rules defined by a user's behavior in our app. There were two main factors that we took into account when setting these rules: ACTIVITY and TIME.

Time vs Activity
We designed our flow so that as soon as a user passes one of our activity milestones (created an email, integrated data, sent email, etc), we automatically trigger the next email in the flow. This means that all the YES path emails are triggered by specific activities that determine the passing of a milestone. These are NOT based on time.

BUT if a user does not pass an activity milestone, we send a NO path email after a specific period of time.

For example...if has created an email, but hasn't added contacts into the system after 10 days, he/she is entered into the NO path and will reveive the emails related to that path. Same goes with the other activity milestones.

Basically - users follow our YES paths based on their activity and our NO paths based on time (days since signup) and lack of activity.

Getting specific with our activity milestones

Another thing we invested time into was carefully defining each of our activity milestones. We could have easily defined each activity milestone with very shallow behaviors (for example - if the user simply clicked on the "New Email" button, we could have considered that an "email creation" milestone). But we wanted to get a lot more specific about the activity that defined these milestones so that we could identify users who were conducting these activities with real intent vs those who were just playing around.

We defined the first step in our path ("Created Email") as a user who had edited at least 3 sections of an email in our email designer.

We define the next step in our funnel ("Added Contacts") as a user who had added at least 10 new contacts. Less than this would indicate that it was someone just playing around without real intent on using the platform.

The next step ("Sending a Real Email") was defined as the delivery of at least 50 emails. We've seen that users that send more than 50 emails become real users for us. Below that could be a user just sending a bunch of test emails/goofing around.

List out specs of each email

As we were buidling out our activation email flow, we started a list of all the emails we were planning and the details of each. This became a very important document as we iterated on our plan (and for when we actually started executing on our emails). Our list looked like this:

In this doc, we listed out:

  • The number of each email (we had them numbered on our flow chart)
  • The name of each email
  • Email description
  • Summary of the content of each email
  • The rules defining when the emails should be sent
  • Then we added two columns to track our progress in execution (a column for Done? and a column for Live?) - these were super helpful as we collaborated on the writing and designing of the emails.

This document was some overhead to build and manage, but it turned out to be super helpful. We highly recommend it.

The Content Track

As we were bulding out our flow, we realized that we had some more strategic pieces of content that would be very helpful for early users, but that didn't fit naturally in this flow. They were more high-level pieces (like 5 Emails the Best Apps Send to Their Users) that would help users think more strategically.

So...we created a new path. We pulled these pieces out and give them their own track that would run in parallel with the main email flow. With this track, users would receive emails with this strategic content at specific intervals after signing up.

Step Three:

Once we had a flow and a list of the emails with which we were happy, we started building out the emails (in Knowtify, of course).

This was definitely an interative part of the process - testing copy, visual designs, icons; altering our flow when necessary; etc.

While this certainly represented the meat of the work on this project, it was also the most fun.

Building an email in Knowtify
Step Four:

Finally...the last thing we did was to print out each email and stick our whole flow up on the wall. I know this is a terrible picture, but, trust me, it looked good in person :)

Hanging the whole flow on the wall really helped us to see our flow with actual, designed emails. It helped us get a better feel for what our users would be seeing and gut check it.

It was only once we had the emails up in the wall did we see that:

  • some of our the design elements between emails needed to be more consistent;
  • a couple of our emails were just too damn long;
  • one of our "No" paths was too short, so we added another email to it;
  • the timing of some of our decision inflection points didn't feel right;
  • and a few other small things needed some more work;

So, we make a bunch of tweaks after seeing the flow laid out "in real life". And then we were ready to go! Which meant it was time to...

Step Five:

Once we felt happy with the flow & the email designs, the only thing left was to turn them on...which we did.

Measure results

As mentioned, this activation email flow is all about activating (a) more users, (b) faster. So that is what we will be measuring. We will be looking at the number of users who were activated (as a percentage of signups) before and after this flow was activated as well as the average time between signup and "activation" of those activated users.

We will write a follow-up post when we have enough data to justify it. But from just the little data we've had so far, the results are promising...

Iterate, iterate, iterate

Obviously, we have made a big investment in this activation email program, it is still very much a work in progress. It will change as we look at the engagement data, it will change as we learn more about what our users care about most, it will change as our app develops and more features are released, it will change as we tweek the in-app onboarding, and it will change as we get more and more feedback.

This was the first step in this process...certainly not the last :)

We hope this has helped you think about your own activation email flow. If you ever need help or would just like to chat about any of your emails, we'd love to chat.


For those interested, here are the emails that make up our current Activation flow:

Thanks for hanging out. Hope it was helpful!