Marketo released Self-Service Flow Steps (SSFS) last summer and I’ve been shocked that more people haven’t been talking about it. I’ve been working with Marketo over a decade, and for me this is an absolute game changer. I have spent the past year building dozens of custom flow steps for various clients, and I’ve been amazed with the things we’re able to do that were previously impossible. The biggest challenge I’ve had is the lack of information available. While Adobe has done a great job with the documentation, there doesn’t seem to be many people in the community using this feature, or at least none writing about it. That is why I want to share my experience. In this post I’m going to discuss what Self Service Flow Steps are, and how they solve 5 major limitations of webhooks. In future posts I will dive deeper into the Self-Service Flow steps capabilities, limitations and detailed guides on how to build them from simple no-code solutions to more advanced deployments.
First, what are Self-Service Flow Steps?
In Marketo smart campaigns are where all of the action happens. If you are a Marketo user, you are probably familiar with this list of flow actions. And if you’ve used Marketo for a while you’re probably also aware that this list hasn’t changed much over the years. Sure, it has most, if not all of the core features you could want as a Marketer. But as Marketers we are always pushing the limits and often times there are advanced or custom features you really wish it had that just aren’t there. If this hasn’t happened to you yet, I promise you it will!
Fortunately for us this is where Self-Service Flow Steps come in. Self-service flow steps allow us to expand our list of flow actions, adding custom actions beyond the typical pre-defined ones. This means that virtually any action you need – from validating emails and updating e-commerce orders to sending WhatsApp messages or even utilizing AI, can now be incorporated into your smart campaigns.
How are they different from Webhooks?
In my view, Self-Service Flow Steps are not an alternative to webhooks, but rather an evolution. While they both allow us to connect Marketo to outside services, passing data out, and return data back, these new flow steps solve 5 major limitations webhooks have had since their inception.
🟥 Webhooks only have one flow action which they all share – “Call Webhook” and the only option you have within this action is to select which webhook you want to call. This means there is no variability between one campaign and the next. For example, we have built a process that allows us to set registration limits for programs. When called, it checks the set limit and number of people currently registered, then either registers the user, or waitlists them. However, with webhooks that limit can’t be set on the flow step, it has to be static or set as a program token which is a bad user experience and ripe for user error.
✅ Self-Service Flow Steps in contrast, allow customizable flow step fields which can be set in each smart campaign providing a much improved user experience, cutting down on uncertainty and errors. This alone expands the possibilities well beyond what webhooks are capable of, as each flow step can be highly customized at the flow level.
Notably, these fields also include dynamic dropdowns which get their options from a backend service. For example, when we launched our OpenAI Flow Step it only had support for the gpt-3.5-turbo model, but when the gpt-4 model was released, we were able to automatically make it an option for everyone with the flow step installed.
2. Ease of use
🟥 Webhooks require the configuration of URL parameters and manually written JSON, which can be cumbersome and technical.
✅ Self-Service Flow Steps, simplify the process by offering packaged solutions where fields can be pre-mapped and offer a graphical interface for making adjustments. This makes the entire setup more straightforward, which lets us empower our Marketo users without burdening them with any intricate configurations.
3. Batch operations
🟥 Webhooks can't be called in batch campaigns, and while there are ways around this, it can cause problems and data loss. This significantly limits the possibilities when using webhooks, as well as efficiency and scalability. For example, while you could use a service like ClearBit as a webhook in a trigger campaign to enrich leads as they enter the system, you couldn’t use that webhook to enrich all of the leads you already have in your database.
✅ Self-Service Flow Steps are supported in batch campaigns. Allowing for more efficient processing of larger tasks. The data is sent to the service in batches of up to 1000 records, which gives us many more options for how we can use them and makes it far more efficient from the backend as well.
🟥 Webhooks depend on server responsiveness. 30 seconds is all we have. If the server is delayed or overwhelmed the connection will close, and there's a risk of data loss. This limits what we can do and what data we can get return. For example, if you are asking an AI model to generate complex content, the process could easily exceed this limit.
From the Marketo webhooks documentation
- Webhook execution time is at the mercy of the response time of the service being used and can result in long campaign execution delays. Even if a service only takes 50ms to execute, that is 1.5 hours when executed 100,000 times.
- Updates via response mappings will only occur if the web service responds with a 2xx HTTP response code. Other types of codes will not result in updates to the record.
- Marketo will wait up to 30 seconds for a given service call before terminating the call (a.k.a. timing out).
✅ Self-Service Flow Steps operate asynchronously. Data is sent to the backend service in batches along with a callback URL, like a return address. The service can then send back the response whenever it’s ready whether it takes 5 seconds or 5 days. This means they're not reliant on a continuous server connection, greatly expanding what solutions are possible as well as reliability.
🟥 Webhooks, are limited to tokens when sending data on the outbound side, which can constrain solutions. On the inbound side, webhooks are limited to lead field changes, which means we while we can update lead data, we can’t see in the activity log anything else about the process.
✅ Self-Service Flow Steps support both standard and custom context data on the outbound side. This includes lead data, program, smart campaign, program member and subscription context data, offering a broader data scope for operations. On the inbound side, we are of course able to pass back lead data, that will update lead fields, but we are also able to pass activity data, which will show up in the lead activity log.
This activity data can also be used for filtering and triggering in smart campaigns giving better targeting options. For example, with our ZeroBounce Flow Step we receive a lot of data back about the user’s email provider including items which we may want to use to trigger but not save on the lead record.
Webhooks vs Self Service Flow Steps
Self-Service Flow Steps are not always the best choice
In some specific scenarios, a webhook might still be the go-to choice. These scenarios include simple setups with few variables, actions that don’t need data responses, or those that can generate a quick reply.
It’s also important to note that there are some current limitations / quirks with self-service flow steps. For instance, they don’t support tokens inside the flow step fields or program tokens.
And, they always require at least one flow step field.
The introduction of Marketo's Self-Service Flow Steps is more than just a feature—it's a breakthrough for smart campaigns. For us it has been an invitation to think bigger, to revisit old challenges, and reimagine what is possible. The new reality is, we can now add to our smart campaign, basically any action we can think of. Sure, there are some technical hurdles to getting set up but the potential is endless. I would love to hear people’s opinions on this topic. Are you using Self-Service Flow Steps? What have you built / what would you build?
Up next in this blog series will be:
- Technical deep dive into Self-Service Flow Steps, their structure and data flow
- Building a no-code Self-Service Flow Step with Workato
- Advanced deployment of a Self-Service Flow Step with Microsoft Azure Functions
- Marketo SSFS Service Provider Interface (Github)
- Marketo Example SSFS built in Adobe IO (Github)
- Marketo Self Service Flow Step Service Documentation
This demo was originally presented as part of our webinar The Power of Marketo's Self-Service Flow Steps. You can watch the recording here
Partner, Chief Marketing Technology Officer
Marketing technology consultant & full stack developer specializing in marketing automation, strategy and highly effective campaign execution. Over 18 years of experience working with companies to identify the right mix of marketing technologies and putting them to work with profitable purpose.