The Missing Layer in Your Email Strategy

(And How to Audit It Properly)

Most teams believe their email strategy is defined by what sits inside their email platform. They look at campaigns, flows, subject lines, segmentation logic and deliverability metrics. They review performance dashboards and optimise what they can see. And when something starts to underperform, they assume the issue must sit within one of those visible components.

But there is another layer at work — one that rarely appears in reports and almost never features in planning sessions.

It is the structural layer that governs how your external communications behave as a system.

Not just marketing emails.

Everything:

• Transactional messages

   

• Sales follow-ups

   

• Service updates

   

• Onboarding communications

   

• SMS reminders

   

• Push notifications

   

• WhatsApp nudges

   

• Manual outreach

   

• System alerts generated by third-party tools

Your audience does not experience these as separate departments or disconnected tools.

They do not differentiate between “marketing automation” and “customer service comms.” They experience one continuous relationship with your business.

And that relationship is shaped less by individual messages than by how those messages interact with one another.

This is the missing layer in most email strategies.

It is the layer that determines what should override what. It governs what should pause when something more important happens. It defines when someone should exit a journey, when they should be excluded from another, and how different triggers relate to one another. It shapes whether communications reinforce each other — or quietly undermine trust.

When this structural layer is missing, the symptoms often get misdiagnosed.

• Open rates dip

   

• Engagement becomes inconsistent

   

• Automations feel “noisy."

   

• Customers stop responding

We call it fatigue, we call it low engagement, we call it deliverability decline.

But frequently, what we are actually seeing is system instability.

Messages collide, tone shifts abruptly, promotional emails land during unresolved service issues. A welcome sequence overlaps with a winback. A discount follows immediately after a purchase. Sales outreach continues while onboarding is mid-flow. Multiple tools fire independently, each technically correct, but collectively incoherent.

Timing does not break because one email was slightly off. Timing breaks because the system has no hierarchy, no guardrails, and no clear logic for how communications should behave together.

This is why this is not a “flow optimisation” article.

It is an experience audit and the missing pieces in your email strategy. 

It is about stepping back from individual emails and examining the ecosystem that surrounds them. It is about asking what people actually receive, in what order, from which teams, under what assumptions — and with what cumulative effect.

If you do not design this layer deliberately, your programme will still run. Emails will still send. Automations will still trigger.

But the experience will feel reactive rather than intentional.

And over time, that is where trust erodes. In the sections that follow, I will walk through how to audit this missing layer properly — beginning with two foundational distinctions that most teams blur together: collision and friction.

Two concepts you need to understand first

Collision vs friction (they’re not the same thing)

People often bundle everything under “timing”. But there are two different failure modes, and if you don’t separate them, you’ll fix the wrong thing.

Collision = messaging conflict

Collision is what happens when the meaning of your communications clashes.

It can look like:

• Marketing says “Book a call now” while Sales is already negotiating terms

• You say “Welcome!” in one email, then “We miss you” in another three days later

• You promise “We’ll only email once a week” and then send four emails in two days

• You send a discount right after someone buys (cool, so you’ve just trained them to regret purchasing)

• Service is mid-resolution and marketing emails land like nothing happened

Collision is context failure. You’re speaking without awareness of the relationship state.

Friction = experience breakdown

Friction is what happens at a campaign execution level — the mechanical bits that make an email feel hard, annoying, or broken.

It can look like:

• Buttons too small to tap

• Images not loading

• Text as one giant wall (hello, Outlook)

• Layout breaks on mobile

• Confusing CTA hierarchy (“what am I meant to do here?”)

• Accessibility issues (all-image emails, poor colour contrast, missing structure)

• Broken links or slow landing pages

• Preference centre that feels like a punishment

Friction is not messaging conflict. It’s usability, relevance or experience design failure.

And yes — these “small” details are often the difference between:

• “I’ll come back to this later”

  and

• “ugh, not dealing with this now”

In the inbox, your reader is not emotionally available for your nonsense. They are scanning. Filtering. Clearing. Achieving.

So collision and friction both matter. But they’re different. And this audit is designed to uncover both.

Quick self-check questions:

• Where do you see more issues right now: messaging clash, or broken experience?

• Do people ignore you because the content is wrong, or because interacting with you is effort?

• Are you losing trust… or losing usability… or both?

Step 1: Map every external comms channel

(If you can’t see the ecosystem, you can’t control timing)

Most “flow audits” fail because they only look at one tool. But your customer doesn’t care what tool you used. They only feel the outcome. So you need to map every channel that can touch someone externally, including the ones marketing doesn’t “own”.

This usually includes:

• Your marketing ESP (campaigns + automations)

• Transactional email platform (order updates, system emails, auth emails)

• Sales automation sequences

• Service ticketing comms

• SMS platform

• WhatsApp / messaging platform

• Push notifications

• Manual outreach scripts and call cadences

• Any third-party tools that send on your behalf (review platforms, appointment tools, payment providers)

Now put them into one visual map where you can see:

• what sends

• why it sends

• to whom

• and what else might send at the same time

Because once it’s in one view, you can start prioritising.

And in 2026, prioritising isn’t optional! 

• A transactional email is generally more important than a marketing email

   

• A service email is generally more important than a promotional campaign

   

•  A high-intent action should override a low-intent broadcast

This is how you stop your ecosystem from behaving like a spiderweb (we don't like spiderwebs)

Questions to ask as you map:

• What channels can reach the same person within the same 24 hours?

• Which channels are “always on” with no human oversight?

• What channels can send without marketing even knowing?

• If a customer asked “why did you message me?” could you explain it confidently?

Practical takeaway:

 Create a simple map with three columns:

1. Channel (ESP / SMS / Sales / Service / Transactional)

2. Trigger types (what makes it send)

3. Priority level (we’ll define hierarchy later)

Step 2: Audit triggers properly

Entry triggers without guardrails are how you create chaos

Most automations are built on a single trigger:

“if X happens, send Y”

And that’s fine… until X happens in a context where Y is inappropriate.

This is where your audit has to move beyond “is the trigger technically correct?” and into:

• Is the trigger behaviourally meaningful?

   

• And do we have guardrails to stop it firing when it shouldn’t?

Guardrails

Guardrails are the conditions that stop a technically-valid trigger from becoming a humanly-stupid message.

Example: your British Gas story.

The trigger itself made sense: meter credit ran out. But the system didn’t check context:

Was there a meter change? Was there an unresolved service issue? Was there a known operational cause?

So the marketing automation fired based on one data point… and landed like a slap.

That’s not a “personalisation problem”.

That’s a guardrail failure.

The trigger needed an exclusion check like:

• “Do they have an open service ticket?”

• “Did a meter change occur in the last X days?”

• “Is there an unresolved billing issue?”

Without guardrails, automation becomes confidently wrong.

Questions to ask for every trigger:

• What assumption does this trigger make about the person’s intent or situation?

• What would need to be true for this email to be helpful?

• What would need to be true for this email to be harmful?

• What other signals should override this trigger?

• What would the “wrong time” version of this look like?

How to stress test triggers

Most teams only learn guardrails through mistakes. That’s normal. But you can be proactive.

Pick your top 5 triggers (highest volume or highest revenue impact) and run a “failure mode” workshop:

• List 5 scenarios where the trigger fires but the email would be wrong

• Identify what system signal would detect that scenario

• Add one guardrail rule per scenario

And remember, exclusions are the new segmentation.

Step 3: Audit intent alignment

If you don’t know what intent you’re responding to, your messaging is guessing

This is where you go deeper than mechanics.

For each flow, you need to define: what intent is it responding to?

I like three buckets (because they’re simple enough to actually use):

Intent audit questions:

• What intent bucket is this flow meant to serve?

• Does the messaging inside the flow match that intent?

• Are you treating passive intent like active intent (aka pushing too hard too early)?

• Are you ignoring negative intent signals that should pause or reshape messaging?

• Do you have different messaging for different intent levels… or is it one sequence for everyone?

To help with this you need to read Intent Over Personalisation: What “Personal” Actually Means in Email (and How to Build It) and Designing Email Journeys Using TFDS.

Step 4: Identify overlaps and “stacking risk”

Can one person qualify for multiple journeys at the same time?

This is where timing usually collapses! Most flows are built with tunnel vision: “this person is in my flow now”.

But people don’t behave in tidy single file lines. Someone can:

• renew membership

• trigger post-renewal

• still be in nurture

• still be in campaigns

• still be in “winback” if the logic is outdated

• still receive sales outreach if the CRM stage didn’t update properly

So you need to audit overlap, not just flow quality.

Practical overlap exercise:

Take your 5 most common audience actions (purchase, discount pop up form fill, demo request, support ticket, webinar sign-up, renewal) and ask:

• What flows could this person now be in?

• What campaigns might they still receive?

• What other teams might still message them?

• What systems would still behave as if nothing changed?

Then count it. If one action can trigger 3–6 messages across 2–4 channels, you don’t have automation.

You have a collision machine.

Step 5: Exit logic vs exclusion logic

They sound similar. They’re not. And both are necessary.

This is one of the most practical distinctions you can make in your programme.

Exit logic = “get them out once context changes”

Exit logic removes someone from a journey when the original reason for being there is no longer true.

Example:

• If they purchase, exit abandoned basket

• If they book a demo, exit nurture

• If they renew, exit winback

• If they activate in a trial, exit “getting started” reminders

Exit logic is about stopping messages that are now wrong.

Exclusion logic = “don’t let them enter (or don’t let other messages hit them)”

Exclusion logic prevents someone receiving a message because their current context overrides it.

Example:

• if support ticket open, exclude from promotions

• if onboarding, exclude from acquisition campaigns

• if active sales cycle, exclude from generic marketing pushes

• if new subscriber orientation, exclude from promo blasts

Exclusion logic is about protecting the experience.

Exit = stop what’s already in motion.
Exclude = prevent collision with what else could hit them.

Audit questions:

• What should remove someone immediately from this journey?

• What should prevent someone entering in the first place?

• What should suppress other sends while this journey runs?

• Are you relying on people finishing flows, instead of designing exits?
  
  
  

Step 6: Build your send hierarchy

Not all messages are equal 

If you don’t set a hierarchy, your systems will behave as if everything is equally important. And in the real world, it’s not.

• A billing failure is more important than a campaign launch.

• A support resolution is more important than an upsell email.

• An onboarding step is more important than a generic newsletter.

So you need a hierarchy — not for theoretical cleanliness, but so your messaging has a governor.

A simple hierarchy that works in most ecosystems:

Tier 1: Critical operational
 Security, billing errors, account issues, service outages, urgent access problems.

Tier 2: Transactional and service
 Order updates, onboarding steps, ticket updates, appointment confirmations.

Tier 3: High-intent lifecycle
 Abandoned checkout, renewal at risk, demo follow-ups, trial activation nudges.

Tier 4: Education and nurture
 Resources, product education, newsletters, thought leadership.

Tier 5: Broadcast and promotional
Campaigns, offers, launches, “send to all” nonsense. 

Hierarchy isn’t just “what’s important”.

It’s what overrides what.

So you define rules like:

• If Tier 1 is active → everything pauses

• If Tier 2 is active → Tier 4 and 5 throttle

• If Tier 3 fires → Tier 5 pauses for X days

• If onboarding is active → acquisition messaging stops

This is how you prevent your programme from embarrassing you.

Is it ever okay for messages to clash?

Sometimes yes (so don't worry). 

Clashes are acceptable when:

• The messages are consistent

• The tone doesn’t conflict

• The objectives support each other

• The experience still feels coherent

Your example is perfect:

If someone signs up for your email health check and RE:markable, they may enter two flows. But it’s okay because:

• The content is different

• The pacing is sensible

• The experience has been audited intentionally

That’s the point, the goal is not “never overlap” and the goal is “never create a confusing relationship”.

Hierarchy questions:

• What is the single most important message type in your business?

• What message should always override marketing?

• When someone purchases, what should they NOT receive for the next X days?

• What does a coherent week of comms look like for a human?

Step 7: Diagnose collision and friction in the wild

Don’t audit what you send. Audit what people experience.

Here’s the most important part of this whole thing: You cannot audit this from inside your ESP alone.

Because the ESP only shows what marketing sends.

You need to audit experience.

Pick a real customer journey (or a few). Ideally:

• one that converted

• one that dropped off

• one that complained

• one that went quiet

Now reconstruct the timeline:

• What did they receive and when?

• What channels touched them?

• What did the messages assume?

• What did the messages ignore?

• Where did the tone shift abruptly?

• Where did the content contradict reality?

• Where did friction show up (broken layout, confusing CTA, slow pages)?

Collision is often why someone doesn’t pick up the phone.

 Friction is often why someone doesn’t click even if they want to.

And teams miss this because they only look at opens and clicks, which are the least interesting part of the story.

Experience audit questions:

• If I received these messages, would I feel understood or managed?

• Does the sequence reduce uncertainty or increase it?

• Is there any point where I’d think “why are you telling me this right now?”

• Is it easy to act, or does acting feel like effort?

Step 8: Strengthen signal weighting

Not all signals deserve the same response

This is where you move from “automation” into actual strategy.

A single page visit is weak but a cluster of behaviours is strong.

A single click is a hint, a pattern is a state change.

So you weight your signals.

Not because it’s fancy, but because it prevents overreaction.

Practical example:

• Pricing page once = mild curiosity

• Pricing page 3 times + case study visit + return within 48 hours = evaluation intent

• Pricing page + contact page + “implementation” page = buying cluster

Same “signal category”. Different meaning but dfferent response.

And negative signals need weighting too:

• One week of silence = normal

• Sudden drop after high activity = potential objection / internal shift

• Support ticket + promo email = timing disaster (unless you’re trying to become a case study in how to lose trust)

Signal weighting questions:

• What behaviours, in your data, consistently precede conversion?

• What behaviours precede drop-off?

• What does “warming up” actually look like for your business?

• What does “cooling off” look like?

• Which signals should trigger escalation, and which should trigger restraint?

What you should end up with

The outputs that make this real (not just “good ideas”)

If you do this audit properly, you should end with:

These “small details” are your email strategy

Collision, friction, guardrails, exit logic, exclusions and hierarchy.

These are the things that make or break your email strategy because they shape the experience your audience actually has. And the inbox is not a neutral space.

It’s a task environment, a filtering environment, a risk evaluation environment.

So if your comms create confusion, effort, or contradiction, people don’t argue with you. They just quietly train themselves to ignore you.

Which is… kind of the worst outcome! 

If you want the simplest reframe to steal: Stop asking “how do we send more messages?”

Start asking: “How do we reduce collision, reduce friction, and protect the relationship?”

That’s where performance comes from now.