Change the rule, and the winner changes
In the last post, the pizza shop owner opened four platform dashboards. AppLovin, TikTok, Pinterest, and Snapchat each reported "people who installed after seeing our ad," and the four added up to 448 installs. The app stores showed only 180. On the way through platform reporting, 180 real installs got inflated almost 2.5x into 448. When one person sees ads on all four platforms and then installs, each platform counts that install as "thanks to my ad," so one install gets counted several times.
To fix this, the ad industry brought in a shared referee. It stands outside the platforms, filters out duplicates with one rule, and hands the same number back to both advertisers and platforms. The industry calls it a Mobile Measurement Partner (MMP). The rule referees use by default is last-touch.
Last time, we only name-checked the other rules: first-touch, linear, time-decay, position-based, and data-driven. This post goes through them one by one and shows, in plain terms, which channel comes out the winner for the same single install depending on the rule.
Before the tour, one term we'll use the whole way through: credit. Say a user sees your ad on Instagram on Monday, again on YouTube on Tuesday, again while searching Google on Wednesday, and installs your app that evening. That's 1 install. How do you split the credit for that 1 install across the Monday, Tuesday, and Wednesday ads? That split is credit. Credit 1 means "that ad takes the whole install," credit 0.2 means "that ad takes 0.2 of the install," and credit 0 means "that ad is treated as contributing nothing." Under any rule, the credits for every ad that user saw add up to 1 (= 1 install). We'll sometimes write it as a percent too. Credit 0.2 = 20% and credit 1 = 100% are the same numbers in different notation.
Splitting 1 install into fractions can feel odd at first. If five ads each get 0.2 of one user's install, each ad logs "0.2 installs." The user installed once, but from each ad's side it counts as "my share is 0.2 installs." Channel performance is those 0.2s stacked up over a month or a quarter (we'll walk through the per-user to per-channel roll-up with a figure in the "From one user to channel performance" section near the end).
One big message to flag up front. An attribution rule looks like a calculator that spits out numbers, but it's really a decision lever. As we go through why last-touch became the industry standard, what each of the other rules is trying to see, and which rule fits which situation, you'll build a feel for answering "so which rule fits my situation?"
Every rule is an assumption
One term first. An attribution rule decides how much credit each ad gets when a user sees several ads and then converts (does whatever the advertiser counts as a result, like an install or a purchase). Unless we say otherwise, this post treats conversion = install. If a user saw exactly one ad and converted, that ad gets credit 1, and every rule gives the same answer. Rules only produce different numbers when a user went through several ads before converting.
Two premises sit underneath all of this.
First, at least one of the ads the user saw influenced the install. The rules in this post don't consider the possibility that no ad mattered at all.
Second, the install is entirely thanks to the ads. The ads split 100% of the credit among themselves. There's no separate slice for "saw the ads, but would have installed anyway." All of it goes to the ads. It's a pretty rough assumption.
Whether those two premises hold in the first place (in other words, "would the user have installed without the ad?") is a question the rules in this post can't answer. Attribution rules take both premises as true and focus only on splitting credit among the ads. Questioning the premises gets its own post next time, and it goes by the name incrementality. This post sets that question aside and only looks at "if both premises hold, how should the ads split the credit?"
On top of those two premises, every attribution rule is ultimately one assumption about "how much credit should each ad get." Different rules just mean different assumptions, and you can't tell which one is closer to "the truth" by looking at the rule. Last-touch, for example, assumes "the last ad the user saw had the biggest influence on the install decision." First-touch assumes the opposite: "the ad that first introduced the brand to the user is the starting point and deserves the most credit." The two rules pick completely different winners inside the same single install, and neither can prove it's more "true."
So choosing a rule is ultimately a business decision. Every service has its own sense of how its users respond to ads on the way to installing. For a service where users decide right after seeing an ad, "the ad right before install is decisive" can be a plausible assumption. For a service where users think it over for months, "earlier ads deserve a fair share of the credit" can look right. Which rule to use comes down to answering "when our users decide to install, which ad do we believe has the most influence?"
Now the rules, one by one. They fall into three groups: single-touch (one ad takes everything), multi-touch rule-based (several ads split credit by ratios a person set), and multi-touch data-driven (several ads split credit by ratios a computer worked out). Strictly speaking, they're single-touch attribution and multi-touch attribution, but we'll shorten them.
First, single-touch. Even if the user saw several ads before installing, exactly one of them gets the full credit 1. Instead of five ads getting 0.2 each, one ad takes the whole install and the rest get credit 0. Last-touch (the last ad takes it all) and first-touch (the first ad takes it all) belong here.
Next, multi-touch, rule-based. Several ads split the credit, but a person sets the ratio in advance. Linear, time-decay, and position-based live here.
Last, multi-touch, data-driven. Several ads split the credit, but no person sets the ratio. A computer works it out from past user data. Shapley value, Markov chain, and attention-based live here.
Rules where one ad takes it all (single-touch)
Last-touch (the last ad takes it all) and first-touch (the first ad takes it all) belong here. They're the simplest, which is why the industry has used this group the most so far.
Last-touch: the last one is everything
This rule rests on the assumption that the most recent ad the user saw before installing was the trigger. It's the same rule we introduced last time as the shared referee's (MMP's) default. Of all the ads the user saw, it picks only the most recent (last) one and hands it credit 1. If the user saw social on Monday, YouTube on Tuesday, and search on Wednesday, then installed that day, Wednesday's search takes the whole credit 1 and Monday and Tuesday get credit 0. It's the current industry standard and the default in MMP dashboards.
Because the design puts everything on the last ad, whatever the earlier ads built up never shows in the number. If the user saw your ad on YouTube a week ago and again on Instagram a few days ago, both still get credit 0, and Wednesday's search right before the install takes credit 1. That's not a flaw in the rule. It's intentional design, and the real question is whether that design matches how your users behave. For a service where users go from ad to install within a day or two, the assumption fits pretty well. For a service where users mull over installing for months, zeroing out every earlier ad can be a big distortion.
First-touch: the first one is everything
This rule gives credit 1 to the earliest ad the user saw. With Monday social / Tuesday YouTube / Wednesday search, Monday social takes the whole credit 1 and the rest get credit 0. It's last-touch flipped completely on the time axis. It starts from the assumption that "the ad that first introduced the brand to the user deserves the most credit for the install."
Every touch after the first ad gets cut to credit 0, so retargeting and performance channels tend to be undervalued. It's used by people who think the first ad's role in bringing the user to the brand weighs the most.
Single-touch: why a rough rule survived
Whether it's last-touch or first-touch, the assumption "that one ad gets 100%, the rest had zero influence" looks a bit odd on its face. It feels more natural to think every ad the user passed on the way to install did at least a little something. A branding banner glimpsed next to a news article, a video half-skipped while scrolling a feed: either one could have quietly made the brand logo feel familiar.
Still, single-touch has survived as the industry standard because the goal was never "the perfect number." It was a choice: "let's count everything with one simple rule everyone can agree on." Last-touch won that slot, the whole industry adopted it as the official number, and that's how the referee (MMP) system got running. The other rules aren't trying to push last-touch out of its seat. They're used as supplementary metrics that sit next to last-touch's official number and add "one more view from a different angle".
Same user, same three ads. Change only the rule, and "the winner of this install" becomes a completely different channel. From the advertiser's side, "which channel should I spend more on?" flips with the rule.
Rules where several ads split the credit (multi-touch, rule-based)
The shared weakness of single-touch is that "crediting only one ad feels a bit stingy." If a user saw five ads before installing and only one gets credit 1, the other four ads never make it into the performance numbers at all. That's why rules where several ads split the credit came along. This is called multi-touch attribution (MTA).
In this group, a person sets the split in advance: "give the ads the user saw credit in these proportions." Three versions are the most common.
Linear: everyone gets the same
Every ad the user saw gets the same share of credit. Five ads, 20% each. Three ads, about 33% each. Where other rules take a clear stance like "the last one matters" or "the first one matters," linear takes no stance and splits evenly. It's close to a declaration of neutrality: "we won't decide in advance which ad matters more." To some people, giving "the ad that first introduced the brand" and "the retargeting ad right before install" the same share looks fair. Others will push back: "there's no way those two had the same influence." Which assumption is more plausible is a different call for every service.
Use it when you want a neutral read on which channels were part of the user's journey at all.
Time-decay: closer means bigger
Ads closer to the install get a bigger share. If a user saw five ads before installing, in time order (first to last), the split could be 1%, 4%, 10%, 25%, 60%, growing sharply toward the most recent (the numbers are illustrative).
Exactly how much bigger, and how fast, is ultimately each service's call. There is one common rule in practice (something like "weight halves every 7 days"), but rather than the numbers themselves, it's enough to lock in the general direction: "the closer to install, the bigger the weight".
Last-touch is the extreme version, "the last ad gets 1, everything before gets 0." Time-decay is a smoothed-out version of that shape. The last ad still gets the most, but earlier ads get some credit too. But "closer means more important" isn't always true. Say a branding banner the user saw on YouTube months ago is what actually changed their mind. After that, the platform's algorithm decides "this user is responsive" and keeps serving retargeting ads, and right before install, a retargeting ad gets logged as the last ad. Time-decay hands the biggest credit to that retargeting ad, but what actually persuaded the user was the YouTube banner from months ago. Time-decay ends up underweighting that earlier ad.
Teams often use it when they want a softer version of last-touch.
Position-based: big at both ends, small in the middle
The assumption here is that the ad that first pulled the user in and the ad that finally got them to install matter most, and the ads in between play a supporting role.
The most common split is 40% to the first ad, 40% to the last, and the middle ads share the remaining 20%. With 3 ads: first 40% / middle 20% / last 40%. With 5 ads: first 40% / the middle 3 split 20% three ways, about 6.7% each / last 40%. Plotted, it's high at both ends and low in the middle, a U shape, which is why it's also called "U-shaped attribution."
The premise "both ends matter" sounds plausible, but 40/20/40 (first/middle/last) isn't a fixed rule. It's just a common convention. You could pick 35/30/35 or 45/10/45 with the same logic. In the end you tune it to your service. The core is the assumption that both "the spot that first introduced the brand" and "the spot where the final decision happened" get rewarded.
All three are cases where a person decided in advance: "with n ads, split the credit like this." Each one rests on a clear, simple assumption.
The problem is that there's no way to prove which of those assumptions is "the objective truth." To settle on "linear is right," the statement "every ad matters equally" would have to be true for your campaigns, and there's no way to prove that with data. You can use judgment to pick "this one seems more plausible for our service," but you can't lock in "this one is definitely right." That's why the next group showed up. Instead of having a person set the ratios, you show a computer the whole pattern of which ads past users actually saw before installing, and let it work out the ratios.
Rules where a computer sets the ratios (multi-touch, data-driven)
In this group, a computer, not a person, works out the ratios from past data. It's more complex to run than the rule-based group, but the difference is that it reflects real data: which ad combinations users in your app actually went through before installing. That said, those numbers also only hold within the premise "this is what our past data says." It doesn't mean "more data = closer to the truth."
Three come up the most: Shapley value, Markov chain, and the attention-based approach that's been rising since 2017. We'll go through each in detail.
Before getting into the three, here's one picture of how they differ from the rule-based rules we've seen. Compressed, it comes down to one question: "who sets the ratio?" With rule-based, a person sets the ratio by hand, and that's it. With data-driven, a computer looks at past data and works out the ratio every time.
Even among the three, there's another split.
Shapley and Markov use an explicit recipe a person can write down. It's a one-line rule like "average how much the install rate dropped when that ad was missing." Feed data into the rule and a number comes out, and a person can retrace "why this number?" with the formula.
Attention is different. All a person gives it is one direction: "assign each ad an importance number." The model learns how to assign them on its own, from hundreds of thousands of past records (which ads users saw, and whether they installed). So even looking at the result, it's hard for a person to retrace "why did this ad matter more?" with a formula.
Shapley value: with it vs. without it
This method measures an ad's credit by asking "how much would the install rate have dropped without that ad?" And not just once. In every ad combination that includes that ad, it measures the "with vs. without" difference, then averages them. A concrete example follows.
The Shapley value is a concept that mathematician Lloyd Shapley proposed in game theory in 1953. It started as an answer to "how do you split a prize fairly among team members?"
Analogy: three people, one team project
Say A, B, and C won a $1,000 prize as a team. How should they split it fairly?
You want to measure "how much did A contribute," but A can get something done alone, might do more when paired with B, and might do something different again with all three together. Looking only at "A's result alone" doesn't tell you how much A adds when B or C is around. So you take every team combination A could be in, and in each one you subtract "the same combination without A" from "the result with A," then average them. Let's follow it with numbers.
There are four team combinations A can be in: A alone / A+B / A+C / A+B+C. A is always in, and B and C are each either "in" or "out," so 2 × 2 = 4 combinations. In each of the four, you compare against "the same team minus A."
Some example numbers. Say past team project records show each combination's average prize like this.
| Team | Prize |
|---|---|
| Nobody | $0 |
| A alone | $100 |
| B alone | $200 |
| C alone | $300 |
| A + B | $400 |
| A + C | $500 |
| B + C | $700 |
| A + B + C | $1,000 |
A's share. For each of the four combinations that include A, subtract "the prize without A" from "the prize with A."
| With A | Prize | Without A | Prize | A added |
|---|---|---|---|---|
| A alone | $100 | Nobody | $0 | +$100 |
| A + B | $400 | B alone | $200 | +$200 |
| A + C | $500 | C alone | $300 | +$200 |
| A + B + C | $1,000 | B + C | $700 | +$300 |
The average of A's four additions = (100 + 200 + 200 + 300) ÷ 4 = $200. That's A's fair share. Run B and C through their own four combinations the same way and you get B = $350 and C = $450 (together, $1,000).
This idea, "measure the with-vs-without difference in every combination and average it," is the core of Shapley.
Applying it to ads
The ads are the team members, and the install rate is team performance. Each ad's credit is the average of "how much the install rate drops when that ad is removed," across every ad combination it can be in.
A numerical example. We dug through past user data and pulled the install rate for each combination of search, display, and email ads that users saw (made-up numbers). "Install rate" in the table means "out of 100 users who saw that combination, how many installed." Below you'll see a unit called percentage points (pp). If the install rate goes from 10% to 20%, the "10" it rose by is 10 percentage points.
| Ad combination the user saw | Install rate |
|---|---|
| Nothing | 0% (baseline) |
| Search only | 10% |
| Display only | 5% |
| Email only | 15% |
| Search + display | 20% |
| Search + email | 30% |
| Display + email | 20% |
| Search + display + email | 40% |
Four combinations in the table include search. Pair each one with "the same combination minus search" and compare.
| With search | Rate | Without search | Rate | Search added |
|---|---|---|---|---|
| Search only | 10% | Nothing | 0% | +10pp |
| Search + display | 20% | Display only | 5% | +15pp |
| Search + email | 30% | Email only | 15% | +15pp |
| Search + display + email | 40% | Display + email | 20% | +20pp |
The average of the four, (10 + 15 + 15 + 20) ÷ 4 = 15pp, is search's share. Display and email, done the same way, come out to 7.5pp and 17.5pp.
The three add up to 15 + 7.5 + 17.5 = 40pp, which exactly matches the 40% install rate of users who saw all three. Here, "40% install rate" means the bottom row of the table above: "40 out of 100 users who saw search + display + email installed" (the key point is that it's the install rate of the group that saw all three, not the app's overall install rate). In other words, there's a property here: add up how much each ad "lifted" the rate, and you get exactly the install rate of the group that saw all three ads. The Shapley formula is mathematically designed to land that way.
To compare channels by "what share of the total is each one responsible for," it's easier to make the three numbers sum to 1 (= 100%). So we divide each channel's share (pp) by the total install rate (40pp) and convert it into a per-channel split ratio. Search 15 ÷ 40 = 0.375, display 7.5 ÷ 40 = 0.1875, email 17.5 ÷ 40 = 0.4375. The three ratios sum to 1. That's the per-channel split ratio Shapley produces.
So how do you split 100 installs?
Shapley doesn't go user by user, taking apart each user's ad history ("this user's install splits like this, that user's like that"). Instead, it runs once over all the past data to get one set of per-channel split ratios (0.375 / 0.1875 / 0.4375), then applies those ratios to every install in that period. For 100 installs: search 37.5, display 18.75, email 43.75. For 1,000 installs: search 375, display 187.5, email 437.5. Shapley is a rule that splits installs at the channel level in proportion to how much each channel lifted the rate.
"Data-driven attribution" in Google Analytics 4 (GA4) asks the same question. Google's own documentation describes it as an approach that weighs "what would have happened without this ad?" That's exactly Shapley's question.
The problem is that as the number of ads grows, the number of combinations you have to look at grows unmanageably fast. With 3 ads, each ad has two states, "seen" or "not seen," so 2 × 2 × 2 = 8 combinations. The eight rows in the table above are exactly those eight. With 10 ads, it's 2 multiplied ten times: 1,024. With 20, it's well over a million. Every added ad doubles the number of combinations.
In a real commerce app, a user can see quite a lot of ads across several channels before installing. At just 20 ads, the combinations pass a million. And to run Shapley, you need "what % of users who saw this combination installed" for every single combination. With a million combinations and a million users, that's 1 user per combination on average. If that 1 user installed, the rate is 100%. If not, 0%. Every combination throws out an extreme number, so you can't trust the result statistically. Reality is worse. Many of those million combinations have zero users, so there's no install rate to compute at all.
So in practice, instead of running every combination, teams pick representative combinations and run the Shapley formula on those. It's a standard statistical technique called sampling. In the 20-ad case, instead of all million-plus combinations, you randomly pick 50,000 and run the formula on those. That's about 20x less compute, and the result comes out almost the same as the full run. Even with sampling, you need tens to hundreds of thousands of users' worth of past data, so Shapley is a rule that runs at the level of big advertisers or large platforms.
Markov chain: removing one channel from the flow chart
This rule draws the paths many users took from ads to install as one combined flow chart, then measures a channel's credit by how much the overall install rate drops when you remove that channel from the flow chart entirely.
It's similar to Shapley but works differently. The skeleton, "see how much it drops when you remove something," is the same. Where you remove it from is different. Shapley took apart ad combinations (search only / search + display / ...) one by one and averaged them. Markov merges many users' install paths into one flow chart and checks how much the overall install rate drops when one channel is erased. A "flow chart" here is a network diagram showing the order in which users went through ads on the way to installing. The Step 1 figure below is exactly that.
To make it something you can follow by hand, let's go step by step with a made-up example of 100 users.
Step 1: tally how 100 past users went through ads to install
Say 100 users came to your app through ads, and you have data on which channel's ads each one went through before installing. Going through each user's record and tallying "which channel's ad did this user see, and how many of them went on to install" gives you this.
(This is a made-up scenario to keep the explanation simple. We assume each user mostly saw ads from one channel. In reality, users bounce between several channels, and we come back to that at the end of this section.)
- Of the 100, 50 users saw search ads, 9 of them installed, and 41 didn't
- Of the 100, 30 users saw display ads, 6 of them installed, and 24 didn't
- Of the 100, 20 users saw email ads, 5 of them installed, and 15 didn't
Total installers = 9 + 6 + 5 = 20, for an overall install rate of 20%. The figure below sums up this flow as a single flow chart.
A quick walk through the flow chart. "Start (100 users)" on the left is the 100 users who saw at least one ad from any channel. Users who never saw an ad aren't in this flow chart. Those 100 users split into three groups based on the ads they saw: 50 in the search group, 30 in the display group, 20 in the email group. The installers from each group (9 / 6 / 5) flow into "Installed (20 users)" on the right, and the rest go to "Didn't install (80 users)."
Step 2: erase the search group from the flow chart
Now the experiment. Erase search from the flow chart completely. The 50 users in the search group are the ones grouped as "users who saw search ads." With search gone, we assume all 50 go to "Didn't install." In reality, some of them might install after seeing another channel's ads, but this scenario leaves that possibility out.
That leaves 6 installers from the display group + 5 from the email group = 11. The install rate dropped from 20/100 to 11/100, or from 20% to 11%. The 9pp drop (= 20 − 11) is search's share. This is called the removal effect.
Step 3: erase the other channels the same way
Erase display. The 30 users in the display group can't install, so the remaining installers = 9 from search + 5 from email = 14. The install rate is 14%, and the drop of 6 users (6pp) is display's share.
Erase email. The 20 users in the email group can't install, so the remaining installers = 9 from search + 6 from display = 15. The install rate is 15%, and the drop of 5 users (5pp) is email's share.
In a table:
| Removed | Before | After | Install rate | Drop (= share) |
|---|---|---|---|---|
| Search | 20 | 11 | 20% → 11% | 9 (9pp) |
| Display | 20 | 14 | 20% → 14% | 6 (6pp) |
| 20 | 15 | 20% → 15% | 5 (5pp) |
Step 4: convert to per-channel split ratios
The three drops add up to 9 + 6 + 5 = 20, exactly the original 20 installers. That's not a coincidence. In our scenario, each user belongs to exactly one ad group, so erasing a channel removes exactly that group's installers (9 / 6 / 5). That's why the three drops add up to the total number of installers.
Converted into per-channel split ratios: search 9/20 = 0.45, display 6/20 = 0.30, email 5/20 = 0.25. Just like Shapley, we end up with one set of ratios per channel. If the period had 100 installs, search gets 45, display 30, and email 25 as channel performance. Shapley removed from ad combinations, and Markov removed from the flow chart. "Where to remove from" differs, but the skeleton, "remove, get the ratios, multiply by channel," is the same.
So far, to keep things simple, we assumed "each user saw only one channel." In real multi-touch data, it's more common for a user to bounce across several channels, like search → email → display. Real Markov chain models account for those paths too.
For example, if a user originally went search → email → install, then even with search gone, there's still some chance this user gets to install through email alone. Markov folds that "remaining chance of installing" into the calculation as a number. Instead of the extreme assumption "erase search and that user 100% doesn't install," it accounts for the share of users who switch to another channel's path and install. Open-source tools like the R package ChannelAttribution handle this calculation automatically. The idea stays the same, though: measure how much the install rate drops when you remove one channel, and use that drop as the channel's credit.
Markov has a limit too. It captures movement between channels, but barely reflects how many times the user saw the same channel. For example, "a user who saw a social ad three times and then moved to search" and "a user who saw social just once and then moved to search" both get lumped into the Markov model as the same "one social → search move." Even if repeated social exposure played a big role in the decision, that credit gets underweighted in the number.
Still, Markov can be shown as a flow chart, and since its combinations don't explode the way Shapley's do, it runs even with many channels. Even without a huge amount of data, an analytics team can run it right away with a single open-source package like ChannelAttribution. Teams often use it when they want a flow chart that shows the "per-channel lift" that last-touch misses.
Attention-based: a model scores how much each ad mattered
Unlike the rule-based rules, no person sets the ratio in advance. Unlike Shapley and Markov, it doesn't measure what happens when you remove ads from combinations. Instead, an attention model trained on past data stamps a number on every single install: "which ad mattered more for this install." That number becomes each ad's credit.
Attention is "a mechanism that lets a model work out on its own which parts of the input to focus on." The large language models (LLMs) we use every day, like ChatGPT and Claude, run on attention as their core principle.
How does ChatGPT build an answer?
Ask ChatGPT "I ordered pizza at a restaurant yesterday, but it was way too salty. Should I go back?" and it builds an answer. That question has 17 words. To build an answer, ChatGPT has to decide internally how much weight to give each word in the question. "Salty" and "go back" are the core, so they get heavy weight. Words like "yesterday" and "a" just give context, so they get light weight. ChatGPT builds its answer from these "importance numbers per word." That importance number itself is attention.
The key point is that no person told ChatGPT in advance that "salty is the important word." While training on trillions of sentences, it learned the pattern "some words have a bigger influence on the answer" on its own, and every time a new question comes in, it recalculates "where to focus in this sentence" based on that learned pattern.
Bringing this to ads
If ChatGPT's input was "the words in a sentence," the input in attention-based attribution is "the ads the user saw before installing." Feed the attention model a user's ad history (Mon social → Tue search → Wed display), and attention stamps a number on each of the three ads: "how much did this matter for this install." It's exactly like ChatGPT reading a sentence and scoring each word's importance. The numbers might come out as Mon social 30%, Tue search 50%, Wed display 20%, and those three numbers become each ad's credit as is.
How does attention figure out this importance?
So how does an attention model come up with numbers like "Mon social 30%, Tue search 50%"? Here's how. Show the model the ad histories + install outcomes of hundreds of thousands of past users all at once, and it repeatedly sees patterns like "installs tend to happen when this ad sits in this position." Storing those patterns as numbers inside the model is what training is. When a new user's ad history comes in, the model uses those learned numbers to score "for this user, Mon social played about a 30% role and Tue search about 50%." It's the same structure as ChatGPT scoring "salty" as an important word, just with the input switched from "words in a sentence" to "ads the user saw".
Strictly speaking, attention has formulas too. But with Shapley/Markov, you plug data into the formula and the number comes straight out. Plug user data into a rule like "average the with/without difference across combinations" or "change in install rate when you remove a channel from the flow chart," and you get a result, and a person can follow the process with pen and paper. Attention's formula, by contrast, contains internal numbers that decide "which ad matters more" (billions of model parameters), and no person sets those numbers. The model tunes them by looking at past data. So the same user history can give different results depending on how far the model has been trained. You can follow the math mechanically, but billions of internal numbers interact with each other, so it's hard to explain in plain words "why this ad came out as more important." It handles any number of ads as is, and it accounts for the order the ads were seen in. "Mon social → Tue search" and "Tue search → Mon social" (only the order changed) get different importance numbers.
The attention mechanism is a basic building block for understanding LLMs and AI agents in general, so we'll cover it properly in a later topic. For this post, it's enough to take away "so that's how attention gets used in attribution."
There aren't many public commercial examples yet. The best known is LinkedIn Data Driven Attribution (LiDDA), which LinkedIn published in 2025. According to the published paper, it's a model built on attention. It puts everything into one model, the ad history a user saw on LinkedIn + platform-wide aggregate performance + external factors like economic conditions, and scores each ad's importance.
Two limits. First, it needs a lot of past data to work. Without records for hundreds of thousands of users or more, the model doesn't have enough to learn from. Second, the can't-explain-the-result problem from earlier bites especially hard in practice. When an exec asks "Why is Tuesday search so big?" the honest answer is pretty much "That's what the model scored." Shapley and Markov can unpack the number ("it dropped this much when we removed it"), but with attention, that explanation path is basically blocked.
Here's one decisive difference from Shapley and Markov. Shapley and Markov produced one set of ratios per channel and applied the same ratios to every install. Attention produces different importance numbers for each user's install. User A's install might get "Tue search 50%," user B's might get "Mon social 60%," and the model recalculates for every install. Channel performance is those per-install numbers stacked up over a month or a quarter. With 100 installs, you take the 100 different sets of importance numbers, collect them by channel, and tally "this month, search got this many installs and social got that many."
So what should I use?
At heart, it's a business decision. As we set up at the start, you choose by answering questions like "is the last-touch assumption plausible for our users' journey?" But there's one practical constraint that gets in the way: data volume. Even if the Shapley assumption fits your service well, if you get a few hundred installs a day, you won't have enough users per combination, so running Shapley at all isn't possible. So the natural order is to first get a feel for "which rule's assumption is more plausible for our service," then filter down to "which rules can we realistically run" by data volume. Below is a rough guide to that second step (how far your data volume lets you go).
- A few hundred installs a day or fewer. You don't have the data to run anything data-driven. The realistic move is to use the last-touch number your MMP gives you automatically as the official number and, if needed, look at one of first-touch, linear, time-decay, or position-based alongside it, whichever fits your service.
- Thousands of installs a day. On top of the rule-based supplement above, it's worth also running a Markov chain as a supplement. Your analytics team can run it in-house with a single open-source R package,
ChannelAttribution. But narrow it down to 3 or 4 channels to get numbers you can trust. - Tens of thousands to hundreds of thousands of installs a day, or more. This is a rare scale, big global advertiser territory. Here you finally have the data for Shapley or even attention. It used to require a dedicated machine learning team, but these days LLMs take a lot of the coding, data prep, and result interpretation off an analytics team's plate, so the barrier is dropping fast.
At any scale, last-touch is very unlikely to lose its spot as the MMP's default official number anytime soon. The whole industry runs on a system of "count everything with one shared rule." The other rules are there for "one more view from a different angle," next to that official number. Rather than the decision itself flipping, the evidence behind the decision grows from one source to two or three.
From one user to channel performance
The rules we've seen split into two ways of rolling results up to the channel level.
- Split per user journey, then stack: last-touch / first-touch / linear / time-decay / position-based + attention. They look at one user journey at a time (the sequence of ads seen before that install), split it across the ads, then add up hundreds to tens of thousands of them by channel.
- Get one set of per-channel ratios, then multiply: Shapley / Markov. Instead of going user by user, they get one ratio per channel from all the past data (e.g. search 45%, display 30%, email 25%), then multiply the total install count by those ratios to get each channel's share (with 100 installs: search 45, display 30, email 25).
Either way, the results end up in the same place: channel-level performance, like "search drove this many installs this month."
What matters in the totals is that channel rankings can flip depending on the rule. For the same period, the #1 channel under last-touch and the #1 channel under Shapley can be different, and whichever is #1 gets more budget next quarter. A rule looks like a tool for producing numbers, but in practice it works as a budget-decision lever.
Questions attribution can't answer
All eight rules covered so far answer one question: "how should the credit be split among the ads a user saw before installing?" But ad measurement has a few more questions that the rules in this post struggle to answer. Each one gets its own post later, so here we'll just name them.
Was the ad really the cause? The rules above start from the assumption "the user saw ads and installed, so let's split the credit among the ads somehow." But even if a user came in through an ad, that ad might not have had much effect on the install. Say a friend recommended the app, so the user has already decided to install. They search for the app's name and tap the search ad at the top. Last-touch gives that whole install to the search ad. But even without the ad, this user would have tapped the regular search result right below it and installed anyway. The ad didn't really earn the credit. Broadly, you could count this question as a branch of attribution too, but the approach is so different from the rules in this post that it gets its own bucket. It's called incrementality (put simply, "how many extra installs happened because of the ad"), and we'll go deep on it in the next post.
Channels you can't track at the user level, and a world where that keeps spreading. The rules above only work if "which user saw which ad" is left behind as data. But some channels were never trackable (TV, outdoor ads), and on top of that, since Apple introduced App Tracking Transparency (ATT) on iOS in 2021, it's gotten hard on iPhone to even confirm that "the person who saw this ad on Instagram" and "the person who installed the app" are the same person. If the user doesn't allow tracking, the clue that would connect the two disappears. Both situations boil down to the same problem, "we can't measure at the user level, but we still need channel performance," and two approaches often come up together. One is Marketing Mix Modeling (MMM), which estimates channel effects from aggregate spend and sales data. The other is Apple's own iOS alternative, SKAdNetwork (SKAN), introduced in 2018: when an install happens, Apple sends the channel only a signal that "this ad produced 1 install," without saying who installed. Its successor, AdAttributionKit, announced in 2024, builds on SKAN's core features and adds measurement for retargeting. We'll cover them one by one in upcoming posts.
What this means in practice
What you can actually do is pick not "which rule is right" but "which rule best answers the business question in front of me". Keep platform settlement on last-touch, the industry standard, but rerun your new-user acquisition review through first-touch. Use last-touch as the official metric, and cross-check with Shapley or Markov for internal analysis. Putting another rule's number next to the official one and comparing them is something anyone can do.
To make that choice well, there's one thing to flag. A rule called "data-driven," with a fancy name or a more complex calculation, isn't automatically the better choice. What matters is picking the rule that fits your service. Picking well means using that number to make your next marketing decision more accurately, and in the end, raising ad efficiency and getting real return on investment (ROI) for the business.
And as much as picking the right rule matters, so does reading the number critically instead of taking it at face value. Say search ads come out #1 under last-touch. But a good chunk of those installs could be users who had already decided to install after seeing a YouTube ad, searched for the app name, and tapped the search ad at the top. YouTube brought the user in, but search took the credit. A last-touch report only shows "search ad installs: N," not whether those users saw a YouTube ad first. But if you're the person who has actually lived through "we turned off YouTube ads and search installs dropped too," you won't take search's #1 at face value. In the end, you have to layer that kind of experience over the report numbers. That's what keeps you from jumping straight to "search is #1, so let's raise the search budget," and makes you ask once more whether the YouTube budget needs protecting first. As those calls pile up, you gradually learn which rules actually make sense as metrics for your service.