CONTENT-HEAVY JOURNEY
Ad → Whitepaper → Webinar → Case Study → Demo → Blog → Purchase
Position-based gives the ad and the demo 80% combined. The four content pieces that built conviction split the remaining 20% — about 5% each. If your content actually drives conversion, that's a misallocation.
If each content piece builds conviction, they deserve more than a 20% split.
**Consider:** Linear attribution or custom weights.
### 2. Single-Session Conversions
If first touch = last touch (same session purchase), position-based adds no value:
*[Chart omitted from the text version: Reusable customer-journey visual for attribution articles.
Locals:
title: String header (uppercase tracking)
steps: Array of step hashes with keys:
day: "Day 1" / "Day -30" / "Same day" — small label above
label: "Facebook Ad" — main pill text
role: :inactive | :credited | :conversion (controls colour)
percent: optional small label under pill (e.g. "100%", "50%")
sublabel: optional italic text under percent
caption: String — italic caption under the row]*
For e-commerce impulse buys, simpler models work fine.
### 3. When You Have High-Volume Data
With 5,000+ monthly conversions, data-driven models can learn actual touchpoint importance rather than assuming 40-20-40. Why guess when you can measure?
> **Warning:**
> **The middle-funnel trap:** Position-based assumes middle touches matter less. For businesses where content marketing, email nurture, or progressive education drives conversion, this assumption may cost you insights.
## Position-Based Variations
### Standard U-Shaped (40-20-40)
The classic split:
- 40% to first touch
- 20% split among middle touches
- 40% to last touch
Best for: Standard B2B, clear intro/close distinction.
### W-Shaped (30-30-30-10)
Adds a third key position—typically "lead creation" (form fill, signup, MQL):
*[Chart omitted from the text version: Reusable customer-journey visual for attribution articles.
Locals:
title: String header (uppercase tracking)
steps: Array of step hashes with keys:
day: "Day 1" / "Day -30" / "Same day" — small label above
label: "Facebook Ad" — main pill text
role: :inactive | :credited | :conversion (controls colour)
percent: optional small label under pill (e.g. "100%", "50%")
sublabel: optional italic text under percent
caption: String — italic caption under the row]*
Best for: B2B with distinct lead capture moment, marketing → sales handoff.
### Custom Position-Based
Adjust percentages to match your funnel:
| Variant | First | Middle | Last | Use Case |
|---------|-------|--------|------|----------|
| Heavy nurture | 25% | 50% | 25% | Content-driven sales |
| Closer-focused | 30% | 20% | 50% | Fast conversion, many intros |
| Intro-focused | 50% | 20% | 30% | Awareness critical, many closers |
The 40-20-40 split is arbitrary—customize if you have reason to.
## How Position-Based Works
### The Math (U-Shaped)
```
If touchpoints = [first, middle1, middle2, ..., last]:
first_touch_credit = 0.40
last_touch_credit = 0.40
middle_credit_per_touch = 0.20 / (number_of_middle_touches)
Special cases:
- 1 touchpoint: Gets 100%
- 2 touchpoints: Each gets 50%
```
### Implementation
```ruby
class PositionBasedAttribution
def initialize(first_weight: 0.4, last_weight: 0.4, lookback_days: 90)
@first_weight = first_weight
@last_weight = last_weight
@middle_weight = 1.0 - first_weight - last_weight
@lookback_days = lookback_days
end
def attribute(conversion)
touchpoints = conversion.user.touchpoints
.where("occurred_at >= ?", conversion.occurred_at - @lookback_days.days)
.where("occurred_at <= ?", conversion.occurred_at)
.order(:occurred_at)
.to_a
return [] if touchpoints.empty?
case touchpoints.size
when 1
# Single touch gets 100%
[build_result(touchpoints.first, 1.0)]
when 2
# Two touches split 50/50
[
build_result(touchpoints.first, 0.5),
build_result(touchpoints.last, 0.5)
]
else
# First: @first_weight, Last: @last_weight, Middle: split @middle_weight
middle_touches = touchpoints[1..-2]
middle_credit = @middle_weight / middle_touches.size
results = [build_result(touchpoints.first, @first_weight)]
middle_touches.each { |tp| results << build_result(tp, middle_credit) }
results << build_result(touchpoints.last, @last_weight)
results
end
end
private
def build_result(touchpoint, credit)
{
channel: touchpoint.channel,
source: touchpoint.source,
medium: touchpoint.medium,
campaign: touchpoint.campaign,
credit: credit,
touchpoint_at: touchpoint.occurred_at
}
end
end
```
### W-Shaped Implementation
W-shaped requires defining the "lead creation" touchpoint:
```ruby
class WShapedAttribution
def initialize(first_weight: 0.3, lead_weight: 0.3, last_weight: 0.3, lookback_days: 90)
@first_weight = first_weight
@lead_weight = lead_weight
@last_weight = last_weight
@other_weight = 1.0 - first_weight - lead_weight - last_weight
@lookback_days = lookback_days
end
def attribute(conversion)
touchpoints = conversion.user.touchpoints
.where("occurred_at >= ?", conversion.occurred_at - @lookback_days.days)
.where("occurred_at <= ?", conversion.occurred_at)
.order(:occurred_at)
.to_a
# Find the lead creation touchpoint (e.g., form fill)
lead_touch = touchpoints.find { |tp| tp.is_lead_creation? }
# Distribute credit based on position
# ... (similar logic with three key positions)
end
end
```
The tricky part: defining what counts as "lead creation." Usually it's:
- Form submission
- Demo request
- Free trial signup
- MQL qualification
## Comparing Position-Based to Other Models
### Position-Based vs Linear
| Aspect | Position-Based | Linear |
|--------|----------------|--------|
| First-touch credit | 40% | Equal share |
| Last-touch credit | 40% | Equal share |
| Middle credit | 20% split | Equal share |
| Assumption | Ends matter more | All equal |
| Best for | Clear intro/close | Unknown importance |
**When to prefer position-based:** When you're confident first and last are most important.
**When to prefer linear:** When all touchpoints genuinely contribute equally.
### Position-Based vs Time-Decay
| Aspect | Position-Based | Time-Decay |
|--------|----------------|------------|
| First-touch credit | 40% | Low (decayed) |
| Last-touch credit | 40% | High |
| Logic | Position matters | Recency matters |
| Best for | B2B, long cycles | E-commerce, short cycles |
**When to prefer position-based:** B2B where sourcing matters.
**When to prefer time-decay:** E-commerce where recency correlates with intent.
### Position-Based vs First + Last Combined
Instead of position-based, some teams run first-touch and last-touch separately:
| Approach | Pros | Cons |
|----------|------|------|
| Position-based | Single unified model | Arbitrary 40/40 split |
| First + Last separate | Flexible analysis | Two numbers to reconcile |
Both work—position-based is simpler for reporting, separate is better for deep analysis.
## Common Position-Based Mistakes
### Mistake 1: Using 40-20-40 Without Thinking
The 40-20-40 split is arbitrary. If your middle-funnel content drives conversion, 40-20-40 undervalues it.
**Fix:** Analyze whether middle touches correlate with higher conversion rates. If so, consider increasing middle weight.
### Mistake 2: Not Handling Edge Cases
Two-touch journeys shouldn't give 80% to one path:
```
BAD: 2-touch journey
Ad → Purchase
40% + 40% = 80%? Where's the other 20%?
GOOD: 2-touch journey
Ad → Purchase
50% + 50% = 100%
```
**Fix:** Handle 1-touch and 2-touch journeys as special cases.
### Mistake 3: Ignoring Journey Length Distribution
If most journeys have 2-3 touchpoints, position-based behaves almost like first-touch + last-touch. The "middle" barely exists.
**Fix:** Analyze journey length distribution. If most journeys are short, simpler models may suffice.
### Mistake 4: W-Shaped Without Clear Lead Stage
W-shaped only works if you have a clear "lead creation" event. Without it, you're guessing which touchpoint to credit.
**Fix:** Only use W-shaped if you track explicit lead creation events (form fills, signups).
## Position-Based and GA4
Google Analytics 4 removed position-based attribution in 2023. Your options:
### 1. Third-Party Attribution Tools
Use mbuzz or similar tools that support position-based with configurable weights.
### 2. Build in Your Data Warehouse
```sql
WITH touchpoint_positions AS (
SELECT
conversion_id,
channel,
touchpoint_time,
conversion_value,
ROW_NUMBER() OVER (PARTITION BY conversion_id ORDER BY touchpoint_time) as position,
COUNT(*) OVER (PARTITION BY conversion_id) as total_touches
FROM touchpoint_data
),
credited AS (
SELECT
*,
CASE
WHEN total_touches = 1 THEN 1.0
WHEN total_touches = 2 THEN 0.5
WHEN position = 1 THEN 0.4
WHEN position = total_touches THEN 0.4
ELSE 0.2 / (total_touches - 2)
END as credit
FROM touchpoint_positions
)
SELECT
channel,
SUM(credit * conversion_value) as attributed_revenue
FROM credited
GROUP BY channel
ORDER BY attributed_revenue DESC;
```
## Implementing Position-Based in mbuzz
mbuzz uses **AML (Attribution Modeling Language)** — a small Ruby DSL — to define how credit is distributed. U-shaped is a three-line program; the weights are explicit arguments rather than hidden config.
### Basic U-Shaped (40-20-40)
```ruby
within_window 90.days
apply 0.4 to touchpoints[0]
apply 0.4 to touchpoints[-1]
apply 0.2 to touchpoints[1..-2], distribute: :equal
end
```
40% to the first touchpoint, 40% to the last, 20% split equally across the middle. The `distribute: :equal` modifier handles the middle pool. Edge cases (1 or 2 touchpoints) collapse cleanly: a single touchpoint takes all the credit; two touchpoints split 50/50.
### Custom weight distributions
Change the literal values to skew the model toward introduction, conversion, or nurture:
```ruby
# Closer-heavy (performance focus)
within_window 90.days
apply 0.3 to touchpoints[0]
apply 0.5 to touchpoints[-1]
apply 0.2 to touchpoints[1..-2], distribute: :equal
end
# Nurture-heavy (content-driven sales)
within_window 90.days
apply 0.25 to touchpoints[0]
apply 0.25 to touchpoints[-1]
apply 0.5 to touchpoints[1..-2], distribute: :equal
end
```
### W-Shaped (with a lead-creation position)
W-shaped extends the model with a third anchor point — typically the lead-creation event (demo request, free trial start, contact sales). Implementing it in AML uses the same conditional-logic pattern shown for custom models in the [AML reference](/docs/attribution-models): select the lead-creation touchpoints by their channel or event tag, then apply a fourth weight band.
## Tuning Position-Based for Your Business
Position-based is highly customizable. Here's how to tune the weights.
### Weights by Business Type
| Business Type | First | Middle | Last | Variant |
|---------------|-------|--------|------|---------|
| **B2B SaaS (standard)** | 40% | 20% | 40% | U-shaped |
| **B2B Enterprise** | 30% | 30% | 40% | Custom (lead creation) |
| **B2B with clear MQL stage** | 30% | 10% | 30% + 30% lead | W-shaped |
| **High-AOV e-commerce** | 35% | 30% | 35% | Balanced |
| **Content-driven sales** | 25% | 50% | 25% | Nurture-heavy |
| **Performance-driven** | 30% | 20% | 50% | Closer-heavy |
| **Brand-building focus** | 50% | 20% | 30% | Intro-heavy |
In AML, the levers are the literals on each `apply` line and the `within_window` duration. Stretch the window to 180 days for enterprise cycles; tighten it to 30 days for product launches.
### Seasonal and campaign adjustments
For a product launch view, increase `first_weight` to 0.50 (every introduction matters when the product is new) and shorten the window to 30 days. For an end-of-quarter closer view, push `last_weight` to 0.55 on a 45-day window. For a brand campaign view, run an intro-heavy variant (0.55 / 0.20 / 0.25) on a 60-day window. Run any of these in parallel with your standard U-shaped and compare the credit split.
### Team-based views
Different teams need different perspectives. Run multiple AML programs side-by-side: a demand-gen view (`first_weight: 0.60`), a performance view (`last_weight: 0.60`), and a leadership view (balanced 40/20/40). The DSL is small enough that maintaining three variants is cheap, and showing all three side-by-side is exactly what makes the political conversation tractable.
### Parameter Tuning Cheatsheet
| Scenario | Weight Adjustment | Why |
|----------|-------------------|-----|
| **Demand gen is undervalued** | Increase first_weight (50%+) | Credit sourcing more |
| **Closers are undervalued** | Increase last_weight (50%+) | Credit conversion more |
| **Content marketing critical** | Increase middle_weight (40%+) | Credit nurturing more |
| **Short sales cycles** | Use balanced 33-33-33 | All touches close together |
| **Long cycles with clear stages** | Use W-shaped | Credit lead creation separately |
| **Brand campaign running** | Boost first_weight temporarily | Measure awareness impact |
| **End of quarter push** | Boost last_weight temporarily | Measure closing impact |
| **New market entry** | Heavy first_weight (60%) | Every introduction matters |
| **Mature market** | Balanced or closer-heavy | Focus on conversion efficiency |
## Summary
Position-based attribution (U-shaped) gives 40% credit to first touch, 40% to last touch, and 20% to middle touches. It balances the need to credit both introduction and conversion while acknowledging the nurturing journey.
**Use position-based when:**
- B2B with clear sourcing and closing moments
- Multiple teams share pipeline responsibility
- You want both first-touch and last-touch credit in one model
- Long sales cycles with distinct funnel stages
**Don't use position-based when:**
- Middle-funnel content is critical to conversion
- Single-session conversions dominate
- You have high volume for data-driven models
- The 40-20-40 assumption doesn't match your reality
**Best practice:** Start with 40-20-40 as a baseline, then analyze whether your middle touches deserve more credit. Consider W-shaped for B2B with clear lead creation stages. Validate with incrementality tests.
## Further Reading
**On Attribution Models:**
- [First-Touch Attribution](/articles/first-touch-attribution) — Understanding introduction value
- [Last-Touch Attribution](/articles/last-touch-attribution) — Understanding conversion value
- [Linear Attribution](/articles/linear-attribution) — The neutral alternative
- [How to Choose the Right Attribution Model](/articles/how-to-choose-attribution-model) — Decision framework
**On B2B Attribution:**
- [B2B Attribution for Long Sales Cycles](/articles/b2b-attribution-long-sales-cycles) — Adapting attribution for B2B
## Key takeaways
- Standard split: 40% first-touch, 40% last-touch, 20% to middle
- Best for B2B where both pipeline sourcing and deal closing matter
- Under-credits middle-funnel nurturing (content, email sequences)
- W-shaped variant adds 30% to 'lead creation' moment for three key positions
## FAQ
**What is position-based attribution?**
Position-based attribution is a multi-touch model that gives extra weight to the first and last touchpoints in a customer journey. The most common split is 40-20-40: 40% to the first touch (introduction), 20% split among middle touches (nurturing), and 40% to the last touch (conversion).
**What's the difference between U-shaped and W-shaped attribution?**
U-shaped gives 40% to first and last touches. W-shaped adds a third key position—typically the 'lead creation' moment (form fill, signup)—and splits credit 30-30-30 to first, lead creation, and last, with 10% to other touches. W-shaped is for B2B with clear funnel stages.
**Is position-based better than linear attribution?**
It depends on your funnel. Position-based is better when introduction and conversion are genuinely more important than nurturing. Linear is better when all touchpoints contribute equally or when you don't want built-in assumptions about importance.
**Does GA4 support position-based attribution?**
No. GA4 removed position-based attribution in 2023 along with linear and time-decay. Only last-click and data-driven remain. Use a third-party attribution tool or build position-based in your data warehouse.
**What percentage should I use for position-based?**
40-20-40 is the industry standard, but you can customize. Some teams use 30-40-30 if middle-funnel nurturing is critical. The percentages are arbitrary—choose what reflects your business reality, or use data-driven models to learn actual weights.