What’s a Potentially Shippable Marketing Increment?
Agile marketing carries many benefits (hello, sustainable pace!), but one of the most commonly sought after is the ability to deliver more often.
Rather than waiting six months for an entire campaign to be complete before we pull the trigger, Agile marketing teams release small parts of that campaign steadily over time.
This might mean putting out a blog post now, a content hub later, a webinar after that, and a series of videos as the grand finale (all contingent on data that validates the concept behind the whole series).
“Release often” might also mean providing what’s known as a “horizontal slice,” something that delivers end-to-end value but doesn’t include every single item that the final campaign might include. (More on this later in this article.)
On the other hand, there are very harmful ways to follow the letter of this Agile tenet and ignore its spirit.
Because let’s face it: putting out crap every week isn’t helping anybody.
So what does it really mean for Agile marketers to deliver value to an audience frequently? What can (and should) we be shipping?
Agile Marketing, Scrum, and Shipping
One term you might encounter when thinking about this frequent delivery cycle is “potentially shippable increment.” It comes from the Scrum framework, and refers to the final product of a Sprint.
The basic idea of Scrum is that we can’t possible plan completely or accurately at the start of a large, complex initiative.
So instead of wasting a bunch of time crafting a perfect plan, we make a short one that covers just the next couple of weeks (the Sprint plan). Then we execute that plan, and at the end we have this nice, complete piece of work.
That’s the potentially shippable increment.
It should be done enough that it could ship, i.e. go out to users/customers/prospects, but you aren’t required to ship things every single Sprint.
This caveat, however, can get a lot of Agile teams in trouble.
If we don’t plan to actually ship something at the end of every Sprint, we can easily fall into the trap of vertical slicing.
When we slice work vertically we build things in order — Part 1 gets built in Sprint 1, Part 2 in Sprint 2, Part 3 in Sprint 3, and so on until the whole thing is done — rather than trying to build the most valuable and impactful components first.
For example, let’s imagine that we’re building a new email nurture campaign. Each email in the series needs:
- A fully functioning email (copy, design, and implementation in our marketing automation tool)
- Active destination pages for people to land on when they click things in the email (those also need to be designed, have copy written, and be created in our CMS)
- Tracking and data collection capabilities so we can monitor our subscribers’ behavior and respond appropriately (send them to sales, put them on a different nurture track, provide different content, etc.)
- And of course all of this requires that we have the entire nurture series planned from start to finish, including logic, exit points, triggers, and all that other good stuff that marketing automation makes possible
You can see ho it would be very tempting to slice this vertically.
This in-depth guide reveals all the available paths, so you can take your first step on your Agile journey with confidence.
How NOT to Create Increments
We could have the strategists spend a whole Sprint drafting the nurture series, identifying the resources they’d share (including new ones that would need to be created), planning out the flow, etc.
Then we’d have the copywriting Sprint, where our writer(s) would write up every single email in the series. If we’re lucky that could all actually get done in 2-3 weeks, but it might bleed over to another Sprint if we can’t review in a timely manner.
Then it’s time for design (how on earth could you create a design without knowing what the copy will say, after all?) in Sprint 3 (or 4, depending on reviews). Once again, this process might bleed into another Sprint if reviews drag on.
Finally in Sprint 6 (because let’s be real — both copy and design took longer than we thought) it’s time to put it into automation with all the technical detail required for a good campaign, like personalization, triggers, etc. etc.
So our vertical slicing has given us a complete, functioning campaign in 6 Sprints, or 12 weeks (18 weeks if we’re running 3 week Sprints).
Is it me, or is that not super Agile?
Choosing a Better Increment
Instead of letting our Agile process morph into something that looks a whole lot like old school Waterfall project management, we should instead be looking for a horizontal slice.
Horizontal slices deliver end-to-end value to your audience (in this case the prospects who are going to be experiencing our email nurture campaign).
BONUS: horizontal slices also get you outcomes way faster (and, depending on how you design them, might also mitigate risk or speed up learning).
Agile Steps to Picking the Right Deliverables
First, let’s walk through this at a general level, then we’ll move on to doing it for real with our email campaign.
(Hat tip to Agile for All for coming up with the super useful slicing framework that I’m employing here.)
Step 1: Frame the Problem
Clearly state what you’re trying to do, so everyone in the room understands what the objective of this whole process is.
It might seem obvious to you (and lots of other folks in the room) what the goal is, but chances are there are at least a couple of people whose ideas of the goal are at odds with one another.
Say the objective out loud, get consensus from others in the room, and write it down.
Step 2: State the Value
This step requires us to articulate why we’re planning to do this work in the first place. Here we answer questions like:
- Where’s the value in this project?
- What makes this worth doing?
- What will we get out of it?
- What will our customers get out of it?
- How will it make us money?
Step 3: Size the Work
If you’re trying to find a way to slice up work, you’re looking at a big, complex project of some kind. So now it’s time to dive into what makes it big and/or complex.
You need to ask yourselves what exactly makes this thing big? Or, said another way, why couldn’t we just knock this out in an afternoon?
As you might imagine, it’s important to have real contributors in the meeting, because they’re usually the ones who can list all the steps and issues that will cause this project to balloon if left unchecked.
Get a room of middle to senior managers together, and they might say, “This can’t be that hard! Of course! Let’s just do it in an afternoon!”
Nobody wins when this happens.
Discuss size with the people responsible for executing the work.
Step 4: Assess Potential Risks
Time for the not-so-fun question: what could go wrong that would cause this project to fail?
Be realistic here, because later on we’ll want to be able to determine if our horizontal slice could be used to mitigate these risks.
Step 5: Document Uncertainties
Chances are you don’t know everything about your project, because we live in a volatile, uncertain world where we can’t possibly know everything up front.
So here, ask yourselves what questions need to be answered for this project to be successful?
Step 6: Review Your Insights
Now you’ve filled out this handy four-part tool, so it’s time to go back through and see what’s been revealed.
In your Value section, look at the list and figure out what value that’s documented there makes all the others relatively unimportant. Delivering that value first could be your first shippable increment, or horizontal slice.
In the Size section, see if anything there contributes disproportionately to the size of the effort. Are there things that would make subsequent releases easier/smaller if we got them out of the way first? They might be part of the first shippable increment.
Interestingly, you may find that the things that deliver the most value aren’t the things that make the project bigger. This makes the tradeoff easy: do the valuable stuff now, and save the really big stuff for later.
When reviewing the Risk section, ask yourself what risk is listed there is the scariest, or the most likely to derail the project? Maybe that needs to be addressed before any other work proceeds.
And finally, take a look at your Uncertainty section. Which of those listed seems the most critical to resolve? You may decide the first shippable increment should be devoted to tackling that.
Example of Horizontal Slicing
Ok, that’s a nice abstract look at how we might find the right shippable increment(s). Let’s run through that sheet with our email campaign and see how it might work.
Here it becomes clear that the Risk is much more closely tied to the technical aspects of this campaign than the content or design.
It seems like we should devote time up front to ensuring we have a handle on this before investing tons of time on actually creating the emails themselves.
Additionally, we’re going to need to try and validate this whole nurture campaign up front too, since our uncertainty is all centered around whether it’s going to deliver sales and conversions like we think.
Based on all this, we’d want to spend at least part of a Sprint setting up and testing the “behind the scenes” parts of the campaign (triggers, tracking, etc.).
At the same time we can be designing/writing the first couple of emails, so that as soon as the backend is done we’re ready to send those and see how they perform.
While that initial experiment might not tell us for sure how the whole campaign will do, we can at least get a feel for whether our hypothesis is correct. If it turns out we were wrong, we can discontinue the campaign without going through the work of making it all.
And, even better, those initial emails will start bringing value to our subscribers nice and early by sharing helpful content and resources. That’s a good horizontal slice!
Shipping is Easier Than You Think
Many impediments will keep you from finishing, but they don’t keep you from starting. You might be aware of serious roadblocks, but there’s almost always some road in between here and there.
Use the Agile value of delivering value early and often as a driver to find the most impactful parts of your work and get them done first.
If you really can’t get at that value right away, use a Sprint or two to reduce the size or complexity of the work, mitigate risk, and/or eliminate uncertainty.
No more excuses, Agile marketers. It’s time to embrace frequent releases and create shippable increments at the end of every Sprint whenever possible.