Author: Jeff Shearer

  • Updated: Tracking Embedded YouTube and Wistia Videos in Marketo

    Updated: Tracking Embedded YouTube and Wistia Videos in Marketo

    Update 5/26 – I’ve fixed a player dimensions issue with the Wistia embed script, and added the ability to track both video starts and video completions. I’ve also updated the token naming conventions with a clearer, more consistent naming convention. Finally I removed the munchkin script call at the top of each embed code (though enabling Munchkin API is still necessary). It’s not necessary if you already have munchkin installed on your pages. Let me know if these changes are helpful!

    A common need among Marketo users lies in the ability to track embedded video engagement with their prospects and customers. Marketo will natively track form submissions and web page activity, but it does not have great built-in video tracking functionality.

    Since it’s important for marketers to understand when their target audiences actually view or interact in a certain way with a video, and not just that they visited a web page that happened to have a video on it, a more robust solution is needed. There are vendors who specialize in tracking video behavior in your marketing automation, but for basic tracking, you can do it yourself, and I’ll show you how.

    By leveraging Marketo’s munchkin API in conjunction with an API-enabled video hosting service like YouTube or Wistia, it’s easy to build this integration yourself. Before we get any further: don’t get scared off by terms like “API”–this particular piece of functionality is actually pretty simple to implement with a basic understanding of HTML and Marketo, and I’ve hopefully done most of the heavy lifting for you. Plus, it’s a great practical demonstration of the extensibility of the Marketo platform.

    This implementation works by using the video player to tell Marketo when it’s state changes from not playing to playing (in other words, when the lead clicks the play button on an embedded video). Then Marketo logs a web page visit event in the lead’s activity log, which can be used to trigger other actions off of Marketo, such as an interesting moment or program status change.

    First Things First: Enable Munchkin API

    Before we get into the specifics of how this works, you’ll first need to set up your Marketo instance to use the Munchkin API. Marketo Admins should first navigate to their admin section > Integration > Munchkin > Edit API Configuration. You’ll want to check the box labeled “Enable Munchkin API”

    Enable Munchkin APIWhile you’re on your Munchkin Settings, also make note of your nine-digit Munchkin ID (formatted as XXX-XXX-XXX). You’ll need this later.

    Now that you have this squared away, you’re set to start setting up your customized embed code. I’ve set up codes for both YouTube and Wistia. While YouTube is certainly a more widely used platform, I’ve started using Wistia more recently because of the issues with corporate IT filters blocking YouTube videos for B2B users. While this isn’t always an issue for embedded videos, I ended up preferring the the customization and business focus of Wistia. It’s a matter of personal preference I’ll leave up to you. For each guide, I’ve included standard embed codes, and tokenized codes (if you’re using your Marketo Programs).

    Option 1: Embedding with My.Tokens

    I mentioned that there are two versions of these embed codes – a standard and a token enabled script. If possible, you really should use the token-enabled script. You’ll find it’s far easier to work with, so long as the page you want to embed your video on is contained within a Marketo Program.

    First are the modified versions of the embed codes for Wistia and YouTube that are set to accept Marketo’s My Tokens, which work within Programs. Also make special note the highlighted section for Munchkin ID. You will want to set this manually, since it’s the same value for your entire Marketo instance. Your tracking will not work without setting this up.

    To set up video play tracking for a Wistia or YouTube video, you’ll need a few things:

    1. Your video ID (10 digit code that you can find in the embed code on Wistia, or on the video URL – The same is true for YouTube, but the code is 9 digits)
    2. Video height and width dimensions (eg 550×309)
    3. A “play” URL that you want Marketo to log anytime the video is played
    4. Your 9-digit Munchkin ID

    Next, you’ll need a landing page to embed your video to. Generally it’s advisable to do this within a program so that you can make use of the token-enabled script, however if you’re comfortable editing the script yourself and cannot make use of program tokens, you can install the videos on really any landing page using the standard scripts at the end of this post.

    If you plan to use the token-enabled script, here are the tokens you’ll need to create (all should be plain text tokens):

    • My.Video – ID: the 10 digit video ID from wistia  (9 digit for YouTube)
    • My.Video – Width: The pixel width of the video (note: this should be input as a numerical value only, eg: “550”, and not “550px”.)
    • My.Video – Height: the pixel height of the video (same instructions as my.videowidth)
    • My.Video – Name No Spaces: this is the fictitious URL you define that will display in the Marketo activity log. You can set anything you want here, but I generally like to follow a similar naming convention to the page that the video is embedded on. I’ll clarify with an example: if your video is embedded on info.yourdomain.com/myvideo.html,  you might want the log to display info.yourdomain.com/myvideo/play when the video is played. In that case, you’ll want to set this token value as “myvideo”. Do not include any other part of the URL – Marketo will do that automatically. Note that this script logs a video start and a video complete event. You can opt to use one or the other, or both at the same time.
    • My.Video – Player Color: This one is optional, and only for Wistia, but it controls the color of the video player. You don’t need to set a value here, but if you want to customize it to your own video branding, feel free to use your own hexadecimal color code. (eg 6688AAD – no # needed)

    Below are the scripts you’ll want to place within an HTML object on a Marketo landing page. Note: The codes below will replace any embed code you would ordinarily retrieve from Wistia or YouTube directly. These will handle both the embed of the video and the tracking and integration within Marketo.

    Remember – you must update the highlighted sections with your specific Marketo 9-digit Marketo ID (including hyphens).

    You can also download all the scripts via my GitHub repository of this project.

     Wistia (With Tokens)

    <!--Video embed (this is what embeds the Wistia player)-->
    <div id="wistia_{{my.Video - ID:default=c6xf9ao18h}}" class="wistia_embed" style="width:{{my.Video - Width:default=550}}px;height:{{my.Video - Height:default=309}}px;" data-video-width="{{my.Video - Width:default=550}}" data-video-height="{{my.Video - Height:default=309}}"></div>
    <script charset="ISO-8859-1" src="//fast.wistia.com/assets/external/E-v1.js"></script>
    <script>
     wistiaEmbed = Wistia.embed("{{my.Video - ID:default=c6xf9ao18h}}", {
     videoWidth: {{my.Video - Width:default=550}},
     videoHeight: {{my.Video - Height:default=309}},
     playerColor: "{{my.Video - Player Color:default=688AAD}}"
     });
     // the functions below will watch for the video to be started or ended (tracked via state changes), and translating that to page visits in Marketo. 
     wistiaEmbed.bind('play', function() {
     mktoMunchkin("XXX-XXX-XXX");
     mktoMunchkinFunction('visitWebPage', {
     url: '/{{my.Video - Name No Spaces}}/played', params: 'x=y&2=3'
     });
     });
     wistiaEmbed.bind('end', function() {
     mktoMunchkin("XXX-XXX-XXX");
     mktoMunchkinFunction('visitWebPage', {
     url: '/{{my.Video - Name No Spaces}}/completed', params: 'x=y&2=3'
     });
     });
    </script>

    YouTube (With Tokens)

    <!--Youtube iframe embed script with Munchkin integration-->
    <div id="player"></div>
     <script>
     // 2. This code loads the IFrame Player API code asynchronously.
     var tag = document.createElement('script');
     tag.src = "https://www.youtube.com/iframe_api";
     var firstScriptTag = document.getElementsByTagName('script')[0];
     firstScriptTag.parentNode.insertBefore(tag, firstScriptTag);
     // 3. This function creates an <iframe> (and YouTube player)
     // after the API code downloads.
     var player;
     function onYouTubeIframeAPIReady() {
     player = new YT.Player('player', {
     height: '{{my.Video - Height:default=309}}',
     width: '{{my.Video - Width:default=550}}',
     videoId: '{{my.Video - ID:default=c6xf9ao18h}}',
     playerVars: { 'showinfo': 0, 'controls': 2, 'rel': 0 },
     events: {
     'onReady': onPlayerReady,
     'onStateChange': onPlayerStateChange
     }
     });}
     // 4. The API will call this function when the video player is ready.
     function onPlayerReady(event) {
     }
     // 5. The API calls this function when the player's state changes, and sends a visit web page action to Marketo via the Munchkin API
     var done = false;
     function onPlayerStateChange(event) {
     if (event.data == YT.PlayerState.PLAYING && !done) {
     mktoMunchkin("XXX-XXX-XXX");
     mktoMunchkinFunction('visitWebPage', {
     url: '/{{my.Video - Name No Spaces}}/started', params: 'x=y&2=3'
     });
     }
     else if (event.data == YT.PlayerState.ENDED && !done) {
     mktoMunchkin("XXX-XXX-XXX");
     mktoMunchkinFunction('visitWebPage', {
     url: '/{{my.Video - Name No Spaces}}/completed', params: 'x=y&2=3'
     });
     }
     }
     </script>
    
    

    Standard Embed Codes

    If for some reason you can't use your video within a Marketo program and use the tokenized codes above, the standard codes below will also work, just know that you must edit the highlighted portions with your video and Marketo info. Take extra care with the Wistia embed code, as variables like video player dimensions and ID must be edited in several places. Again, use the tokenized version above if you can! Finally, note the highlighted portion for “url”. Remember, this is the name of the URL you wish to have logged in a lead’s Marketo activity log when the video is played. This can be set to anything, and doesn't need to be an actual working URL. In the example of a webinar, your URL could be “myQ2Webinar/play”. Note to only include the page name and then something afterwards to distinguish the actual page from the play action, such as  "/play". Do not include any prefixes or domains (http, www, domainname.com, etc).

    Wistia (Standard Script, no Tokens)

    <!--Video embed (this is what embeds the Wistia player)-->
    <div id="wistia_29b0fbf547" class="wistia_embed" style="width:550px;height:309px;" data-video-width="550" data-video-height="309"></div>
    <script charset="ISO-8859-1" src="//fast.wistia.com/assets/external/E-v1.js"></script>
    <script>
    wistiaEmbed = Wistia.embed("29b0fbf547", {
     videoWidth: 550,
     videoHeight: 309,
     playerColor: "688AAD"
    });
     // the functions below will watch for the video to be started or ended (tracked via state changes), and translating that to page visits in Marketo.
    wistiaEmbed.bind('play', function() {
     mktoMunchkin("XXX-XXX-XXX");
     mktoMunchkinFunction('visitWebPage', {
     url: '/YourVideoName/started', params: 'x=y&2=3'
    });
    });
     wistiaEmbed.bind('end', function() {
     mktoMunchkin("XXX-XXX-XXX");
     mktoMunchkinFunction('visitWebPage', {
     url: '/YourVideoName/completed', params: 'x=y&2=3'
     });
     });
    </script>

    YouTube (Without Tokens)

    <!--Youtube iframe embed script with Munchkin integration-->
    <div id="player"></div>
     <script>
     // 2. This code loads the IFrame Player API code asynchronously.
     var tag = document.createElement('script');
     tag.src = "https://www.youtube.com/iframe_api";
     var firstScriptTag = document.getElementsByTagName('script')[0];
     firstScriptTag.parentNode.insertBefore(tag, firstScriptTag);
     // 3. This function creates an <iframe> (and YouTube player)
     // after the API code downloads.
     var player;
     function onYouTubeIframeAPIReady() {
     player = new YT.Player('player', {
     height: '390',
     width: '640',
     videoId: 'kTcRRaXV-fg',
     layerVars: { 'showinfo': 0, 'controls': 2, 'rel': 0 },
     events: {
     'onReady': onPlayerReady,
     'onStateChange': onPlayerStateChange
     }
     });}
     // 4. The API will call this function when the video player is ready.
     function onPlayerReady(event) {
     }
     // 5. The API calls this function when the player's state changes, and sends a visit web page action to Marketo via the Munchkin API. Make sure to update the mktoMunchkin value to match your specific account ID (Admin > Integration > Munchkin)
     var done = false;
     function onPlayerStateChange(event) {
     if (event.data == YT.PlayerState.PLAYING && !done) {
     mktoMunchkin("XXX-XXX-XXX");
     mktoMunchkinFunction('visitWebPage', {
     url: '/YourVideoName/started', params: 'x=y&2=3'
     });
     }
     else if (event.data == YT.PlayerState.ENDED && !done) {
     mktoMunchkin("XXX-XXX-XXX");
     mktoMunchkinFunction('visitWebPage', {
     url: '/YourVideoName/completed', params: 'x=y&2=3'
     });
     }
     }
     </script>
    
    Once you've successfully embedded your codes, It's time to test out your page. Visit the Marketo landing page you've just created, and click the play button on your video. Make sure to be using a browser that has already been cookied by Marketo (An easy way to confirm this is to visit a Marketo page with a form on it - if the form is pre-filled with your information, you're cookied). Then, search for your lead record in the Marketo lead database, and click over to the activity log. You should see something like this: activity log This web page will now appear anytime the video you've set up is played. Cool, huh?

    Triggering flowsteps off video play behavior

    So what do you do now? Now that you've got your videos tracked in Marketo, it's time to have Marketo do something interesting with that information. Since you've logged a web page visit, you can now use the "visited web page" trigger or corresponding filter in a Marketo Smart Campaign to trigger activities off of video plays. web page trigger   For example, you could log an interesting moment anytime your video is played. Your sales team will thank you for this, as you can log something very explanatory, like "Viewed Video: Q2 Product Demo" instead of "visited web page my-landing-page-Q2_Demo-V8.html/play." In the past I've discussed how to centralize your content tracking through Marketo programs. You can do the same with videos too, and log a program success when a lead plays one of your videos. This is especially helpful if you want to view all the leads who've watched your video, or to calculate return on the investment of a video's production. Flowstep   Keep in mind that these examples work best when the lead is already known in your database. So in the case of a recorded webinar, where you've probably got a form sitting in front of that video, it's safe to assume that you'll probably have known visitors being tagged with video views. But if the video is a general marketing video that may be sitting on its own, you will likely have anonymous as well as known visitors. Marketo will still track both, but logging a program status change or interesting moment is really only of value to known leads. So you may consider dropping in a filter to your smart campaigns to exclude anonymous leads, or just be willing to accept some anonymos leads in your program reports.

    Moving beyond the basics

    I built this integration because it solved a very specific problem for me, yet there are pretty limitless possibilities with expanding on this. With a bit of work, it's likely possible to track more nuanced behavior, such as viewing a video for a specified period of time, or observing the degree to which the video is started and stopped. I constructed this integration using the following resources. Feel free to use these in your own efforts! Marketo Munchkin API Documentation Wistia Player API Documentation Youtube JS Player API Reference As I mentioned earlier, I've started with Wistia and YouTube, but there are probably plenty of other video players you could build similar integrations with, such as Vimeo. Most of their APIs are fairly similar to work with, so it's probably just a matter of adapting the existing scripts to other players' specific operations. If you're interested in other applications of this, let me know in the comments!

  • Why I’m a B2B Company’s Least Favorite Prospect

    Why I’m a B2B Company’s Least Favorite Prospect

    I’m a B2B company’s least favorite kind of prospect.

    • I ignore or unsubscribe from their emails (especially if I didn’t explicitly opt in )
    • I’m doubly likely to opt out if my information was clearly bought from a list (In fact, I’ll do this just out of spite)
    • I never answer or return their calls (and in the rare circumstance that they actually do reach me, the very act of doing so usually kills any chances of them getting a successful sale from me). I don’t hate talking on the phone, I just really hate getting called by salespeople unless I’m specifically requesting it.
    • I don’t click their ads (except to see if there are any creative ideas worth poaching from their landing pages)
    • I immediately see through any sort of automation and tracking they’re using: if they have a gate on content I want, I either disable javascript or view source to get to the content without providing my information, or I just give (cringe) fake information.
    • I used to sometimes respond positively to LinkedIn InMail when the volume was low, but nowadays find myself largely rejecting most InMail requests.
    • In the rare case that someone does get me interested in something, I’m terrible at staying in touch with them, and never stick to the timelines they set.

    And yet, my job is to help  sales reps do the very things to prospects that I absolutely detest. So how do you sell to the most private of prospects? When I look back at how I’ve been successfully sold to in the past, some common themes emerge.

    Content plays a big role–and I’m not just talking about whitepapers and webinars–product details, video demos, etc all are valued, depending on where I’m at in the buying cycle. I’m big into doing my research ahead of time, so I actually find myself consuming most of a brand’s relevant content before ever engaging with a salesperson. While I generally avoid gated content if possible, this isn’t a hard and fast rule, and I will give up some basic contact information in certain instances. The one thing I won’t do, though, is give up my phone number for a whitepaper.

    When it comes to marketing technology, I’ll always vet a potential vendor with my professional network  for reputation. If I catch a whiff of a poor product from my peers, that’ll usually not only kill the sale, but cause me to warn others to steer clear as well. While references are an important part of deciding on a vendor, it’s actually how I first catch wind of many of them. I try to surround myself with very intelligent people, and if they’ve found a way to solve a problem I too am experiencing, I’ll listen.

    Obviously, the timing also has to be right. When this doesn’t line up, even the most willing of prospects isn’t going to be able to make the purchase. But there’s more to it than that. I think most organizations tend to shoot first and ask questions later when it comes to determining the timeline of a prospect. The very fact that they are asking me if I’m in the market & timeline for whatever they’re selling, they’ve  already lost the sale. The salespeople who generally win with me are those who recognize that I will come to them when I’m ready to hear more.

    Even though the average prospect in most industries probably isn’t as aggressively unreachable as me, I do respond well to content (when done right), referrals and reputation count, and timing is everything. The difference is that while you can potentially get my attention with direct sales tactics, I’m not likely to reciprocate. Instead, I’ll readily raise my hand when the need, want and timing are there.

    On a side note: I suspect part of my stubbornness around sales engagement has a lot to do with my profession. Seeing how the sausage is made has a certain effect on one’s taste preferences. Part of me is thankful I don’t currently work in an industry where I’m marketing to marketers. We’re a tough group to please.

     

  • 15 Marketo Protips: Advice You Can Implement Today

    15 Marketo Protips: Advice You Can Implement Today

    Back in April I gave a presentation at the 2014 Marketo Marketing Nation Summit focused on practical, easy-to-implement tips to make your automation systems more scalable, efficient, and effective. The idea worked great on paper, but I bit off more that I could chew–fifteen tips is a lot of ground to cover in a 45 minute session, so I ended up having to provide more of a glimpse than in-depth guidance.

    For those who expressed interest after the presentation in seeing the slides or learning more, I decided to do a deeper dive on these tips, and this article is just that.

    The idea of this session came about, in part, because I always prefer going to sessions where I get practical, actionable advice. The content, however, came about from all the little shortcuts I or others have found to make things easier and more efficient when using Marketo. Many of these ideas have been submitted by users around the community, and also within the Marketo Seattle User Group. While I have this list of 15 tips, I’m sure you have others, so be sure to share them in the comments!

    #1 – Folder Organization

    folder-organizationBe honest, we all have some scary areas of our Marketo instances that are just a mess. I’ll be the first to admit it. The fact of the matter is, sometimes we create assets quickly, but don’t bother to give them a name that makes sense, or put them in a folder. It seems harmless at first, but after years of this stuff piling up, it’s pretty much impossible to figure out what is relevant and what isn’t.

    I’m pretty crazy about organization and consistency in our Marketo instance, so I generally gravitate towards smart folder organization. Yet it’s doubly important when you have many users in your Marketo instance, each with their own ideas of how to organize and name things. Set a consistent process, write it down, and ensure everyone in your instance knows and follows it.

    There’s no hard and fast way to do this, but I try and organize things with top level folders for the basic category, followed by subcategory, followed by year/month/quarter etc.

    You also want to make use of archived folders where possible to indicate what’s no longer relevant for other users to be looking at.

    #2 – Asset Naming Convention

    The naming of your assets is closely related to folder organization. Again, there’s no hard and fast way to organize the names of your assets, but it’s important to set a naming convention and stick with it. Here’s a good litmus test of how big of a problem with naming conventions you have (this could also be made into the nerdiest marketing drinking game ever): Pick a form at random from the bowels of your design studio. Can you identify what form it is, the situations it’s used for, and any hidden field info, just from the name? No, well then take a drink,or read on…or do both.

    You’ll be amazed at how much time you can waste trying to figure out which asset is which, when a lot of that can be avoided with some intelligent naming conventions. So suppose you’re naming forms. Don’t pick a crazy abbreviation that no one remembers. Pick something descriptive. Name the form that’s for webinar registrations: “webinar registration”. Another variable a lot of people don’t think about with forms in particular is the submit button text. I actually try to include that in the name where possible. It helps to avoid needing to check the asset incessantly.

    While labeling things descriptively helps reduce confusion, it can also be handy for clever use of smart list triggers and filters. Suppose you want a particular type of email to be sent to the salesperson anytime someone fills out a webinar registration form.

    webinar-namingWell, if you’ve done you due diligence and named your assets consistently, you can build a smart list that just looks for any form submissions that start with the words “Webinar Registration”. This is way easier than trying to remember every single form name that might qualify for the alert, and it helps future proof your triggers, because any time you add a new form under the same naming convention, it’ll automatically fit into your existing logic, without any need for you to add it in manually.

    Thinking through your naming conventions can just help you find things easier and quicker, too. You can chronologically label occurring steps for an event program. Since Marketo organizes data alphabetically, with a bit of thought, you can organize your smart campaigns in a logical manner, rather than just where they occur in the alphabet. This is much easier to find what you’re looking for, as it’s a step by step list.

    #3 – Sales Insight Email Organization

    MSI Published templatesSpecial consideration with organization must be made for sales insight emails, which are emails you’ve published as templates for your sales team in Salesforce.com or whatever CRM you’re using. I make heavy use of Marketo Sales Insight, to the point where I’ve got dozens of these templates available, with new resources being added weekly, so helping my team understand which email is which is super important.

    Because of the nature of how Marketo Sales Insight published emails work, I’ve found it makes much more sense to keep all our published emails in one location. I have folders for different points of sale, with further folder definition for sales vs account management templates. Then, each asset is prepended with an identifier of which team should use which asset.

    MSI-SFDCIf you look at how it appears for the salesperson, this is way easier to decode which email is which than if everything is randomly named with no folder organization.

    Another tip here is to make use of the description field on your email assets in Marketo. This description will carry over to the Marketo Sales Insight interface, to help give the salesperson a bit more insight on what the template is for. If you have a ton of templates in your instance, you can’t possibly hope for your sales team to remember what every single template is for. So this description field is really helpful.

    #4 – Global Forms

    global-formsWhen I talk about global forms, I basically mean the concept of using a single form on multiple landing pages. In other words, not creating a new form every time you have a new campaign.

    Using forms globally where possible is a great idea, because it will reduce the amount of single-use assets that are hanging out in your instance, but it also makes your system for alerts, scoring, and other data management tasks much easier. Imagine you wanted to create one scoring rule that watches any time a resource download form is submitted. If you had a unique form for every whitepaper, case study, and infographic you ever made, you’d need to account for a lot of forms.

    It’s also fantastic when you want to make large, sweeping changes to your forms at once. Suppose you now need to start asking a new piece of information on all your forms. With a global form, you make the change in one place, and have it propogated out to all your landing pages that use it at once.

    #5 – Global Emails

    Just like forms, some of the emails you use, both internally and externally, can be made global in Marketo. There’s two great examples here.

    Think about all the email alerts you set up, either for yourself or for your sales team. In most cases, you’re basically telling them: “Hey, a lead did something, here’s all the relevant information to contact them.” You don’t need to create an alert for every situation, you can actually have a couple of generic alerts that trigger on a set of criteria. So, for example, you might have an alert that tells a salesperson that a high value form was submitted.

    If you’re using common forms for things, and if you’re basically telling the salesperson the same thing each time, it actually does you a disservice to have a ton of different alerts. Your sales team is going to get overwhelmed, and isn’t going to know which alert is which, despite your best efforts.

    So I generally advise keeping alerts simple so they can cover a wide swath of uses. You’ll have an easier time training your sales team to click through to salesforce to get the specific details of what’s going on with this lead.

    sp_send_alert_infoOne great tool to use in your alerts is the “SP_Send_Alert_Info” Token. This will automatically pull in the specific smart campaign that drove the action, a timestamp of the activity, and best of all: it links to the record in SFDC and Marketo.

    You can also use the global email concept with autoresponders. If you send your resource downloads to leads via email, rather than letting them access the download directly on the website, you can use the same autoresponder for all your resource downloads. And of course, you can use tokens here too. Anytime someone downloads a piece of content from one of your programs, you can trigger a global autoresponder to fire, that populates all the specifics of the content. The email doesn’t even need to be local to the program.

     #6 – Tokenized Programs

    webinar-programI received some interesting feedback from people who heard me using the word “Tokenize” in my presentation. I can’t claim credit for that, but I also can’t say who coined it originally (Har har har). Anyway, here’s the idea.

    Consider your average webinar. Think about all the assets and logic that go into an event like this. You have emails, landing pages, and smart campaigns. And that’s for a simple event. And yet, most webinars are actually very similar in Marketo. You’re always following the same general process, yet creating and editing all these assets, even when you can clone past events, is so time consuming.

    By building all your program assets with tokens, you can save a huge amount of time, and build more consistent, error-free programs.

    So continuing the example of a webinar, let’s look at the tokens you can set on the program.

    Program Tokens

    As you can see, nearly everything can be made into a token. Your webinar content, banners, logos, even the access information to the webinar. Thank you pages, and finally, even our On-Demand videos are tokenized.

    This is huge for replication, because it means the only thing you’re editing is the tokens – no need to go into the assets at all. Another benefit of building programs like this is that any sorts of inconsistencies, such as the wrong date/time or dial in information, are minimized, because again, you’re setting the token value at one place, at it shows identically everywhere the token is referenced.

    It turns a highly complex campaign into something anyone can go in and reproduce. As a colleague of mine, Adam Waterson is known to say, it doesn’t do you any good to build some sophisticated, complex solution if you’re the only one who knows how to work it.

    #7 – Program Templates

    program-templateOnce you’ve built out a fully tokenized program, it’s a great idea to create a template version that you clone from. I like to do this for things like content and events, as I like to have a pre-built package ready to go when I have new content. So the reason you want to have a template, versus just cloning the last used program, is that anything custom you might have had to add to the program will carry over as well.

    I find this is especially helpful for the rest of my team as well, as they can easily duplicate something we build all the time. You can even take it a step further with default tokens that indicate what you should do with each token. For example, the dimensions needed for the perfect banner image.

     #8 – Centralized Content Programs

    You've got all these great lead sources, but how are you to track content engagement across all of them?
    You’ve got all these great lead sources, but how are you to track content engagement across all of them?

    This one could have a whole article devoted to it, which I’ll probably spin up eventually. But here’s the gist of it:

    Suppose you’ve got a new whitepaper, and want to promote it on several different channels. Ordinarily, you might think it wise to build each channel separately. Build your display ads that point to the whitepaper download page. Link to it in social, etc.

    The problem with this is that you can’t track the utilization of a piece of content across channels in  one place, and you can’t efficiently compare which channels performed better for the content than others.

    There’s a way in Marketo that you can centralize your content so that all channels point to the same core assets.

    Essentially, it means creating a specific program for each piece of content you produce. Here’s an example of one of our whitepapers. This program has a special type created for it called “content”, and every channel that uses it: online advertising, content syndication, and even sends from your sales team, are all sent to the assets that are in this program.

    Through this, you can see any download activity on this content in one place.

    If you create a template for your sales team to share this resource, you should point them to an asset stored in this program. You can then track and clicks on the download link there are a conversion.

    If someone accesses the content from a nurture campaign, you can track that here too.

    The other value to this process is that any changes you need to make down the line to the content can be done in just one place, rather than trying to find every email, landing page, etc that uses the asset. Plus, going back to a previous tip, you can tokenize much of the content in these programs, making cloning and tweaks really easy.

    #9 – Picklist ALL the Things

    picklistsSo if you’ve been using Marketo for awhile, you’ve probably come across this issue already, but standardized lists of data are so much easier to work with than text entry. Here’s what I mean. Suppose on your form, you ask a lead’s job title. Pretty harmless right? Then you get asked to build a persona-targeted campaign, and you realize how many different ways someone can spell (or misspell) a job title.

    This goes back to the adage of “bad data in, bad data out.” But you can circumvent a lot of headache later by being smart with the way you collect data in your forms. Identify the areas where you can bucket values, rather than asking the precise value. (pull screenshot of Marketo guide that shows accuracy of form data). It’s probably not going to be all that accurate if you ask an exact value, and it’s not terribly actionable for your marketing efforts. So use select fields for things like job title, industry, company size, revenue size, and other identifying aspects.

    #10 – Triggers for Standardizing Data

    normalizerFor the data that you want standardized, but can’t necessarily put in picklists, I’ve got a solution for you there, too. (or if you just need to do a bit of spring cleaning)

    A simple example looks at incorrect formatting of country values, and fixes them.  Basically, it watches for values containing certain words or abbreviations and rewriting them to the appropriate standardized value. It’s not a perfect solution because stuff will fall through the filters you build, but I like to audit what these don’t catch every month or so and build the missing non-standard values into the normalizer as well. Eventually, you’ll have most circumstances covered well. The opportunities to do this are endless, too. Think job titles, industries, etc. You can’t currently do anything fancy with wildcards or case changes, though. SO YOU’LL NEED TO FIND ANOTHER WAY TO FIX ALL THE DATA FROM PEOPLE WHO TYPE LIKE THIS ON YOUR FORMS.

    #11 – Segmentations as Smart List Filters

    If you’ve ever made use of Marketo’s dynamic content feature, you’re probably familiar with how Segmentations work. But you may not know the power of using segmentations within smart campaigns.

    For frequently used filters, such as lead owner, industry, job role, etc, these can be super handy. Remembering all the commonly used filters you need for a campaign can be tricky, but by using a segmentation to contain all those filters, the only filter you need to remember in your blasts is the segmentation. There used to be some debate that using segmentations instead of straight field filters was actually a faster way to generate a list, though in my testing I haven’t seen any speed benefit either way.

    In any case, they’re a lot more convenient, especially when you’re dealing with a piece of data that can change often.

    #12 – Lead Source Tracking with URL Variables

    url-parameterYou are probably already tracking lead source on your different forms with a hidden value. This works, by basically tagging any lead that comes through the form with the lead source value you specified. It works, but it’s limiting, especially if you move to using more global forms where you’re leveraging one form for multiple assets.

    To do this, a great solution can be in switching your lead source value on forms to be assigned based on URL parameter. Here’s how you do it. In your form, go into the autofill settings of the field, and change the “Get value” field to “URL parameter”. You’ll need to set a default value of some kind, but in the parameter name, put whatever URL parameter you want to use. This is somewhat arbitrary, you can use pretty much any parameter name you want. Yours could just be “leadsource”, if you want to keep it simple. We tend to follow the old utm tracking naming conventions.

    Once you’ve done this, all you need to remember to do is when linking to your landing page that uses the form, append the appropriate URL variable to the end. This is so handy because it means you’re not only using your forms efficiently- but you’re suddenly able to get visibility to channels you may not have had great data on before. Social media comes to mind for me- it just isn’t something something I have a good handle on lead gen from, but now  I can track  any content, infographic and event and be confident that  I’ll get accurate lead source data.

    Find this handy dandy tool for any landing page by clicking Landing Page Actions > URL Tools > URL Builder
    Find this handy dandy tool for any landing page by clicking Landing Page Actions > URL Tools > URL Builder

    The only catch to this is you need to remember to tag your URLs before using them. This is more about building habit than anything,

    And lucky for you, Marketo has a built in tool for that. On any landing page, you can find the URL builder in the settings. It will look up any hidden values you have on the form that are set to accept URL variables, and you can generate your URLs easily.

    #13 – Tokenized Lead Scoring

    You may have noticed the score token, but not have had a great idea of how to use it. Lead scoring systems can be pretty complex, and even harder to audit and adjust later. Score tokens can help here. To use them, you first need to have your scoring contained in a program.

    For each of your triggered scoring rules, instead of assigning +10 or -20 points, you’re actually assigning a token value. Then, on the program token settings, you can view all your score changes in one place, and adjust them accordingly. This is really handy when you want to take a glance at the different score changes that could occur, and also helpful if you have multiple triggers that are affected by the same score change.

    score-tokensAlso, here’s a freebie: if you’re starting from scratch with your lead scoring, there’s a great program pre-built in Marketo that you can import. You can find the importer in marketing activities, and there are actually a ton of fantastic starter programs in here beyond the scoring program.

    import-program
    This is a great hidden feature. Go to Marketing Activities click the “New” dropdown, and select “Import Program”.

     

    #14 – Tokens in Interesting Moments

    Interesting moments are such a valuable way to pass insight to your sales teams, but a lot of people use them incorrectly. Usually, you have the basics in there: fills out a high value form, visits web pages, critical piece of information is learned. While these work great in theory, the way they’re conveyed to the sales team is not always very clear. The problem is that basic interesting moments just take the raw asset names in Marketo, and push them to Salesforce.

    Here’s what I mean. Put yourself in the sales person’s shoes. What the heck is LandingpageA1441-September2014aconvertedpage?

    The cool thing is, you can actually make these interesting moments more…well, interesting, by building them through tokens. So, as long as you followed my past suggestions on using tokens wherever possible, you can build interesting moments on your programs that use token data instead of gibberish asset names.

    interesting-moment-token

    Now the salesperson can see a much clearer view of what the lead has been up to.

    MSI-interesting-moment

    #15 – Folder Tokens

    I’ve been talking a lot about tokens at the program level, but you can actually set these at the folder level, too, which can lead to some interesting use cases.

    Probably the most common benefit is with copyrights and key contact information. You update this stuff at least once a year. Normally, that’s a time consuming process in Marketo, because you have to edit the template, and then approve all the assets that use the template. BUT! If you set your copyright info and other high level information that may change (logos are another opportunity here) in tokens, you can use folder tokens to your advantage here.

    Then you can set your token by clicking any folder in your Marketing Activities section of Marketo, and navigating to the My Tokens section. Of course if you’re setting a very universal piece of information like copyright, you’ll want a top-level folder that contains all your other folders, but this is never a bad idea, and goes back to the very first tip I talked about regarding folder organization.

    folder-token-hierarchy

    The other really cool thing about folder tokens is they can nest. In other words, you can set a copyright token at one folder at the top level, but other tokens in folders at lower levels, and finally tokens within programs at the lowest level. Plus, if you set a token value of your global HQ address as the top-level folder token, you can override it with a token in a folder (or a program beneath it). So your Canadian and eEuropean teams can use their local office locations for their folders, and you can use your address for your folders.

    Now the next time that your office moves to a new location, you rebrand, your company gets acquired, or you just enter the next year, you’ve built your systems smart to allow you to make an update in one place and have all assets affected immediately, with no approval required. One super annoying disclaimer to this process: Tokens DO NOT work with emails published to sales insight. So keep in mind that any emails you’re publishing to your sales team must have all {{my.Tokens}} removed. You’ve been warned!

     

    So that’s it! If you have ideas to add or want to know more, submit a comment or tweet me. I’m @TheJeffShearer.

  • An Email Marketer’s Approach to Inbox Zero

    An Email Marketer’s Approach to Inbox Zero

    I’ve had a few people ask me recently about how I manage my email inboxes for my personal and professional accounts. Given my line of work in email marketing, I must have some great secret to managing the inbox, too, right? Well, not exactly, but the short answer is, I do have a process, largely based on a philosophy called “inbox zero.” If you’re unfamiliar with the concept, I first invite you to watch Merlin Mann’s presentation on the topic.

    Essentially,  inbox zero is a practice to overcome email overload. By establishing a simple system for processing emails as they come into your inbox, you spend less time reviewing and re-reviewing your inbox, and more time being productive. Despite the name, it doesn’t necessarily have to mean an empty inbox. While I will sometimes reach a completely zeroed inbox, it’s not really the goal. Instead, it’s about getting better control over your inbox.

    The basic principle is each message you receive is processed in one of four ways:

    • Do: take action now, whether it’s a response, or a task to accomplish
    • Delete:  If the message is irrelevant to you, or can be filed away, get it out of your inbox immediately.
    • Delegate: If another person can better deal with the message, delegate it to them, and file away. Don’t sit on it.
    • Defer: If action is not needed now, the message should be moved out of your active inbox until it is due.

    This process is handled a bit differently depending on the circumstances, so I’ll do my best to break down how I do it professionally and personally.

    Zeroing my personal inbox

    Mailbox App
    Mailbox App

    I live out of gmail for personal email, which, fortunately, is a client reasonably well suited for the inbox zero philosophy. Yet, interestingly enough, I actually handle the “zeroing” of my inbox entirely on my mobile devices, that is, to say, through an app called Mailbox. You may have heard of Mailbox as the much ballyhooed app from Orchestra  released last year.  Mailbox is the best manifestation of inbox zero in an app that I know of. Your inbox exists in three views: your current mailbox to review, your deferrals (to the left), and your archive (done). Processing messages is handled entirely through swiping: a short swipe right will archive the message, a long swipe right will delete it entirely. Conversely a short swipe left will allow you to choose a deferral date, and a long swipe left will archive to a specific tag (gmail only).

    This swiping process takes some getting used to, and it probably isn’t for everyone, but the deferral functionality is what I really love about this app. In a swipe and a click, I can get a message out of my inbox, set a date or time for when I will be ready to look at it, and it will automatically move back into my inbox once the timer is up. Part of the reason it works so well is that it is almost effortless to do this (unlike how this process can work in Outlook, but we’ll get to that in a moment).

    Mailbox deferral
    Mailbox’s deferral options

    Some may argue that by having this deferral functionality only serves to create procrastination, but in practice, I’ve found I can usually archive 70-90% of the messages in my inbox immediately, and defer or do the rest.

    With this app, I can easily churn through dozens of emails in a matter of minutes, and there is a little sense of accomplishment each time I clear my inbox.

     

    My professional inbox

    While Outlook is a fairly detestable email client, it is possible to successfully implement inbox zero principles within it.  Now, before I go any further, I do want to mention that the core process I follow is entirely based off of a blog I stumbled across by Owen Barder. It essentially revolves around some clever use of Outlook search folders (versus the static folders you’re probably most familiar with) and follow-up flags. I’ll leave the details of how this is technically set up to Owen’s blog, but I’ll say a few words on how I actually work within this process, and the results I’ve seen so far.

    When a message arrives in my triage inbox, I respond to it (if possible), and then immediately file it into a single archive folder. If for some reason I also want a reminder to follow-up, I’ll flag the message instead of immediately filing, and it will move into one of my deferral folders for a later reminder.

    I have a simple set of static folders that I’ll file messages to, rather than a huge tree of folders and nested folders. I’ve found personally it’s far easier for me to perform a simple search in a handful of folders than try to remember which folder I put a message.

    Deferred messages are where it gets a bit more interesting. In addition to the triage folder, I have a search folder for “Today” and for “Future”. These search folders only display messages that exist in the inbox, and have a follow-up flag with a due date in a particular time frame (so This week looks at messages with a due date of this week, and Future looks at anything that’s due further out). The great thing is that the moment a flag is set for a message in the triage inbox, it automatically moves to one of these deferral folders. Once I get to a deferred message, I’ll remove the flag, and then file it in the archives.

    My morning email routine now works like this: When I process my morning emails, I flag and file messages until I have completely cleared the inbox. I then live most of the day primarily within the “Today” folder. I occasionally check in on the triage folder, and on particularly email-heavy days, I may be zeroing my inbox 2-4 times. This may seem like a lot, but it usually only takes a few minutes, and it means I can continually keep on top of only the emails that matter.

    I’ve definitely found some major efficiency and success with this process, but I won’t pretend it isn’t without its own challenges, mainly from Outlook’s limitations. Probably the biggest weakness for this approach right now is when managing your inbox on mobile. Search folders don’t work on the mobile clients, so depending on how many messages you have that exist in the deferral stage, you could have a reasonably big inbox full of your triage and deferred emails (since you’re basically just using search folders to look at the same inbox folder in different ways). Ultimately I’d love to have a Mailbox-like mobile interface for my Outlook.

    The balance between your time spent in the triage folder and the today folder is also tough to master. Sometimes I find myself hanging out in the triage folder too long when I have action items to complete in the Today folder. Habits take time to build, but ultimately I feel I’m better off than I was without a system like this. I’ve also found it helps to change the default folder that’s opened in your Outlook to the “Today” folder.

    To avoid obsessing over email the instant it arrives, I also disable the pop up notifications and sounds that are set by default in Outlook. This step alone has had a huge impact on keeping me from obsessing over email all day. I’ve found that I’ve taken a similar approach to push notifications from apps on my phone. By disabling these in most cases, I’ve found it has greatly helped cut back on distraction.

    So that’s it so far. I’d say I’m far from a perfect solution, but I’m glad to have at least started on the path to something better. I’m curious to hear how others are managing their mailboxes efficiently, so please share your methods in the comments.

  • {{my.Favorite Feature of Marketo}}

    {{my.Favorite Feature of Marketo}}

    I’m amazed at how many people are using Marketo like a plain-jane email marketing tool. Maybe it’s just my nature to seek out the more efficient, scalable way of doing things, or maybe the true automation functionality in Marketo is simply not well understood by many users.

    If you’ve ever pulled me into a conversation about marketing automation, you’re likely to have heard me mention “tokens”–and quite often. This is one of the areas where I believe some of the real, tangible value of an automation tool like Marketo starts to pay off, yet I also know it’s not well utilized or understood by the majority of organizations & users of Marketo.

    Tokens are a piece of functionality that can not only save time for those creating campaigns and programs in Marketo–they actually help produce better, more consistent campaigns in the process.

    Tokens, defined

    Marketo tokensTerminology and naming conventions are always tricky with marketing technologies, and the term “token” can mean a few things, particularly in Marketo.

    A lot of CRMs and email providers use the term token to basically define a mail merge field. Tokens are something pulled from a field in a database to appear in a piece of creative-most often, an email.

    This is an accurate definition in Marketo. You can personalize emails with salutations, lead owner details, you name it, with all the data pulled from your CRM or wherever. For lack of a consistent, descriptive name, I call these Field Tokens.

    But this sort of usage of a token is pretty duh. It’s not new, and most marketers have been using it for years.

    There’s another type of token, though, that’s actually pretty special.  I call them Program Tokens, though their usage can extend beyond programs in certain situations.

    But for the purposes of this explanation,  program tokens are something you set within a Marketo program. It’s not a piece of data unique to a lead (like a field token is). It’s a piece of data unique to a program.

    A practical example

    Think about a webinar as an example.  If you’re like most marketers, a typical webinar’s list of assets looks something like this:

    1. Invite Email
    2. Registration Page
    3. Reminder Email
    4. Follow Up Email (Thanks for Coming/Sorry We Missed You)
    5. On-Demand Webinar Page (for watching the recording later)

    While each of these are separate assets, and each serves a different purpose, they actually all contain a lot of the same information:

    1. Title of the webinar
    2. Date and time
    3. Event description
    4. Branding elements: banners, buttons, speaker photos, etc

    If you’re the person building out the webinar, think of the amount of times you need to re-enter all of these pieces of info. It’s time-consuming, and it’s where most mistakes happen. The wrong date gets entered, the wrong link to a landing page is posted, the list goes on, and for a webinar especially, a small error can actually be pretty disastrous.

    So the benefit of a program token is that you can set a token for something like the date and time of your webinar in one place, and have it automatically used in every area you reference it. Here’s how it works:

    1. On your webinar program, create a token with a unique name, in this example, let’s call it Webinar Date.
    2. Set what you want your token’s value to be: March 3, 2014
    3. Go  into each of your assets that references the date of the webinar, and instead of writing the actual date in each, use the token instead. So instead of saying “Join us on March 3, 2014,”, say “Join us on {{my.Webinar Date}}”.
    4. Once you’ve done this for all your tokens and all your assets, preview and test each asset. They should automatically populate with the information you set at the token level.

    So why does this all matter? For a single webinar, you may not exactly be saving much time by creating all these tokens. But suppose you’ve got the date wrong on one reminder email. If you miss it in your QA processes, you’ve got a big problem when your campaign launches.

    And then consider the implications if you’re running a webinar every month. Chances are, you’re following the same format for each webinar.  If you set tokens for all the event-specific stuff, you can simply clone the first webinar program you created, and just go in and change the tokens to match the new event details. If you do it right, you may not even need to go into the email and landing page editors at all. It can literally take your event production in Marketo down from a few hours to 20-30 minutes.

    I’ve been using webinars as the example here, but the concept of tokens can be used in limitless situations in Marketo.

    There’s also other, more out of the box ways to use tokens, including things like: graphical elements, embedded videos, hidden form data, and even straight HTML, CSS, and javascript.

    Hope this helps!