Tutorial: Real time dynamic Personalization with Adobe Target

Adobe Target is part of the Adobe Experience Cloud. It can be used for A/B Testing and Personalization of Websites, Apps and Server Side Applications. This article describes how it can be used to create dynamic Experiences based on the user profile and mbox parameters.

Personalization is not a feature, it’s obligatory

Some years ago, the internet was not more than a collection of static pages. It was perceived as the worlds largest library, so websites were created the same way as a library: Books don’t change their content over time, or react to the reader. Much like in a library, search indices like Google helped to navigate the web and find the best content.

Over time, websites started to make better use of what computers are capable of. Animated images and blinking text rivaled for the user’s attention. If you got an email a human voice would tell you about it. And once you create an account on a forum it would greet you with your username. The internet got personal.

Today companies like Google, Netflix or Amazon base their business around personalization even more. They collect data on their user’s behavior to deliver more relevant content. More so, most products now have so much content that personalization is required to not overwhelm the user and make the portfolio feel relevant.

Personalization solves another problem companies with a large portfolio have: Data on the user’s behavior helps with the need for content curation. Instead of manually choosing which content should be promoted, algorithms decide what is most relevant to each and every user. Every customer has their very own experience with the product, tailored to their needs.

With personalization so ubiquitous it has become an unconscious expectation that businesses need to meet. Products need to feel personal now. Missing out on this development will lead to lost business due to lower user engagement and loyalty.

Adobe Target for real time personalization

So, let’s teach Target how to help us to engage our users. It uses a concept called mboxes, which deliver content to the browser or app, and parameters, which contain information about the page or user. For example, we can tell target the username of the current user and which page they are looking at. Information that is given about the user is appended to it’s profile, which persists over multiple requests for the current user.

In a browser, we can request data for a mbox (called “DemoBox” in this example) and attach information about the request (look at the “name_of_page” parameter) and the current user (“profile.username”) like this:

adobe.target.getOffer({
  "mbox": "DemoBox",
  "params":{
     "name_of_page":"Profile Page",
     "profile.username": "Uber CRO" 
  },
  "success": function(offer) {
    console.log("Result: "+JSON.stringify(offer));
  },
  "error": function(status, error) {
    console.log('Error', status, error);
  }
});

On a website with Target implemented, we can just execute this in the browser console. Since we don’t have an Activity in Target yet, we only get an empty array back:

Next, we head over to Target and create a new activity with the Form Editor. As location, we use “DemoBox” (like above) and create new HTML Content with this code:

Test content!
Username: ${profile.username}
Page Name: ${mbox.name_of_page}

This code retrieves the parameters from the User Profile and the current mbox. The complete Experience now looks like this:

Go ahead, save and activate the Activity. Now, when we execute our script, we actually get something back:

Awesome! We could already use this to greet our user on every page, even if we don’t have the username available from the backend. If we leave out the parameters, we still get the information that is saved in the User Profile, even if the volatile parameter is empty now:

Remembering product interactions

But Target can do even more! It has some logic about products and purchases that we can use to personalize even further. For example, we can tell Target which product the customer is looking at like this:

adobe.target.getOffer({
  "mbox": "DemoBox",
  "params":{
    "entity.id":"Product 1",
    "categoryId":"Category A"
  },
  "success": function(offer) {
    console.log("Result: "+offer[0].content);
  },
  "error": function(status, error) {
    console.log('Error', status, error);
  }
});

In this example, the user is looking at “Product 1” in category “Category A”. This information can also be included in our Experience Content. Let’s change it to this:

Test content!
Username: ${profile.username}
Page Name: ${mbox.name_of_page}
Last viewed Product: ${user.endpoint.lastViewedEntity}
Most viewed Product: ${user.endpoint.mostViewedEntity}
Favourite Category: ${user.endpoint.categoryAffinity}

If we now request the content again, we get information about the viewed products as well (note that we don’t need to include the product in the parameters):

Even if we view a different product now, Target remembers our first product if we viewed it more often:

Let’s sum up what we discovered up to now: We can give Target information about our Users and store it in their profile. This includes arbitrary values, but also variables related to viewed products and product categories. That logic can be used to greet users with their username, show them more relevant content or their favorite product.

Tracking purchases

But there is still more! We can also tell Target about the purchases a user completed. To do this, include another parameter with the purchased products:

adobe.target.getOffer({
  "mbox": "DemoBox",
  "params":{
    "productPurchasedId":"Product 3"
  },
  "success": function(offer) {
    console.log("Result: "+offer[0].content);
  },
  "error": function(status, error) {
    console.log('Error', status, error);
  }
});

Now we need to modify our Activity Content one more time to this:

Test content!
Username: ${profile.username}
Page Name: ${mbox.name_of_page}
Last viewed Product: ${user.endpoint.lastViewedEntity}
Most viewed Product: ${user.endpoint.mostViewedEntity}
Favourite Category: ${user.endpoint.categoryAffinity}
Last purchased Product: ${user.endpoint.lastPurchasedEntity}

And now we get even more information as mbox content:

It’s up to our business to decide how a purchase or view of a product should be defined. Things are simple for an online retailer, but as a media company we could define a purchase as a video view. Expert tip: You can also use the same variables in the Visual Experience Composer to directly edit the website you are working with!

Wrapping up

We explored a simple way to use Target to create dynamic experiences based on profile variables and the user journey. Now we are able to give that information back to the frontend, be it as mbox content or through the Visual Experience Composer.

Next step: Be creative! Use the principles demonstrated above and apply them to your business!


Avatar

Frederik Werner

Data Scientist roaming the realms of Web Analytics and Online Marketing Tech