Value Laddering: How to Feed a Six-Month B2B Pipeline Into a 90-Day Ad Platform

Your B2B sales cycle is six months. Google Ads will only credit an offline conversion to a click for up to 90 days.

Do the maths on that and most "send your closed-won revenue back to the ad platform" advice falls apart. The deal closes, someone uploads it, and the click that started it has already aged out. The upload may even go through without an error, so everyone assumes it worked. The bidding algorithm never learns which campaigns produced revenue, so it keeps optimising for the thing it can see: form fills. CPL falls, pipeline doesn't move, and nobody can explain why.

Value laddering is how you close that gap. This piece covers what it is, how to price it, the trap that inflates the numbers, how it differs across Google, Meta and LinkedIn, and the single dependency that decides whether any of it works.

One conversion at the end is too late

Ad platforms learn from feedback, and feedback that arrives after the attribution window closes is useless for bidding. A B2B buyer who clicks in January and signs in July has produced the most valuable outcome your campaigns can deliver, and the platform will never connect the two.

The instinct is to optimise for something earlier instead, usually the lead. But a lead is a weak proxy. Most leads never become revenue, and the ones that do look identical to the ones that don't at the moment of the form fill. Optimise for leads and the algorithm gets very good at finding people who fill in forms.

What you want is a signal that arrives early and still carries information about revenue. That's the ladder.

What a value ladder is

Instead of one conversion at the end, every meaningful stage in your CRM pipeline fires as its own conversion, each carrying a monetary value: MQL, SQL, demo held, proposal sent, closed won.

Early rungs reach the platform within days or weeks of the click, well inside the window. Each one tells the algorithm not just that something happened, but how much it's probably worth. The platform starts bidding toward traffic that produces pipeline, and the later rungs refine that picture as deals progress.

Pricing each rung

The values shouldn't come from a workshop or a gut feel. They should come from your own pipeline history, using one formula: the stage's historical close rate multiplied by your average won deal.

If 12% of your SQLs eventually close and your average won deal is $28,000, an SQL is worth $3,360 in expected value. Here's a full ladder built on the same assumptions:

The timings are illustrative, but the pattern is typical: the first three or four rungs land inside a 90-day window, and closed won often doesn't.

One rule matters more than the formula. If a stage has fewer than 20 historical data points, don't calculate a value from it. A precise-looking number built on four deals is worse than an honest estimate, because it carries false confidence into the bidding. Use a declared figure until the data catches up, and recalculate on a schedule as it does.

The double-count trap

Notice the last column. It isn't the expected value. It's the increase in expected value since the previous rung.

This is where most ladder setups quietly go wrong. If you send the full expected value at every stage, a single won deal reports $840 + $3,360 + $5,600 + $9,800 + $28,000, which is $47,600 for a $28,000 contract. The platform now believes your campaigns are 70% more valuable than they are, and it will bid accordingly.

Sending the increment fixes that. Add up the right-hand column and a won deal totals exactly $28,000. Each rung is effectively an advance payment on the deal's expected value, and closed won is the true-up.

When deals die

Most deals don't close, and that's already priced in: an SQL is worth $3,360 precisely because 88% of them are lost. But once a specific deal is lost, the value you advanced on it is no longer an expectation. It's revenue that will never exist.

So retract it. When a deal is marked closed lost, withdraw the rung values already reported for it. Across a cohort, this converges on reality. A hundred SQLs report $336,000 in expected value. Twelve close at $28,000 each, which is also $336,000. The early signal and the final truth agree, and in the months in between the algorithm was learning from a reasonable estimate rather than silence.

Skip retractions and the algorithm is permanently trained on revenue that never arrived, which pushes it toward campaigns that generate optimistic-looking SQLs rather than ones that close.

Whether you can retract depends on the platform, which is the next problem.

The ladder isn't the same on every platform

Google Ads is where the full ladder works best. Offline conversions can carry values, the bidding strategies can optimise toward value, and Google supports adjustments that retract a conversion or restate its value. Two practical points: make your ladder rungs the primary conversion actions and demote the raw form fill to secondary, or you'll double count the top of the funnel. And keep the 90-day limit in mind, since the late rungs of a long cycle may miss it.

Meta works differently. Its CRM-based optimisation for B2B is built around native Lead Ads forms rather than website leads, and it optimises toward a chosen pipeline stage rather than a stack of values. It also has tight timing rules: stage events need to be sent within days of happening, and the stage you optimise toward should typically occur within about four weeks of the lead. In practice that means picking one early, reachable rung, usually MQL or SQL, rather than sending the whole ladder.

LinkedIn sits in between. Its Conversions API accepts offline events up to 90 days after they happen, and its attribution windows can extend beyond 90 days for lead-type conversions. But its bidding is less mature than Google's for value-based optimisation, and it has less volume to learn from. Send one or two rungs, typically SQL and closed won, and treat the rest as reporting. If you use LinkedIn's native Lead Gen Forms, the chain-preservation problem shifts from the click ID to whether your CRM sync keeps the lead's LinkedIn identifier intact.

The broader point: a ladder is a pipeline model, not a platform setting. Build it once from your CRM, then decide how many rungs each platform can actually use.

The part that decides everything

All of the above is the easy part. Values, increments and retractions are arithmetic.

None of it works unless the click ID survives the whole journey: ad click, landing page, three more pages, a form embedded from a vendor iframe, then into a CRM property someone forgot to map. Most B2B sites break that chain somewhere. Lose the click ID and you fall back to hashed email matching, which on Google has a shorter window and a lower match rate. Lose that too and the deal can't be attributed at all.

This is also where the danger sits. If a large share of your outcomes can't be tied back to a click, the ones that can are not a random sample. They're whichever journeys happened to survive, which may be the short, simple ones. Feed that into live bidding and you're training the algorithm on a distorted picture of what works. That's worse than feeding it nothing, because from the dashboard nobody can tell the difference.

So set a threshold. If more than roughly 30% of outcomes can't be matched to a click, stop sending until the chain is fixed.

A diagnostic you can run this week

Before building any ladder, check whether your data can support one:

• Click a live ad yourself, go through the journey, submit the form, and check whether the gclid, fbclid or li_fat_id appears on the resulting CRM record.
• Repeat through every form type you use, including embedded vendor forms and chat widgets, since these are where the chain most often breaks.
• Pull the last 90 days of CRM leads from paid campaigns and calculate what share have a click ID stored. That percentage is your ceiling for attribution.
• For each pipeline stage, count how many historical deals passed through it. Any stage under 20 gets a declared value, not a calculated one.
• Measure the median time from first click to each stage. Any rung that typically lands after 90 days won't reach Google in time.
• Check whether closed-lost is recorded reliably, with a date. Without it you can't retract.
• Look at your current Google Ads conversion actions and confirm which are primary. If form fills are primary alongside pipeline stages, you're double counting today.

Most teams find their answer at step one. The useful question isn't "what's our CPL?" It's "does our click ID actually make it into the CRM?"

How we're building this into Atlas

We've been building this logic into Atlas, our conversion signal platform: stage values derived from each client's own pipeline history with a minimum-data rule, automatic retractions when deals are lost, and a cut-off that switches delivery off when more than 30% of outcomes can't be matched to a click.