Skip navigation
All Places > Products > Blog
1 2 3 Previous Next

Products

359 posts

Hi Marketing Nation! As you may have noticed, the look and feel of content within Community has changed. These changes were made during the release of a new build last week. Unlike former builds, we are unable to return to revert to the old layout. 

 

We wanted to communicate the permanency of these changes and work alongside our customers to ensure Community remains the best place for Marketo knowledge, best practices, and discussions.

 

If you have any questions about the new layout, feel free to leave a comment below.

Despite instructing a Community member to “search my posts” the other day, I ran a search myself and there wasn’t a one-stop explanation of what Do Not Track (DNT) means in Marketo (on a deeper technical level than you get on the official doc page). So here goes.

 

As you probably know already, there are 2 DNT options, Ignore and Support:

 

 

We won’t worry about Ignore.

 

But what does it really mean to choose Support? On a technical level, it means one specific thing:

 

If a user’s browser sends the DNT: 1 HTTP request header along with a Munchkin-logged pageview or link click, Marketo will not save the activity to the Activity Log database.

 

So here are some things Do Not Track = Support does not do:

  • it does not stop gathering Clicked Email stats: email clicks are still tracked unless you separately turn off link tracking
  • it does not stop Munchkin JS libraries from loading
  • it does not stop Munchkin from initializing and setting its _mkto_trk cookie
  • it does not stop Munchkin from sending a Visit Web Page (assuming you're using the default configuration which always sends a VWP on startup)
  • it does not stop Munchkin from sending a Clicked Link for <a> links on the page

 

But again, here's the very important thing it does do:

  • it stops the Marketo platform from storing the Visit Web Page and Clicked Link hits sent by Munchkin

 

 

Why not stop Munchkin completely?

It's not that Marketo would not like to be more proactive on the browser side, I'm sure. But the weirdest thing about DNT is there's no programmatic (let alone cross-browser) way to know if the user has set a preference! Ergo, you cannot know if the person would've wanted you to turn off Munchkin downloading/initialization/hit logging. You have to dumbly send the hit in all cases, then the server will discard it if it's accompanied by the “please ignore me” header.

 

The privacy appeal of having the DNT setting be unreadable in the browser is clear — it's the equivalent of an HTTP-only cookie that can't be seen from JavaScript — but it certainly creates confusion. For example, someone with DNT enabled who’s also running Ghostery or similar will still see that the Munchkin tracking JS was blocked, which is suboptimal: ideally, it wouldn’t show up at all. You might seem like you’re being worse corporate citizens than you actually are. (A link on your Privacy Policy confirming that you honor Do Not Track is useful.)

 

 

The browser's-eye view

The browser sending the DNT: 1 header is a prerequisite, of course. Privacy-oriented browsers do this by default; other browsers do it in Private/Incognito/InPrivate mode only; the the rest do it for all pages/tabs/windows when selected. Here's the setting in an older version of Chrome, for one of a zillion examples, which will send DNT: 1 for all pages viewed in this user profile:

 

 

And here’s a screenshot of the HTTP request for the main document, showing the header:

 

 

And Munchkin’s Visit Web Page XMLHttpRequest, showing the same HTTP request header and its acknowledgment in the response:

 

In this edition of Marketo Master Class, Marketo Champion Chelsea Kiko takes a deep dive into the process behind building a Center of Excellence (CoE). Chelsea covers various considerations for building a CoE in both a fresh Marketo instance and existing instance, among other tips and best practices. Read on to discover how to build and maintain your own CoE, from implementation to long-term execution.

 

1. What are the benefits of setting up a Center of Excellence (CoE) within Marketo?

 

Setting up a CoE in Marketo is great for consistency, accuracy, and scaling your Marketo instance. CoEs typically contain programs that are often repeated and have the same type of operational steps. Users can clone these to create their own programs, which provides easy access to high-quality programs and scalability for your strategies. The other great aspect about a CoE is it can be built by an expert (either internal or external) and used by new users in the instance with the same type of consistency across the board. This also saves time and increases efficiencies for your team.

 

2. What are the essential components of a CoE? What are aspects will vary based on use case?

 

 

The first essential component of a CoE program or folder is a naming convention. This is one of the most important pieces in my opinion for CoE programs because when programs are cloned out, the naming conventions are automatically adopted. You should set up naming conventions for all assets, including emails, landing pages, forms, smart campaigns, programs, etc. Having uniform naming conventions for each program is vital to keeping the instance clean and consistent even when various users are working in Marketo. As you can see in the above screenshots, everything is ready to go, even sample email naming conventions. This is all pre-canned so you can clone, update, and have a program done much quicker than if you were creating from scratch.

 

Next, it’s key to build out templates for any operational programs you want to run. This could include programs to: change program status, increase lead score for specific programs, sync to your CRM, send alerts, etc. Once you have them built in your CoE, they are ready for you to edit or optimize for each program right away.

 

Finally, it is helpful to create templates or template styles for specific programs in your CoE. Once you clone the template program and the modules or email layouts are ready, all you have to do is edit tokens or change content/swap images. Even though modular email 2.0 templates are easy to use, it still saves time to have the right modules and layout of your email ready for cloning, especially if it’s an event or nurture program where you have several emails.

 

Be mindful of the fact that when you’re building your CoE you will probably be using different program types. In the screenshot below, there is an email program for a one-time send, a basic nurture program, a more advanced nurture program, and a live event.

 

The aspects of the program templates that will vary based on use cases will be your tokens, operational programs, list arrangements, and reporting. If you have the structure set, changing these aspects is quick and easy. You can easily adapt your programs by editing your CoE program templates, allowing you to scale your instance.

 

 

 

 

**Tip: If you are an agency or consultant, it really helps to have operational programs in the CoE. You can even create these in your sandbox and import the programs into any of your clients to help them with data normalization, lead scoring (customize it on the client), deliverability programs, etc.

 

3. What are some best practices for creating a CoE in a fresh instance of Marketo vs. building a CoE in an existing instance?

 

Creating a CoE within a fresh instance is definitely a different strategy than building one in an existing instance. Both have their pros and cons but let’s start with the fresh instance. When you are new to an instance, sometimes it’s hard to decide what your CoE programs will be. What we normally do for clients is:

1) Host discovery sessions to see which programs they are envisioning

2) Map the programs out beforehand

3) Show the internal stakeholders or clients to gain approval before we build

 

This helps us ensure they are on the same page. Also, having a visual of how your CoE operates is a great training and educational tool to those stakeholders outside of the system who don’t need to know the details of the Marketo instance, but need to understand how it works.

 

For an instance that is already in use, it is important to measure first then determine what the CoE will contain. For example, are there any programs that need to be refreshed or changed? If so, incorporate that in your CoE. Check to see what programs are built over and over again and standardize these for your CoE so people can just clone a single template program and update minimally. This makes the CoE useful for each Marketo user and guarantees you’re looking at real data in your instance as you build your CoE out.

 

4. How do you recommend aligning with key stakeholders when planning out the CoE?

 

When aligning key stakeholders for a CoE, you don’t necessarily need to dive into the weeds of how it will operate in Marketo. What I normally do is map out an example program for them to understand and align it to their business needs.

 

For example, the screenshots below show a template map I put together for a healthcare client where the stakeholders own the cancer service line. The first image lays out the process template that would live in the COE, including a landing page and three different email streams for three different messaging focuses they could include for that line. The second image lays out a customized program that was cloned from that process template. You have to alter your message for which stakeholder you’re educating. Normally if it is a marketing manager, who won’t be spending much time in Marketo, mapping out higher-level strategy is the best method to get them on board.

 

 

5. What is important to consider when rolling the CoE out to your teams?

 

Make sure you host trainings for your Marketo users. Usually I have the flow maps ready and then host live trainings where I go into the instance and demonstrate how to clone and update certain programs. For example, you don’t need to train an event manager (who owns the Marketo event programs) on how to clone a nurture template, because it’s not relevant to their work. Customizing your training to your users is crucial for the success of your CoE.

 

6. How do you set up processes to maintain that CoE over time?

 

Setting up processes to maintain the CoE is important for the long-term health of your instance. Normally the Marketo expert/admin should bear the responsibility of updating and maintaining the CoE. For example, let’s say your Marketo users keep cloning a nurture template but are adding more operational programs and emails to it, that should denote a CoE change. Your CoE should always contain the most updated programs that are ready to be cloned for your team. Sure, customization is always going to be added, but if the same programs or emails or reports are being added time and time again, it’s time to refresh your CoE. Lastly, I recommend taking a quarterly look at your CoE – maybe you added a new reporting feature in Marketo that you forgot to take into account in your templates, or maybe you’ve altered your webinar strategy – all of those changes need to be audited and monitored in the CoE.

 

**Tip: when building out your CoE, always use the description field to explain what each program does. This ensures success and helps train Marketo users on each of your CoE programs. Example below.**

 

Customers often ask about exporting Marketo Activity Data. This can be accomplished using the bulk activity API or the standard activity API.

 

Some things you might consider are...

  • Is this a one-time or a recurring activity export?
  • What activities do I need?

 

The bulk API is a good option when you want to get activities in a maximum 31-day timeframe. This is a great approach for a recurring extract with a start_date and an end_date. Once the file is ready for download, you'll be able to download a CSV of the data with the activity jSON parsed into columns. This approach has the following limitations

  • By default, Marketo instances are limited to 500mb of downloaded bulk data per day
  • Bulk api downloads are limited to a window of 31 day timeframe

 

The activity API is the better option for a wider window of activities "all activities in the past 12 months" for example. Up to 300 activities are returned per call, returned as jSON, along with a "has more records" flag and if appropriate, a "nextPageToken" to pass into a subsequent call This approach has the standard per- call limitations of the standard REST API, as follows

  • By default, Marketo instances are limited to 50,000 calls per day.
  • You may have up to 10 concurrent calls
  • You may execute up to 100 calls in a rolling 20 second window

 


Activity Types don't change for the great majority of Marketo instances (the exception might be extremely old Marketo instances). I've created a list of those types, here Activity Type Attributes - Common - Google Sheets  which you're welcome to download and use.

 

Activity Type Attributes are also shown to illustrate the fact that different activity types have different attributes.

 

Marketo Professional Services is happy to do this with or for you you, and for details you should reach out to your PS Engagement Manager who can help scope the effort.

Buried in a bunch of my Nation responses is this ginormously important guideline: whenever possible, use your Marketo LP domain in your form embed code instead of the default //app-something.marketo.com.

 

Once per week, I'd estimate, an admin solves their “forms sometimes not showing up” problem with this tiny tweak.

 

That is, if the embed code in the Marketo UI is:

 

<script src="//app-sj01.marketo.com/js/forms2/js/forms2.min.js"></script>
<form id="mktoForm_999"></form>
<script>MktoForms2.loadForm("//app-sj01.marketo.com", "123-ABC-456", 999);</script>

 

and your primary Marketo LP Domain (or a Domain Alias) is:

 

https://pages.example.com

 

then edit the embed code (after pasting on your external site) to be:

 

<script src="//pages.example.com/js/forms2/js/forms2.min.js"></script>
<form id="mktoForm_999"></form>
<script>MktoForms2.loadForm("//pages.example.com", "123-ABC-456", 999);</script>

 

The only and I mean only reason to avoid this change is if your external site requires SSL (https:) but your Marketo subscription does not yet include Marketo's SSL add-on. (Built-in browser security won't allow forms to load if you're in this unfortunate situation.)

 

In all other cases, you can and should switch over. Like, yesterday. That includes (1) when your external domain and Marketo LP domain both run over SSL (best practice in 2019); (2) when neither uses SSL (eh, it works); and (3) when the external site doesn't, but the Marketo domain does use SSL (strange but possible).

 

 

What's this about?

It's about tracking protection. If someone browses your site using Firefox with TP turned on, or with Ghostery or a similar plugin, they will not be able to load forms from app-*.marketo.com, because they can't load anything from domains matching *.marketo.*.

 

It makes sense that Munchkin (from munchkin.marketo.net) would be blocked, of course. That's what anti-tracking features/plugins are designed to do. But forms can be thrown out with the bathwater, if you will.

 

Yes, it's not really fair for all that matters! because form submissions require deliberate user action, and they don't inherently “track” anything but the Filled Out Form activity itself (assuming Munchkin cookies are blocked and all existing cookies were deleted).

 

But it's something we have to live with: Munchkin is fairly described as a tracker, Munchkin comes from the domain marketo.something and the major marketo.{tld} domains are of course all owned by Marketo. So, fair or not, privacy wins out... even if that means forms leave a blank space on your page for some end users.

 

By loading from your Marketo LP domain instead, you fully comply with the anti-tracking plugin (since you aren't dropping any new cookies or logging any more pageviews/clicks with Munchkin blocked) but also allow forms to be seen and be filled out. So do it!

 

 

Why isn't it the default?

Because of the SSL exception described above. Apparently, the Embed Code textbox in the UI and the underlying domain setup can't communicate. So the LP domain can't safely be the default, as not everyone can use it.

 

 

We're in the process of getting SSL on our Marketo LPs, but not sure if it's ready

If you have a pending order with Marketo, you can quick-check the state of affairs (for the purposes of this blog post) by loading the Forms 2.0 forms2.min.js in your browser. Here's Firefox's way of saying your custom cert isn't installed yet:

 

Here’s some information to help you sort things out when you hit an API limit.

 

First here’s a great article about API usage

http://developers.marketo.com/blog/best-practices-for-api-users-and-custom-services/

Summary of the article:

If you have multiple web services creating individual API users is recommended:

  • It is easier to understand what data each web service is being given access to and allows you to create different API roles with different permissions if necessary
  • Reporting on API call usage will be broken down by user

 

If you are not is not using the Bulk API the error is#607 “Daily quota reached” when you’ve hit the limit.

https://developers.marketo.com/rest-api/error-codes/

 

A temporary solution is to contact Marketo support and see if they will raise the limit. If you need a more permanent solution contact your Customer Success Manager and purchase more daily API calls.

 

For more info about API limits please check out

http://developers.marketo.com/rest-api/marketo-integration-best-practices/

 

If you are using the Bulk API according to the documentation the daily quota is a maximum of 500MB per day, which is shared between leads and activities. When the quota is exceeded, you cannot Create or Enqueue another job until the daily quota resets at midnight Central Time. Until that time, an error “1029, Export daily quota exceeded” is returned.  Aside from the daily quota, there is no maximum file size.

 

You can contact your Customer Success Manager and purchase a higher daily extract limit. The increase can be purchased for just a month.

Bulk Extract Additional 1GB

Bulk Extract Additional 3GB

Bulk Extract Additional 5GB

Bulk Extract Additional 10GB

 

For more info about the Bulk API check out

http://developers.marketo.com/rest-api/bulk-extract/

 

If you are using an ELT Extraction Tool and experiencing an issue you should check with the vendor since its most likely Marketo support isn't familiar with the tool you are using and won’t be able to troubleshoot it.

 

I hope this article helps you troubleshoot your issue faster. BTW, I'm not in charge of setting the limits or the prices. I'm also not in charge of what the error codes. Thanks! 

A clear symptom of broken custom JS is when you see form fields, in URL-encoded format, in the location bar after clicking Submit:

 

5c886b174c52a500bf5f9c28_fields_in_url_url.png

 

You should get to know the cause on sight: an uncaught error has been thrown in a custom Forms API onSubmit function.

 

To replicate this, just set up an otherwise empty page with your form embed and this purposely bad JS:

 

MktoForms2.whenReady(function(form){
form.onSubmit(function(form){
form.oohlala(); // the property `form.oohlala` will never exist
});
});

 

This code won't throw any early errors on page load, because it doesn't have a syntax error. There's no way for the JS engine to know that form.oohlala will end up being a nonexistent method at runtime, it just adds the onSubmit listener happily onto the form.

 

However, when the form is actually being submitted, Marketo runs your custom onSubmit function. Then the browser gets serious and throws a hard TypeError, as you can see in the Dev Tools console (make sure to check off Preserve Log or you'll miss it people don't realize this behavior is always, without exception, a JavaScript error because they fail to prepare their debugging environment ahead of time).

 

Here's the runtime error:

 

5c886b174c52a500bf5f9c28_fields_in_url_console_error.png

 

But why does a JS error result in fields in the URL?

It's simple. Marketo forms use a true HTML <form> tag (this is A Very Good Thing™) and standard <input>/<select>/etc. elements under the hood.

 

The Forms API, among many other things, is responsible for transforming the standard W3C submit event into an elegant cross-domain POST to your Marketo instance.

 

In an error-free environment, the standard submit is swallowed by the Forms API's robust set of handlers. The event is triggered, but its default action that is, sending fields to the form's action (destination URL) using its method (HTTP method) is turned off. The API's non-default actions take over.

 

But when there's an error thrown within the Forms API listener stack, the form reverts to standard HTML form behavior as the default action doesn't get a chance to be turned off.

 

The Marketo <form> element doesn't have a specific action or method[1], i.e. it looks basically like so:

 

<form>
<input name="Something">
<input name="SomethingElse">
<button type="submit">Submit</button>
</form>

 

The default value for method is GET, and the default value for action is the empty string which represents the current URL. So the effective markup is:

 

<form
method="GET"
action="https://whatever.example.com/the_current_page.html">
<input name="Something">
<input name="SomethingElse">
<button type="submit">Submit</button>
</form>

 

When the button is clicked with this markup, and there's a JS error, the browser reverts to a standard GET of the current URL with form fields in the query string:

 

https://whatever.example.com/the_current_page.html?Something=a%20value&SomethingElse=another%20value

 

Whenever you see this behavior in your browser, realize your forms aren't working at all (even though the form seemingly "posts" somewhere). So fix em!

 

 

 


Notes

[1] Nor does the <button> have the newfangled formaction or formmethod attributes, which would be used if present.

In this edition of Marketo Master Class, Marketo Champion Juli James took some time to share her expertise on the topic of forms and gated content. Specifically, she explores the best scenarios to utilize forms, gated content best practices, and leveraging progressive profiling to get the most out of your Marketing efforts. Read on to discover how Juli uses forms in conjunction with gated content to seamlessly gather data without disrupting the customer experience.

 

1. What are the benefits of Marketo forms?

The benefit of using Marketo forms is pretty simple. The forms are easy to create, plug into campaigns, and ensure that data is being captured for any of your content-driven campaigns, whilst also allowing you to monitor real time content downloads and report out on what content is getting the most engagement.

 

They’re also great to use for event registration as you can tie the form to your event campaign, put it onto the event registration landing page and the monitor real time registrations. I’ve also recently been playing around with real time content delivery at events.

 

The beauty of Marketo forms is that you can add any CSS you want to it, as well as add some cool Javascript to make the forms look and behave in the way that you want to, without needing to get developers or IT involved. And then you can use them to scale your campaigns.

 

There are obvious examples of when you must use a form, such as capturing event registration. Tracking of all event registrations is imperative, whether online or offline. Having the registrations via Marketo forms means that you can send out confirmations, reminders and updates automatically using trigger campaigns, rather than having to download registration information from somewhere else and uploading to Marketo.

 

2. What situations warrant global vs. local forms?

I will always lean towards global forms as much as possible. Purely down to a scalability factor. A bit like CSS for websites, if you need to make a change to a form and you’re using global forms, then you only need to make that change in one place and then bulk approve the landing pages from design studio. If you had only local forms then you would have to go into each campaign and adjust each form.

 

 

An example would be when GDPR was introduced. I’ve heard various horror stories of people having to go into 600+ forms to add the GDPR rules for opt-in, rather than just going into 1 form and bulk approving 600 landing pages, which takes minutes vs. hours.

 

However, there is sometimes a need for local forms. I would suggest using local forms if your program requires specific data to be collected. For example, say you have an event where you are required to ask guests their dietary needs, or t-shirt size, or your field marketing manager wants to collect specific interests that won’t be relevant elsewhere. A local form would fulfill that need.I would also suggest a local form if you have to do a specific campaign in a different language. I’ve worked on landing pages in multiple languages but they’ve only been created once or twice, so then I would only create local forms as its highly unlikely they’ll get used again. If I find that I’m using a form more than a few times, I’ll add it to the Design studio and start using as a Global Form, although I try to keep the number of Global Forms down as well.

 

3. What type of content do you leave ungated? What content is important to gate?

I try my hardest to not leave content ungated, but rather to use the ‘Known Person’ option on the form to provide a simple ‘download now’ button instead of a form, or I like to use a Marketo Partner such as Uberflip that will track content downloads without the need for too many forms.

 

The whole point of gating content is to track who is engaging with the content you are providing and creating. Moreover, having gated content will help with tracking which content is providing the most conversions to analyze which content is the most effective. If you left all content ungated (as is the suggestion of some industry experts), then there is no way to track and convert potential new customers. It also depends on the value of the content. I would not gate an infographic for example, but I would most definitely gate a whitepaper or analyst report.

 

4. How do you synchronize progressive profiles built from forms/gated content with your marketing campaigns at large?

I like to use progressive profiling forms to build up records user profilesto further segment and personalize the types of campaigns that are being sent out. For example, if I’m using ‘Industry’ on a form it’s because I want to further segment down the industries into Strategic Business Units using an approved segmentation. Having data segmented means that emails can now be sent out using dynamic content based on segments.

 

This is especially useful for Nurture campaigns if you work with multiple languages. You can set up your segmentation based on the country information that has been populated from the progressive profile form and then use those segments to create dynamic content to send the same email in the preferred language of each record.

 

 

 

5. What are some of the most underutilized features on forms?

Prior to GDPR I would have said the most underutilized feature on forms were the visibility rules. Having the ability to only show certain fields when other fields on the form are completed is a great feature! If you’re not using visibility fields for anything on your forms, and especially for GDPR you should look into it.

 

 

You can also set up field sets to be shown dynamically based on visibility rules too:https://docs.marketo.com/display/public/DOCS/Add+a+FieldSet+to+a+Form

 

Another feature that really isn’t used enough and that Sanford Whiteman has recently authored a post about is the use of the ‘known person’ option in the Settings section of the Form editor. He talks about not just showing a button rather than the form, but also how to set up an Auto Submit for known users, which will help to provide an excellent customer experience for those users who are already in your database, whilst at the same time recording the ‘Form Fill’.

 

One last feature that I don’t see utilized very often but could be helpful is Input Masking, to ensure that values being put into certain fields are formatted in the correct way for data cleanliness:https://docs.marketo.com/display/public/DOCS/Apply+Input+Masking+to+a+Field+in+a+Form

 

 

6. What’s one tip about forms/gated content that you wish you learned sooner?

Over the last few months I have be working more with CSS and JavaScript on forms to manipulate them in a way to perform exactly as requested. For example, Sanford also wrote a post a while ago about adding JavaScript to forms:

 

And there are some great tips for form manipulation for embedded forms using JavaScript on the Developer Site too:http://developers.marketo.com/rest-api/assets/forms/examples/

I really wish I’d learn that you could do more than just create a form and play with the CSS a long time ago.

 

I’ve also recently learnt how to add 2 forms to one page with some JavaScript, and that was a technique that I wish I had a long time ago. Below are how it looks on the Landing Page, the HTML on the landing page and the custom

 

Screen Shot 2019-02-19 at 11.17.41 AM.png

7. Are you planning to try anything new with forms/gated content in 2019?

For 2019 I plan on working more with Velocity Script in conjunction with Form fills so that real-time content delivery can happen at events. For example, having an iPad with a form on showing content related to that event, and then the users can select which content they find interesting and have that delivered in real time to them via email. This will save the need for a lot of collateral being printed, but it will also help to grow the database organically.

 

I’m also hoping to spend more time with form CSS to improve the customer experience and look of forms across various platforms. I think CSS alongside Javascript and Velocity Script can make for some really interesting user experiences for known and unknown records looking for content. For example, forms that auto submit in the background for known users so they get direct access to the content without having to resubmit the same information numerous times would allow for a more frictionless customer experience. Essentially, if less clicks are required between a lead and the content they are likely to consume, it’s much easier to move along the funnel.

 

 

We hope you enjoyed reading about how Juli James is leveraging forms and gated content seamlessly gather data without disrupting customer experience. If you have any examples of how you've used these features to better engage with your customers, please let us know in the comments!

 

You can find more informative content in the brand new edition of our customer newsletter, the Fearless Forum.

Printing fallback content when a Lead field is blank is a basic Velocity task. You can do it in a few lines of clunky code... but that's a few lines too many!

 

Seeking a one-liner, you might reach for Velocity's built-in $display.alt. But that won't fill the bill in Marketo-land. You see, $display.alt($field, $fallback) outputs the fallback if the field is null. But null isn't the same as the empty String that Marketo uses for unfilled Lead fields.

 

Therefore, the code

 

Dear ${display.alt($lead.FirstName,"Friend")},

 

will only ever output

 

Dear Joe,

 

or

 

Dear ,

 

It will never fall back to

 

Dear Friend,

 

because Marketo ensures $lead.FirstName is always a String of some kind, never null.[1]

 

So without any other tools at your disposal, you're left with a typically wordy #if block:

 

Dear ##
#if( $lead.FirstName.isEmpty() )
Friend,##
#else
$lead.FirstName,##
#end

 

This will work fine, but as your scripts get cluttered with repeats of this same structure, you start to go a little crazy.[2]

 

The good news is there's a short Velocimacro you can include globally that greatly lightens the load. Once you set up the #displayIfFilled macro, you can reduce the logic to one easy-to-read line:

 

Dear #displayIfFilled($lead.FirstName, "Friend"),

 

Building #displayIfFilled

Here's the macro definition:

 

#macro ( displayIfFilled $checkValue $fallbackValue )
#if( !($checkValue.isEmpty()) && !($checkValue == $context.get("0")) )
$!checkValue##
#else
$!fallbackValue##
#end
#end

 

As you can see, #displayIfFilled takes 2 self-explanatory arguments: the field to check for filled-ness, and the fallback value.

 

#displayIfFilled is designed to treat null the same as the empty String. It thus covers a superset of the cases covered by $display.alt, so you may never be tempted by the latter function again.

 

Step further out: #displayIf

We can abstract the functionality of #displayIfFilled into a more general #displayIf:

 

#macro ( displayIf $truePredicate $trueValue $falseValue )
#if( $truePredicate )
$!trueValue##
#else
$!falseValue##
#end
#end

 

#displayIf takes 3 arguments: a Boolean, the value to output if the Boolean is true, and the output if the Boolean is false.

 

To emulate #displayIfFilled, pass an isEmpty() check as the first arg (the $truePredicate):

 

Dear #displayIf($lead.FirstName.isEmpty(), "Friend", $lead.FirstName),

 

Lots of tricks up your sleeve with #displayIf.  Say you want to switch output based on a specific non-empty value

 

Your #displayIf($lead.trialType.equals("Other"), "VIP", ${lead.trialType}) trial is almost over!

 

or output based on a date/time property

 

Good #displayIf($calNow.get($calFields.AM_PM).equals($calFields.AM), "mornin'", "aft'noon")!

 

or anything that can be expressed as if-then-else!

 

Of course, #displayIf can be overused; past a certain point of complexity, you should be using #if-#else on separate lines. But where a one-liner doesn't hurt readability, I say use it. #displayIf is critical to my sanity (if I have any left) as an avid Velocity coder.

 

Stay functional

There's another detail that you'd eventually learn on your own, but I'll spoil it to save you time.

 

When passing macro arguments in parentheses, you can include any chain of function calls but not syntactical expressions. For example, though Boolean operators and expressions are valid in other parts of Velocity, you can't do:

 

#displayIf(!$lead.FirstName.isEmpty(), "${lead.FirstName}'s", "Your") special offer is ready!

 

That won't compile because of the !. Velocity's parser doesn't accept operators  in that place (nor would it accept <, > or == operators there).

 

Instead, either chain with the equals() function:

 

#displayIf($lead.FirstName.isEmpty().equals(false), "${lead.FirstName}'s", "Your") special offer is ready!

 

or as some programming style guides suggest anyway don't rely on negated Booleans and instead put your true case first:

 

#displayIf($lead.FirstName.isEmpty(), "Your", "${lead.FirstName}'s") special offer is ready!

 

To be clear, this doesn't mean you can't use all manner of operators and expressions to construct Boolean values, you just can't use them directly inside the parentheses when calling a macro. This will work fine:

 

#set( $hasCompany = !$lead.Company.isEmpty() && !$lead.Company.equals("N/A") )
Is #displayIf($hasCompany, $lead.Company, "your family") in the mood for pizza?

 

Disrupts the dream of a one-line solution, though.

 

What's with $context.get("0")?

Ah, yes. I don't want to overwhelm you earlier with the details of null checking in Velocity.

 

$context.get("0") (up above in the first #displayIfFilled macro) gets the value of a reference that is guaranteed to not exist, i.e. guaranteed to be null, in any Velocity context.

 

Why is it guaranteed to not exist? Because neither Java nor Velocity variable names are allowed to begin with a number.

 

Why not compare to the literal null? Because and this reality sneaks up in other important places in Velocity there is no four-letter keyword null! The null-ability of injected data is honored, even favored, in Velocity, like by $display.alt as noted above. But it doesn't have a keyword to create new null values easily.

 

So you have to find a roundabout way of getting a reference to a null value. Elsewhere on the net, people say "just use a variable you didn't #set anywhere else, like $abcdefg, as that will naturally be null." The flaw in this reasoning is nothing actually stops someone else (either a future coder or a current collaborator) from using $abcdefg for something else.  So I prefer to use a reference that cannot exist even by coincidence.

 

 


 

 

Notes

[1] In the Marketo Lead/Person world, you aren't gonna run into literal null values, but rather empty strings. This is true despite non-filled fields being represented as [null] or NULL in parts of the Marketo UI.  You can and will encounter null with Custom Objects, though. That's the stuff of another post.

 

[2] Yes, you could smush the VTL into one line. But if you think Dear #if($lead.FirstName.isEmpty())Friend#else${lead.FirstName}#end, is sufficiently readable, you're made of stronger stuff than me.

This JS string-splitting approach is a sure code smell, but I see it all the time on LPs:

 

var partsOfString = stringifiedLeadInfo.split("|");
var firstName = partsOfString[0];
var lastName = partsOfString[1];
var companyName = partsOfString[2];
var phoneNumber = partsOfString[3];
/* ... and so on and so on... */

 

 

Presumably stringifiedLeadInfo when the code was first written was a string like

 

Sandy|Whiteman|FigureOne, Inc.|212-222-2222

 

But this code is clearly fragile: there's no guarantee that the “magic numbers” 0, 1, 2, and 3 will continue to represent the same data (business-wise) inside the string.  If order shifts around at the source, or if a new data point is added in the middle, all these lines may need to change. That leads to bugs.

 

Instead, use what I call a header string. It's nothing more than a sample string containing the variable names in the currently expected order

 

var delim = "|",
    stringifiedLeadHeaders = "firstName|lastName|companyName|phoneNumber",    
    leadHeaders = stringifiedLeadHeaders.split(delim);

var leadInfo = stringifiedLeadInfo
                 .split(delim)
                 .reduce(function(acc,next,idx){
                   acc[leadHeaders[idx] || "Unknown_Property_" + idx] = next;
                   return acc;
                 },{});

 

 

Now, leadInfo is a simple object:

 

{
  firstName: "Sandy",
  lastName: "Whiteman",
  companyName: "FigureOne, Inc.",
  phoneNumber: "212-222-2222"
}

 

 

And you only need to change the header string if the data starts coming in differently. No other lines need to be added or changed. 

 

(I also made the delimiter a variable, ’cuz that could change too. And if new data points appear in the data before you add them to the header, they're given automatic names like Unknown_Property_5 to help signal the change.)

 

Please use this — or something along these lines, there are other methods with the same effect — in your code. It makes it less painful to read (scrolling through 25 variable assignments ain’t fun) and because of my curious specialty I spend a lot of time reading other people's stuff.

 

Do it in Velocity, too

The equivalent can be done in any language. Always better than magic numbers, IMNSHO. Here's the comparable VTL:

 

#set( $delim = "\|" )
#set( $stringifiedLeadHeaders = "firstName|lastName|companyName|phoneNumber" )
#set( $leadHeaders = $stringifiedLeadHeaders.split($delim) )
#set( $leadHeadersCount = $leadHeaders.size() )
#set( $leadInfo = {} )
#foreach( $next in $stringifiedLeadInfo.split($delim) )
#if( $foreach.index < $leadHeadersCount )
#set( $void = $leadInfo.put($leadHeaders[$foreach.index], $next) )
#else
#set( $void = $leadInfo.put("Unknown_Property_${foreach.index}", $next ) )
#end
#end

 

 

The main difference here (Velocity's verbosity aside) is that Java's String.split always treats the delimiter as a regular expression, not a simple string. Since the pipe symbol "|" has special meaning in regex-land, I escaped it as "\|" to treat it non-specially. Character class "[|]" would also implicitly escape the pipe.

 

(JavaScript's split(delim) also supports regexes, but the language can tell the difference between a "string" and a /regex/ so you don't need to escape strings.)

 

Better yet, don't give yourself the need to split

It could be argued that all string splitting is smelly, and this improvement is just code cologne.

 

Indeed, the best string-splitting code is the code you don't have to write, because you store multivalued fields as JSON or some other well-known, self-describing  format. Private formats with pipes, semicolons, or commas are to be avoided when possible. We'll never completely get away from them, though, and they’re admittedly efficient storage-wise.

A majority of customers find their consultants to be their most valuable resource during their Marketo onboarding. However, we also know your time with them is limited. Check out the following advice - most of it sourced from Marketo consultants themselves - on how to optimize your onboarding experience right from the get go.

 

What are some of the pitfalls I should look out for during onboarding?

  • Users that don’t look at Marketo learning resources or take Marketo-recommended trainings before working with their consultant will often end up spending valuable consulting hours trying to understand basic Marketo concepts. Take some time to check out the Marketo University free trainings, Marketo University Online, or purchase the Marketo Core Concepts course.
  • Start thinking long-term about content you’ll be using for your Marketo programs. Which type of email and landing page assets will you need? Are you producing creative assets from scratch or repurposing content from previous marketing campaigns? Creating those Marketo program may seem far away now, but waiting on creative assets can often be an unforeseen bottleneck.
  • Build out your Marketo documentation as you set your instance up instead of trying to document it all after your implementation. This makes the task of recording your Marketo admin choices much easier and helps you make informed decisions throughout your implementation.
  • Because Marketo often pulls in data from a CRM (and sometimes pushes out to it, too), data quality can have a huge impact on your Marketo implementation. If you have the time and resources available, clean up your data before integrating with Marketo.
  • Many companies don't have clearly defined, consistent processes to manage lead handoffs between marketing, telemarketing and sales. If they do, they often only have them for prospects, and not for existing customers that research additional products. Take the time to connect with other teams and map these strategies out while you’re building in Marketo to ensure you will get the most out of your use of the platform.
  • Be sure to involve your leadership in the implementation right from the start. Leaders that are hands-off won’t always understand the capabilities of Marketo, whereas leaders who are involved and invested in Marketo can help set you up for long-term success.


How do I make the most of my consulting hours?

  • Be sure to complete the recommended Marketo trainings before getting started with your consultant. That way, you can spend your time working through your implementation and not on Marketo basics.
  • Submit support tickets on your own - it’s good practice, plus you won’t be using your consulting hours for this.
  • Make sure you’ve contacted the teams that need to get involved early. You don’t want to get on a call with your consultant and be waiting on a deliverable from IT or Sales Ops because they didn’t know they had a role in onboarding Marketo.
  • Set some time aside to do a bit of learning on your own each week. Check out the Marketo Product Docs and Marketo University videos.


Where should I go if I need help during my onboarding?

  • Ask your consultant for instance-specific questions.
    • Note: Asking your consultant for help outside of your regular meetings will generally eat into your consulting hours
  • Submit a Support ticket on the Marketing Nation Community.
  • Check out the:
    • Marketo Product Docs - how-to guides on Marketo features
    • Marketing Nation Community - open forum with blog posts, product discussions, Q&A with fellow users, and the Support portal
    • Support Office Hours - available to customers with the appropriate Marketo Launch Pack; regularly scheduled time to bring your questions to Marketo consultants
      • Note: These are only available to customers who have purchased a Marketo Launch Pack. You must register before each session in order to attend these office hours.
    • Partner Blogs - our extensive partner ecosystem is a huge asset for Marketo users. Search through Marketo Partners’ sites and blogs for additional tips
    • Peer Content - sometimes typing out your question in Google will bring up some awesome content from other Marketo users!

 

 

A huge thank you to the Marketo Professional Services Consulting team for sharing their knowledge and advice with customers!

 

Hello Marketing Nation!

 

Today we are thrilled to announce the Class of 2019 Marketo Champions! Each member of this group has proven themselves to be a steadfast Marketo brand ambassador and a valuable asset to the Advocate Nation. Their expertise will be critical in enabling their peers to drive even more success with Marketo in 2019.

 

We also want to thank the hundreds of customers who applied to become a Marketo Champion this year. Your passion for Marketo made determining this year’s Champions very difficult. We are humbled by the turnout and look forward to your continued participation in Advocate Nation. Please join me in welcoming this year’s Marketo Champion class!

 

Also, Marketo CMO Sarah Kennedy would like to share a few words to the incoming class of Marketo Champions:

 

 

NameCompany
Ajay SarpalAryaka Networks
Amanda ThomasAlert Logic
Amber HobsonApplied Systems
Amy ConnorThousandEyes
Ann Marie GastineauOptiv
Ashley LangfordGreenSky
Bekah WaltersWorkiva
Beth MassuraUniversity of Chicago
Brooke BartosWalker Sands Digital
Carissa RussellCurrent powered by GE
Carrie ChandlerGenworth Mortgage Insurance
Chelsea KikoHileman Group
Chloe PottNexthink
Chris WilcoxHartford Funds
Darrell AlfonsoAWS
Devraj GrewalZuman
Elicia ChenLiveRamp
Grace BrebnerTourism Holdings Limited
Helen AbramovaVerizon Enterprise Solutions
JD NelsonSpigit
Jenn DiMariaDigital Pi
Jenny RobertsonANNUITAS
Jessica KaoDigital Pi
Joe ReitzAWS
Juli JamesSt. Edwards University
Karan HariWunderman\MSC
Kevin WeisenbergerDaVita
Kristy MurphyVerizon
Kyle McCormickPalo Alto Networks
Loren PosendeckDuo Security
Maarten WestdorpInnogy SE
Michelle TangCloudflare
Mike ChiuPanasonic Corporation of North America
Natalie KremerMcGraw-Hill Education
Omar Al-SinjariMcKesson/RelayHealth
Sean BissellSAP Concur
Sydney GordonCloudPassage
Sydney MulliganEtumos
TJ PerrinXylem
Trent CrossSolomon Solution

 

You can find all of their Community and LinkedIn profiles here!

While there's no perfect recipe for success for your Marketo implementation, most Marketo users can agree on two things that'll make the process a whole lot smoother:

1. Plan ahead of time: It's always a good idea to keep a plan or timeline around your implementation so you can make sure you're hitting your goals and pulling together the resources you'll need well in advance. Remember that implementation is an ongoing process and building some flexibility into your plans will help you stay realistic about your plan.

2. Get your leadership involved: Leadership buy-in and support is a huge differentiator for long-term Marketo success. Keeping your internal stakeholders aware of your goals and up to date on your onboarding process will make sure they feel invested in the process and in Marketo. Whether you're scheduling regular meetings with them or sending out an update email each week, maintaining regular contact will make sure they're on the same page as you and will help them manage their expectations around your organization's Marketo onboarding.

 

Check out the attached resources to help you get started:

1. Onboarding Milestones Template: Use this template to outline some specific milestones during your onboarding and identify the teams and resources you'll need to engage before you go live.

2. Internal Communications Guide and Template: Once you have your milestones laid out, use this guide to draft regular updates to your key stakeholders.

 

Have a couple tips or implementation advice of your own? Help your peers out and share them in the comments below!

By now, you've probably heard the exciting news: Marketing Nation Summit is taking place at Adobe Summit, March 24-28, 2019 in Las Vegas!

 

Why? Because, now that you’re part of the Adobe family, Adobe and Marketo couldn’t wait to engage with you and connect you with an even larger community of passionate marketers. Integrating Marketing Nation Summit into Adobe’s event allows you to not only enjoy all of the usual Marketing Nation activities, but gives you the opportunity to connect with the broader Adobe ecosystem and benefit from multiple days of additional breakout content covering every area of interest to modern marketers in 2019.

Together with 15,000+ marketers, advertisers, data scientists, and other experience marketers, join us for four inspiring and action-packed days. Learn more about how Marketo integrates with Adobe Sensei, Adobe Experience Cloud, Adobe Analytics, and much more. Marketo will be integrated throughout the entire event, including the community pavilion (exhibit hall), general sessions, and networking events—plus, we have added a dedicated day on Thursday, March 28, specifically focused on bringing together the entire Marketing Nation for compelling content breakouts sessions, and most importantly, opportunities to celebrate our achievements together.

 

Tickets are on sale now and all Marketo customers will be offered a discounted ticket price of $1,195 (originally $1,895). To purchase tickets, register here and enter promo code S19MN.
 

Stay tuned for more information in the coming weeks, including:

  • A full list of Marketo sessions
  • Marketo’s University Day and opportunities to get your Marketo certification
  • Plus, regional events for the Marketing Nation community happening around the globe throughout 2019, such as Adobe Summit EMEA in London (May 13-16, 2019)


Questions? Please don’t hesitate to reach out to summitsupport@adobe-summit.com.


Best,
 

The Marketo Team

“Imagine you win the lottery today and quit your job tomorrow. Would someone be able to step right in and take over your Marketo instance?” This is the mindset Tori Forte, Marketo consultant extraordinaire, recommends as you’re thinking about documenting your Marketo instance. In fact, good documentation can be nearly as important as the actual implementation itself. Keeping track of changes and decisions you’ve made during your instance setup can help you:

  • More easily train additional users in a scalable way
  • Build more efficiently in Marketo long-term
  • Maintain the health and hygiene of your instance moving forward
  • Make the transition process much smoother for a new Marketo admin if your team experiences any turnover


There are a couple different types of documentation you can produce. A governance guide outlines your instance setup in detail with topics such as program/folder structures, communication limits, and more. This would be a living document that users would turn to in order to identify your specific best practices and governing standards for your Marketo instance, and would mainly be for your Marketo admin or main user. In addition to a governance guide, your team may need supplemental enablement documents or training materials to help them get up to speed with Marketo. These could include exercises to practice working with the platform, quizzes to pass before being granted access, or a list of what your users are allowed to do in Marketo. These would be aimed at all Marketo users in your organization.
Whether you’re putting together a full blown governance guide or are simply documenting the key aspects of your setup to start, writing down the decisions you make during onboarding will help you and your team be successful with Marketo.

Getting Started on Your Documentation

Having trouble getting started on your guide? Tori suggests first focusing on the most important aspect of your Marketo documentation: your Admin Setup. “Make sure you’re writing down all of your behind-the-scenes decisions so if anyone needs to take over your Marketo instance, they’ll be able to understand how and why your instance was set up the way it is.” It’s crucial, Tori points out, that you “don’t just document what was built, but why it was built that way.” This helps a future admin (or even future you) avoid repeating decisions that didn’t work out or wasting time going down dead ends.

 

Another recommendation from Tori to establish the success of your documentation is to “ensure every rule you make has an owner to enforce it down the line. Lack of enforcement makes writing those rules moot.” Check in with your team and put a process in place to make sure this documentation will continue to adapt and stay relevant, as well as stay top of mind for your users.

Tips and Tricks

Whether you’re documenting a new/existing instance or creating training resources for your organization’s Marketo users, consider these tips from one of our resident Marketo experts, Kylie Peters:

  • Over-document, over-communicate, over-test! If it feels like you’re doing enough, you might not be doing enough.” You never know what might be useful to you or your team in the future, so be sure to add in details and keep other teams in the loop!
  • Be ‘new-hire-minded’. Write the documentation for someone who’s never used this technology before.” Once you become familiar with Marketo it can be easy to take a lot of background knowledge for granted. Make sure you’re creating your enablement and governance documentation with the most basic user in mind. Consider including some definitions and best practices directly into your training documentation if they’ll help new users get up to speed.
  • People have different ways of processing and understanding information so it helps to use a combination of written points, pictures, videos, and hands-on exercises in your trainings.” Instead of just writing a block of text to send out to your team, include some interactive content or a couple different formats within your enablement documentation and training.
  • Run the documentation by someone who’s never seen Marketo before and ask them if they have any questions.” Not sure if your governance and enablement documentation is clear? Ask someone who’s never used Marketo to take a look and see if they can follow your trainings. This will give you a good fresh perspective on what you’ve put together and how you can improve it.
  • “It’s important to remember that training documents are very different based on your needs and your instance.” Unlike governance guides, which should be as comprehensive as possible, enablement documents should be produced based on your organization’s need. Keep in mind that what might be important to document in detail for one instance or one user could be less relevant for others. You should know your instance and users best, so create your training documentation accordingly.



Marketo Documentation Sample Topics

Use these topics to guide your initial Marketo governance documentation plan. It may help to take it slow and start with a few topics that are important to your particular instance, then expand from there.

 

  • What is Marketo and what are its purposes for our organization
  • Purpose of this Documentation
  • Process to Maintain/Make Changes to Governance Guide
  • Administrative Set Up
    • Instance(s)
    • Workspaces and Partitions
    • User Roles and Responsibilities
    • Smart Campaign/Email/Program Settings
    • Communication Limits
    • Security
    • Channels
    • Tags
  • Data Structure
    • Field Structure
  • Operational Programs
  • Building In Marketo Instance
    • Center of Excellence (COE)
    • Folder Structure
    • Naming Conventions
    • Program Organization
    • Templates
    • Standardized Processes
    • Checklists
    • Segmentations
    • Archiving
    • Subscription Center
  • CRM Integration
    • How does the sync work
    • Campaign Sync
    • Data Dictionary
  • Other Integrations
  • GDPR & Compliance

 

Check out an example of Channel Documentation here.

 

Start documenting your instance today! Be sure to involve your whole team - whether that’s just you or a team of 10 - and revisit these docs every month to keep it up to date as your use of your Marketo instance grows.

 

To regularly receive content to help you through your Marketo onboarding and implementation, sign up for the Marketo Jumpstart series.

Filter Blog

By date: By tag: