9 UTM Mistakes That Quietly Ruin Your Analytics Reports

Why silent failures are the expensive kind

If UTM tracking broke loudly, nobody would have this problem. A missing tag would show an error, somebody would fix it, and the numbers would be right. Instead every failure mode here produces a report that is fully populated, entirely believable and quietly wrong.

The damage compounds. Decisions get made on those numbers — budget moved to the channel that appears to be winning, a campaign killed because it appears to be flat. Neither decision is recoverable once the money is spent, and the underlying data was never examined because nothing looked broken.

So the useful skill is not building perfect links. It is recognising the shape of each failure when you see it in a report.

The nine mistakes, and what each looks like

1. Inconsistent capitalisation

What it looks like: Facebook, facebook and FB as three separate rows, each with a third of the traffic.

Why it happens: GA4 compares parameter values as literal, case-sensitive strings, and three people typing a link by hand will produce three spellings. The fix: lower case everything, without exception, and enforce it at the point the link is built rather than in a style guide nobody reads.

2. An invented utm_medium

What it looks like: a chunk of traffic in Unassigned, or a channel report that does not add up to your total.

Why it happens: GA4 maps medium values onto its default channel groups using fixed rules. email matches. emailer, e-mail and mailer do not. The fix: agree a short list — email, cpc, organic_social, referral, affiliate, qr — and treat anything outside it as a bug.

3. Tagging your own internal links

What it looks like: your newsletter or your own site name appearing as a source far more often than sends could explain, while organic search mysteriously underperforms.

Why it happens: a UTM parameter on any link tells GA4 a new campaign has begun. It ends the current session and starts a fresh one, so a visitor who arrived from Google and then clicked a tagged internal button is re-credited away from Google. The fix: only tag links that arrive from outside your domain. For internal button tracking, use GA4 events, not UTMs.

4. Spaces and ampersands left unencoded

What it looks like: campaign values that are cut off halfway, or a landing page that loads with half its content missing.

Why it happens: an unencoded space breaks the URL where it sits; a raw & inside a value starts what the browser reads as a new parameter. The fix: never hand-assemble a link that contains a value you typed as a sentence. This is precisely what a builder is for.

5. Losing the query string that was already there

What it looks like: a landing page that ignores the variant, language or offer parameter it was supposed to receive.

Why it happens: somebody appends ?utm_source=... to a URL that already had ?lang=en, producing two question marks and one broken link. The fix: the second and subsequent parameters need &, not ?. A builder that preserves existing query strings does this for you.

6. No utm_content, ever

What it looks like: you know the email drove 240 visits. You have no idea whether that was the header button, the mid-body link or the PS at the bottom.

Why it happens: it is optional, so it gets skipped. The fix: use it on every link where two versions of the same thing exist. It costs nothing and it is the difference between measuring a campaign and learning from one.

7. Campaign names with no date

What it looks like: a row called webinar that spans three years of webinars and describes none of them.

Why it happens: at the moment of naming, there is only one webinar. The fix: webinar-2026-05. Sorting works, filtering works, and next May you will not be guessing.

8. Tagging paid search by hand when auto-tagging is on

What it looks like: Google Ads data that will not reconcile with GA4, or keyword-level reporting that has vanished.

Why it happens: Google Ads auto-tagging uses a gclid, which carries far more detail than UTMs can. Manual tags on top of it can override that richer data. The fix: leave auto-tagging on and do not manually tag Google Ads links unless you have a specific reason and know what you are giving up.

9. No canonical tag on the landing page

What it looks like: an SEO problem rather than an analytics one — several near-identical URLs in Search Console, each with a fraction of the impressions.

Why it happens: every UTM variant is technically a distinct URL. Without a self-referencing canonical, shared and indexed variants split the ranking signals that should have pooled on one page. The fix: one canonical line in the head of every page. Generate it with the canonical tag generator, then confirm it is actually being served with the SEO page checker.

How to audit what you already have

This takes about twenty minutes and it is worth doing before you tag anything new.

1. In GA4, open Reports → Acquisition → Traffic acquisition and switch the primary dimension to Session source / medium.
2. Scan for near-duplicates. Anything that differs only by case, a plural, or a hyphen is one campaign wearing two costumes.
3. Look for “Unassigned”. If it is more than a rounding error, you have invented mediums somewhere.
4. Search the source list for your own domain and brand name. If either appears, something internal is being tagged.
5. Sort by campaign and read the names. If you cannot tell what a campaign was from its name alone, rename the convention now rather than after another year of data.

Write down what you find. Historic data cannot be re-attributed — GA4 stores what it received — but knowing which rows are unreliable stops you making a decision on them.

Why a builder removes most of these

Six of the nine are mechanical: case, encoding, the second question mark, the preserved query string, the missing utm_content field, the invented medium. A tool that handles them cannot be talked out of it at five o'clock on a Friday, which a convention document can.

The UTM builder here lower-cases source and medium by default, percent-encodes every value, keeps an existing query string intact, shows you the finished URL as you type, and puts the optional fields in front of you with an explanation instead of hiding them. It runs entirely in your browser — no account, no logging, and campaign names that often reveal an unannounced launch never leave your machine.

The remaining three — internal tagging, undated campaign names and fighting with auto-tagging — are judgement, not mechanics. No tool fixes those. Knowing they exist does.

A tagging routine that holds up

1. One place links get built. Whoever is sending, the link comes from the builder, not from memory.
2. One list of allowed mediums, written down where the team looks, not in someone's head.
3. Campaign name decided once, at the start, with the month in it — then copied, never retyped.
4. A monthly two-minute scan of source / medium for near-duplicates. Catching a split in week one is trivial; catching it in month six is archaeology.
5. Check the money, not the clicks. Attribution only matters if conversions are recorded — then run the numbers through the ROI calculator and see which channel actually paid.

FAQ