Why Attribution Became a Problem — And Why It's Getting Harder to Ignore

Last-click attribution survived for as long as it did because the alternative was painful: admitting that we don't really know which part of the journey drove the conversion. The last click was measurable, attributable, and defensible in a budget meeting. That was enough.

It stopped being enough when user journeys stopped being linear. A campaign impression on Instagram, a shared short link three days later in a group chat, a search a week after that, a revisit via email — each of these contributed something. Giving all the credit to the final click is a accounting convenience, not an accurate model of influence.

Multi-touch attribution is the industry's attempt to distribute credit more honestly across that journey. Whether it succeeds depends heavily on what's happening at the infrastructure level — specifically how redirects, short links, and cross-domain handoffs are handled. The model is only as good as the signal it receives.

What Attribution Actually Is (And What It Assumes)

Attribution is the process of assigning conversion credit across the touchpoints in a user's journey. The deceptively hard part is that no attribution model represents objective reality — every model encodes a set of assumptions about how users make decisions. Linear models assume all touchpoints contribute equally. Time-decay models assume recency correlates with influence. Position-based models assume the beginning and end of a journey matter most.

None of these assumptions are universally true. What matters is whether the assumption matches your users' actual decision process — and whether your tracking infrastructure can capture enough of the journey for the model to work with.

In short-link ecosystems, the second part is often the binding constraint. You can choose the most sophisticated attribution model available, but if your redirect chain is losing UTM parameters or breaking session continuity, the model is learning from an incomplete picture.

Single-Touch Attribution: Where the Problems Start

First-touch and last-touch attribution are still in wide use, and they fail in predictable ways that are worth understanding precisely because they set the baseline expectation that multi-touch models are trying to improve on.

First-touch attribution gives 100% credit to the initial interaction. It overstates the role of awareness channels and completely ignores the intent-building that happens in the middle of the journey. Last-touch attribution gives 100% credit to the final interaction before conversion. It overstates the role of retention and direct channels and ignores the work that created intent in the first place.

In a campaign using short links across multiple channels, last-touch attribution creates a specific distortion: the channel that happens to host the final click (often a search or direct visit) receives all the credit, while the short link that introduced the user to the brand receives none. This leads teams to over-invest in bottom-funnel channels and under-invest in discovery — which is exactly backwards from where they'd want to invest if they could see the full journey.

The Multi-Touch Models: What Each One Is Actually Assuming

Comparison diagram of linear, time-decay, and position-based attribution models.

Multi-touch models are often presented as a menu of options with neutral labels. In practice, each one encodes a specific and contestable claim about user behavior. Choosing a model without understanding that claim means you're making a decision you didn't know you were making.

Linear Attribution

Linear attribution distributes conversion credit equally across all recorded touchpoints. The implicit claim: every interaction contributed equally to the conversion. This is almost never true in practice, but it has real utility as a visibility tool — it tells you which channels are present in converting journeys without making claims about which ones drove the decision.

The problem in short-link campaigns is that linear attribution can't distinguish a passive redirect (a user mechanically following a link) from a deliberate return visit that indicates genuine intent. Both get the same credit weight. If your UTM setup records every redirect hop as a touchpoint — rather than only the meaningful campaign interactions — linear attribution will spread credit across navigational events that didn't actually influence anything.

The fix is upstream: ensure your attribution events are fired at meaningful interaction points, not at every redirect step. In a Spring Boot redirect handler, this means recording the click event with the campaign context, not the intermediate redirect traversal: 

// Record attribution event at the point of meaningful interaction
// (when the user clicked the short link), not at each redirect hop
@GetMapping("/{code}")
public ResponseEntity<Void> redirect(
        @PathVariable String code,
        HttpServletRequest request) {

    ShortUrl shortUrl = urlService.resolve(code);

    // Log the click event with campaign context for attribution
    clickEventService.record(ClickEvent.builder()
        .shortCode(code)
        .utmSource(request.getParameter("utm_source"))
        .utmMedium(request.getParameter("utm_medium"))
        .utmCampaign(request.getParameter("utm_campaign"))
        .referrer(request.getHeader("Referer"))
        .timestamp(Instant.now())
        .build());

    // Redirect without creating an additional analytics event
    return ResponseEntity.status(HttpStatus.MOVED_PERMANENTLY)
        .header("Location", shortUrl.getDestination())
        .header("Cache-Control", "no-store")
        .build();
}

Time-Decay Attribution

Time-decay models assign more credit to touchpoints that occur closer to the conversion, using an exponential decay function. The implicit claim: recency correlates with influence — the closer an interaction was to the decision, the more it contributed.

This works reasonably well for short sales cycles with impulse-driven conversions. It fails for campaigns involving trust-building over time, content marketing, or any scenario where the initial exposure (often a shared short link) created the awareness that made every subsequent interaction possible. A user who discovers a product through a shared link, then returns two weeks later via search to convert, would have the original link severely discounted under time-decay — even if that first exposure was the reason they searched at all.

The practical question to ask before choosing time-decay: what's the typical gap between first exposure and conversion in your campaign data? If that gap is commonly more than a few days, time-decay attribution will systematically undervalue your top-of-funnel channels.

Position-Based (U-Shaped) Attribution

Position-based models assign the majority of credit (typically 40% each) to the first and last touchpoints, distributing the remaining 20% across the middle interactions. The implicit claim: discovery and the final decision are the two most influential moments in a journey, with the middle interactions serving a supporting role.

This is often a reasonable approximation for many journey types. The complication for short-link campaigns is that position-based models are particularly sensitive to accurately identifying the first touchpoint. Redirects that strip referrer data, in-app browsers that don't pass attribution signals, and private messaging platforms (where many shared short links live) can all cause the model to misidentify the first meaningful interaction.

When that happens, the model assigns 40% credit to the wrong touchpoint with full confidence. There's no uncertainty signal in the output — it simply reports a clean number that's attributing credit to the wrong place in the journey.

Data-Driven Attribution

Data-driven attribution uses statistical analysis of your historical conversion paths to estimate the marginal contribution of each touchpoint. Rather than applying a fixed rule, it learns from the difference between paths that converted and paths that didn't. In theory, this is the most accurate approach because it's empirical rather than assumption-driven.

In practice, it has two hard dependencies that campaigns with short links often struggle to meet. First, it requires a minimum volume of conversions — Google's GA4 threshold is approximately 400 conversions and 4,000 ad interactions per conversion event per 30-day period. Below that threshold, GA4 silently falls back to last-click, which means many smaller campaigns are getting last-click attribution in GA4 without being informed of the fallback.

Second, the model learns from what it can observe. Short links that lose UTM parameters mid-redirect, sessions broken by in-app browsers, and cross-domain handoffs without cross-domain measurement all create gaps in the event stream. The model doesn't flag these gaps — it treats the incomplete data as complete and builds its statistical model accordingly. The result is a data-driven model that's confidently learned from a distorted dataset.

Where Redirects Break Attribution Models

Redirects are the single largest source of attribution failure in short-link campaigns, and they fail in ways that are hard to detect because the analytics output looks normal. The failures are silent — the numbers don't go to zero, they drift.

The specific failure modes, in order of frequency:

UTM parameter loss in redirect chains. Each hop in a redirect chain is an opportunity to lose query parameters. This happens most commonly when intermediate redirect handlers don't explicitly forward the query string, when CDN or reverse proxy layers cache the redirect response without parameters, or when URL shorteners in the chain strip everything after the path. Testing your redirect chain end-to-end with curl is the fastest way to audit this: 

# Audit redirect chain for UTM preservation
curl -sIL "https://vvd.im/example?utm_source=newsletter&utm_medium=email&utm_campaign=q2-launch" \
  2>&1 | grep -E "^(HTTP|Location:)"

# Each Location header should carry the original query parameters
# A Location header without ?utm_* = attribution loss at that hop

# For detailed timing at each hop:
curl -w "\n%{redirect_url}\ntime: %{time_total}s\n" \
  -sIL "https://vvd.im/example?utm_source=test" | grep -E "^(Location:|time:)"

Session fragmentation at cross-domain boundaries. When a short link redirects from one domain to a landing page on a different domain, GA4 treats this as a new session by default — meaning the UTM attribution from the first domain doesn't carry over to the landing page domain. Cross-domain measurement configuration is required to stitch these sessions together. Without it, the short link domain gets credit for a session that immediately exits, and the landing page domain sees a Direct visit.

In-app browser isolation. Links shared in messaging apps (WhatsApp, Telegram, LINE) and opened within the app's built-in browser operate in a sandboxed environment that doesn't share cookies or session state with the device's main browser. When a user later opens the same site in Safari or Chrome, GA4 sees a new user with no attribution history. This is increasingly common and effectively invisible in standard analytics reports.

Referrer stripping by intermediate pages. If any hop in the redirect chain serves a full HTML page — even briefly, as part of a JavaScript-based redirect — the Referer header for subsequent requests will point to that intermediate page rather than the original source. GA4 may attribute the session to that intermediate page as the source.

GA4's Attribution Logic in Practice

GA4's event-based attribution is architecturally better suited for cross-platform journeys than UA's session model. Attribution is evaluated per-event rather than locked at session start, which means GA4 can handle more complex multi-device scenarios that UA simply couldn't model.

The practical limitation is that GA4 needs the attribution context to be present when the first meaningful event fires. If the page_view event fires before UTM parameters are available — which can happen with JavaScript-based redirect implementations that load the page before completing the URL resolution — GA4 assigns attribution based on what it sees at that moment. It doesn't retroactively correct the attribution when the UTMs arrive.

For server-side redirects (301/302), this isn't typically an issue because the browser doesn't load the intermediate page. But some redirect implementations, particularly those that show interstitial pages or use meta-refresh patterns, can trigger this problem. The safest redirect implementation for attribution preservation is a direct server-side 301 with explicit query string forwarding: 

# Nginx: explicit query string preservation in redirect rules
# Wrong - drops query string
location ~* ^/([a-zA-Z0-9]+)$ {
    return 301 https://destination.com/page;
}

# Correct - preserves UTMs and all query parameters
location ~* ^/([a-zA-Z0-9]+)$ {
    return 301 https://destination.com/page?$query_string;
}

# For proxy-based short URL handling (passes to Spring Boot)
location ~* ^/([a-zA-Z0-9]+)$ {
    proxy_pass http://127.0.0.1:8080;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    # Cache-Control prevents CDN from caching redirect without query params
    proxy_hide_header Cache-Control;
    add_header Cache-Control "no-store";
}

The Attribution Failure Pattern That Dashboards Hide

The most dangerous attribution errors are not the ones that produce obviously wrong numbers. They're the ones that produce plausible numbers with the wrong structure — channels that appear to be performing well by the attribution model's accounting, but aren't generating real business outcomes.

The tell-tale sign is a divergence between attribution credit and downstream metrics. A channel that receives significant multi-touch credit should also correlate with higher lifetime value, better retention, or stronger engagement from the users it influences. When attribution credit doesn't correlate with any downstream metric you care about, the attribution model is probably misallocating credit — and the most likely cause is signal loss in the redirect or cross-domain handoff layer.

Flow diagram showing goals and data shaping attribution model selection.

Practical Attribution Strategy for Short-Link Campaigns

The sequence most teams get wrong: they choose an attribution model and then try to make their tracking fit it. The sequence that actually works: audit what signals your infrastructure reliably delivers, then choose the attribution model that works within those constraints.

For short-link campaigns, the audit should verify four things before model selection:

First, confirm that UTM parameters survive the complete redirect chain from click to landing page. Test with actual curl requests against your production infrastructure, not a local dev environment. CDN behavior, Nginx configuration, and Spring Boot routing all need to be tested together because the failure modes are often in the interactions between layers.

Second, identify which redirect hops are navigational versus persuasive. A redirect that exists to enforce HTTPS or route to a regional domain is navigational — it shouldn't register as a touchpoint with attribution weight. A landing page that presents content intended to build purchase intent is persuasive and should. If your analytics is recording both types equally, your attribution model is working with inflated touchpoint counts.

Third, determine whether your campaign volume meets the threshold for data-driven attribution. If you're below GA4's ~400 conversions per 30 days per event, you're getting last-click by default. In that case, explicitly configure a position-based or linear model rather than relying on a fallback that isn't labeled as such.

Fourth, configure cross-domain measurement if your short link domain differs from your landing page domain. Without this, the handoff between domains creates a session break that makes every short-link click appear as a Direct visit on the landing page side.

Cross-domain measurement in GA4 requires adding your domains to the list of domains to measure together in GA4's data streams settings, and ensuring that the GA4 tag is present on both domains. The tag handles the rest — it appends a session identifier to cross-domain links automatically: 

// GA4 cross-domain measurement via gtag
// Configure in GA4: Admin > Data Streams > Web > Configure tag settings > Configure domains
// Also verify in Tag Manager if using GTM

// For server-side validation: check that GA4 is appending _gl parameter
// to links crossing domain boundaries
// Example: https://yourdomain.com/landing?utm_source=newsletter&_gl=1*abc123*...

// In Spring Boot, you can log whether the _gl parameter is present
// to validate cross-domain measurement is working
@GetMapping("/{code}")
public ResponseEntity<Void> redirect(@PathVariable String code, HttpServletRequest request) {
    boolean hasCrossDomainParam = request.getParameter("_gl") != null;

    if (!hasCrossDomainParam) {
        // Log missing cross-domain measurement for monitoring
        log.warn("Cross-domain measurement parameter missing for code: {}", code);
        metrics.increment("redirect.missing_cross_domain");
    }

    // Continue with redirect...
}

Choosing a Model: The Decision Framework

With clean signal confirmed, model selection comes down to your sales cycle length and what business question you're actually trying to answer.

If your primary question is "which channels are present in converting journeys?" — use linear. It won't tell you about influence, but it will give you accurate visibility into channel presence without making contested claims about contribution.

If your sales cycle is short (under 3 days from first touch to conversion) and conversions are largely impulse-driven — time-decay is defensible. The recency assumption holds reasonably well for these journeys.

If you have a well-defined discovery channel (shared short links, social, paid) and a well-defined decision channel (direct, branded search) — position-based is a reasonable model. It will correctly weight the endpoints of the journey, as long as your infrastructure accurately captures them.

If you have sufficient conversion volume and clean signal — data-driven attribution is worth the investment. But verify the signal quality first. Running data-driven attribution on fragmented session data produces a model that's learned to distribute credit in a way that reflects your tracking gaps, not your users' actual behavior.

Attribution Is a System, Not a Setting

The teams that get the most reliable value from multi-touch attribution are not the ones running the most sophisticated models. They're the ones who've built the infrastructure to deliver clean, consistent signals — and then applied a model appropriate to their data quality and business questions.

Attribution accuracy is primarily an infrastructure problem. The model selection is secondary. A position-based model running on clean data from a well-configured redirect chain will outperform data-driven attribution running on fragmented sessions from a leaky implementation.

Start with the signal. The model follows.