Thinking Outside The Marketing Box: Campaign Patterns [Exercise]

In software engineering, a design pattern describes a general, reusable solution to a commonly occurring problem.

Image for post
Image for post

The beauty in being a big-picture person is that the more you think about a problem, the more likely you are to find the pattern behind it. And when you understand the pattern, you can design a solution that prevents the unwanted behavior.

Same goes for opportunities. The more you think of the overall picture, the easier it becomes to see the dots, connect them and create a strategy that allows opportunities to reoccur.

When I started learning JavaScript, I cam across the design pattern concept. In software engineering, a design pattern is a general and reusable solution to a commonly occurring problem.

Similar to frameworks and methodologies in content strategy, yet different in the way they approach the problem-solution duo. But what happens if you adopt the same way of thinking when developing marketing campaigns?

Let’s look at some common JavaScript design patterns and see how feasible it is to turn them into Campaign Patterns!

The playing field

Before we dive into it, here are the rules of the game:

  1. A pattern should be a proven solution.
  2. A pattern should be reusable.
  3. A pattern should be expressive, it should have a set structure and vocabulary.

The theory behind design patterns says that a pattern should have:

  • A name and description
  • A context — when should the pattern be applied, for what user needs
  • A problem — we don’t need a solution if there’s no problem
  • A solution — the steps for solving the problem
  • A design — the expected user behavior when facing this problem
  • Implementation guide
  • Illustrations, examples
  • Co-requisites and relations — does the pattern interact with others? What are the dependencies?
  • Known usage — what happens when the pattern is used outside of its defined purpose?

How should we think about Campaign patterns?

I’ll do this exercise for four JS design patterns.

  • The good news: If it works, it’s purely beautiful.
  • The bad news, which is actually also a good news: If it doesn’t work, I’ll market this approach as an anti-pattern! :))

Let’s start!

The three main categories of design patterns are:

  1. Creational design patterns
  2. Structural design patterns
  3. Behavioral design patterns
Image for post
Image for post

Creational patterns: The Constructor & The Factory

Creational Design Patterns focus on handling object creation mechanisms, where objects are created in a manner suitable for the situation we’re working in.

So what would a creational campaign pattern look like? It could focus on the methods of creating the campaign objects, or the campaign components. That could mean, in the first case, the campaign structure, scope and size; in the second scenario, it could refer to the target industry, target persona, approach angle and so on.

Let’s see how much deeper into this we can go.

The Constructor DP allows you to create multiple instances of the same type of object, all of them sharing the same or similar properties and methods. This ensures a consistent behavior.

It looks like this:

class Cat { 
constructor(name, voice, favFood) {
this.name = name;
this.voice = voice;
this.favFood = favFood;
}

feedCat() {
return `Your beloved ${this.name} says ${this.voice}. It's time to give ${this.name} some {this.favFood}.`
}
}
const saki = new Cat('Saki', 'Miau!', 'Sheba Creamy Snack');
const klein = new Cat('Kleintje', 'Maaaauww', 'Crantanele');
console.log(saki.feedCat()); // Your beloved Saki says Miau! It's time to give Saki some Sheba Creamy Snack.console.log(klein.feedCat()); // Your beloved Kleintje says Maaaauww! It's time to give Kleintje some Crantanele.

So what we do with the Constructor design pattern is that we define an object and its properties and methods, then we initiate a new one by simply using the keyword “new”.

I do see an application here for marketing campaigns, as follows:

  1. Define the campaign template:
/* Incorrect code coming, focus is on the idea */campaign (persona, industry, ...rest) {
persona:
industry:
problem:
solution:
campaignGoal:
target:
channels: [...]
contentTypes: [...]
budget:
deadline:
}

2. Instantiate 4 (quarterly) campaigns or 12 (monthly) campaigns

3. Fill in the campaign calendar

This would help in planning the marketing campaigns for the full year, with a clear scope per campaign, clear goals and targets. And you would immediately see the connections between them and the gaps in terms of covered industries, themes or goals. Beautiful.

Building on this idea, we could also use the Factory DP as follows:

class MktCampaign { 
constructor() {
this.createCampaign = function(type) {
let goal;
if (type === 'leads') goal = new LeadGenCampaign();
else if (type === 'traffic') goal = new TrafficCampaign();
return goal;
};
}
}
class LeadGenCampaign { constructor() { ... } }
class TrafficCampaign { constructor() {...} }

Beautiful.

Structural patterns: The Adapter & The Composite

Structural design patterns are concerned with object composition and finding ways to create relationships between objects. Their purpose is to ensure than if one part of a system changes, the system itself doesn’t need to change.

The Adapter DP is a structural one, and what it does is translate the interface of one class into another, to avoid incompatibilities and to make the classes work together. Often used for creating APIs.

I could see a potential application for this in adapting the structure of a campaign by adding new content types / channels, based on audience reactions.

What about the Composite Design Pattern? Also a Structural DP, this one composes objects into tree-like structures to represent whole-part hierarchies. Each node in the tree-like structure can be a collection of objects or an individual object. But they’re all treated uniformly.

I could see an application if we would create a campaign that targets a specific industry or audience, and has a specific goal, but the full journey or channels and types of content aren’t clear. You could potential add new channels, funnel steps or content types, making the journey longer or perhaps making it more specific to audience segments in the lower levels.

Practical application / Challenge

What if you could connect all your analytics tools to another tool, that would allow you to create campaign patterns, and then would recommend you the campaign structure, channel, target audience etc. based on previous results? Even better, what if it would be able to analyze the campaigns of competitors?

What if you could start with one set of campaign assets and two campaign goals, and adapt the campaign structure while running it, by simply adding a new content stream for one of the goals? And what if this recommendation would come from the tool itself, based on user interactions?

What if you could start a campaign by defining only the audience and goal, then the tool would analyze your audience and would compose the campaign structure, while notifying you what types of content you should create? All this, while the campaign is running?

The beauty of the idea. More thinking needs to go into this. Open to dev comments :).

Content strategist working with SaaS companies. Front end developer. Passionate about health, forensics.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store