Skip to content
Ashish Kumar AgnihotriOperating Partner

A global advertising network · Advertising & media operations

A three-step Makegoods QA framework that protected $20M+ in billings

When delivered campaigns miss their guarantees, the agency owes makegoods — and at scale, undetected shortfalls become a direct, recurring loss. The fix was a quality framework precise enough to catch them before the client did.

When a delivered campaign falls short of what was guaranteed, the agency owes the client a makegood. One shortfall is a cost of doing business. At the scale of a global advertising network, undetected shortfalls become something worse: a recurring, invisible leak that drains money every cycle and quietly erodes client trust. That was the problem I was asked to solve.

The brief was precise. Catch the delivery shortfalls before the client did, across a volume of campaigns far too large for manual, ad-hoc checking, and do it in a way that could be proven rather than merely asserted. The existing process caught problems inconsistently and could not demonstrate its own coverage — which meant nobody could say with confidence how much was slipping through.

I built a three-step Makegoods QA framework that protected more than USD 20 million in client billings by catching shortfalls while they were still correctable. It became the standard QA approach for the function. I will describe the method and the reasoning here; I keep the client unnamed, as the engagement was confidential.

01The challenge

Across a very large volume of campaigns, discrepancies between what was promised and what was delivered were surfacing late — often after invoicing, sometimes after the client found them first. Each one carried a makegoods liability and an erosion of trust. The volume was far too high for manual, ad-hoc checking, and the existing process caught problems inconsistently, with no way to prove coverage.

02The intervention

What I actually did.

  1. 01

    Architected a three-step Makegoods QA framework that staged the check at the points in the delivery cycle where errors were both most likely and still correctable.

  2. 02

    Standardised what was inspected and how it was scored, so coverage was provable rather than assumed — and so results were comparable across teams and markets.

  3. 03

    Built the framework to run at the volume of the operation, prioritising the campaigns and failure modes that carried the most financial exposure.

  4. 04

    Wired the findings back into delivery, so recurring causes were removed at source rather than re-caught every cycle.

03The outcome

The framework protected more than USD 20 million in client billings by catching delivery shortfalls before they became makegoods liabilities — converting an invisible, recurring leak into a controlled, measured process. It became the standard QA approach for the function.

$20M+

in billings protected

3-step

staged QA framework

Standard

adopted as the function-wide QA approach

Client identity withheld under confidentiality. The figures are real and were measured at the time of the engagement.

In depth

The operating reasoning behind the result.

The operating problem beneath the makegoods

A makegood is a symptom. The underlying problem was that the gap between what was promised and what was delivered surfaced too late — often after invoicing, sometimes only when the client found it first. By then the agency had two costs: the makegood liability itself and the harder-to-price erosion of trust that comes from a client catching your error before you do. The volume made manual checking hopeless, and the existing process had no way to prove what it had and had not inspected. So the real task was not to check harder. It was to design a system that caught shortfalls early, ran at the operation’s scale, and could demonstrate its own coverage.

Why timing was the whole design

A quality check is only worth running at a point where the error is both likely to occur and still correctable. Check too early and the failure has not happened yet; check too late and all you can do is confirm a loss you can no longer prevent. The three steps were placed at exactly the points in the delivery cycle where those two conditions overlapped — where shortfalls tended to appear and where there was still time to act on them before they hardened into a makegood. That staging is the core of the framework. It is the difference between a QA process that prevents losses and one that merely documents them after the client has already been disappointed.

Making coverage provable, not assumed

The old process could not answer a basic question: what did we actually inspect? I standardised what was checked at each step and how it was scored, so coverage became provable rather than assumed. That standardisation did two things. It closed the gaps where shortfalls had been slipping through unexamined, and it made results comparable across teams and markets, so the function could see where exposure concentrated. Provable coverage matters beyond catching errors — when a client or a senior stakeholder asks how delivery is assured, the honest answer is a defined, scored process rather than an assurance that people are being careful. Confidence does not survive scrutiny; a measured standard does.

Built to run at the volume of the operation

A framework that cannot keep pace with the work is theatre. This one was built to run at the real volume of the operation, which meant it could not treat every campaign identically — there was neither time nor justification for that. Instead it prioritised by financial exposure, placing the heaviest scrutiny on the campaigns and failure modes that carried the most money at risk. Not all shortfalls cost the same, and a flat checking process spreads attention thin across trivial and serious alike. Weighting the checks by exposure is what let limited QA effort defend the largest liabilities first, and it is a large part of why the framework protected the value it did.

Closing the loop so causes were removed at source

Catching the same shortfall every cycle is better than missing it, but it is still a recurring cost. So the framework fed its findings back into delivery, so that recurring causes were removed at source rather than re-caught indefinitely. A defect that is designed out stops consuming QA effort forever; a defect that is merely inspected out has to be caught again and again. This is what turned the framework from a net under the operation into a mechanism that actually improved it over time. Each cycle, the most common failure modes were not just caught but eliminated, which meant the checking could keep moving up to the next tier of exposure rather than re-fighting old battles.

The transferable principle

The principle holds anywhere a guarantee meets delivery at scale. A recurring liability is rarely an effort problem and almost always a system problem: errors surfacing too late, coverage that cannot be proven, and attention spread evenly instead of by exposure. The fix is to stage the checks where errors are both likely and still correctable, standardise them so coverage is provable, weight them by financial risk, and feed findings back so causes are removed rather than re-caught. Whether the guarantee is media delivery, an SLA, or a regulatory commitment, the same discipline converts an invisible leak into a controlled, measured process you can defend.

Questions

Common questions.

The framework was developed and then embedded into the delivery cycle, which is the part that takes real time — designing the three staged checks is faster than proving they hold at full volume across teams and markets. The protected value accrued cycle after cycle as the framework ran, not in a single moment. I would characterise it as an engagement that first stood the system up, then demonstrated its coverage, and then improved on it as findings fed back into delivery and recurring causes were removed. The durable proof was that it became the standard QA approach for the function rather than a one-off exercise.

It reflects the client billings that would have been exposed to makegoods liability had the shortfalls reached the client uncaught, but were instead caught and corrected in time. In other words, it is the value the framework defended by intervening before a guarantee was breached at the client’s expense. The figure exceeded USD 20 million. It is a measure of loss prevented rather than revenue created, which is exactly why an invisible, recurring leak of this kind is so easy to under-manage — until it is made visible, nobody can see the money quietly going out the door each cycle.

Because a single final check can only confirm a loss, not prevent one. By the time work is finished and ready to invoice, a shortfall is no longer correctable — all a late check can do is reject it. The three steps were placed at the points in the delivery cycle where errors were both likely to appear and still fixable, so problems were caught while there was time to act. Staging the checks this way is what makes a QA framework preventive rather than merely diagnostic. The number three was not arbitrary; it matched where the meaningful, correctable failure points actually were in the cycle.

No. The engagement was confidential, and I describe the client only by role and scale — a global advertising network operating at very high campaign volume. I treat the specifics of any client engagement as theirs, not mine to publish. What I can share fully is the method and the reasoning behind it, which is the part that transfers to other operations. The discipline of staging checks by correctability, making coverage provable, weighting by financial exposure, and removing causes at source is not confidential, and it is what a prospective client actually needs to evaluate the work.

Yes. The framework is really about protecting any commitment that is delivered at a volume too large to check by hand — a service-level agreement, a delivery guarantee, a compliance obligation. Anywhere a promise meets execution at scale, shortfalls tend to surface late and unevenly, and the liability compounds. The same approach applies: find the points where failures are likely and still correctable, place staged checks there, standardise them so coverage is provable, prioritise by what is most costly, and feed findings back to remove recurring causes. The advertising context is the example; the mechanism is general.

By two design choices. First, it was standardised and scored, so it did not depend on individual diligence to keep working — coverage was defined and provable rather than a matter of who happened to be careful. Second, it fed findings back into delivery, so it improved rather than decayed: each cycle removed recurring causes and freed the checking to defend the next tier of exposure. Becoming the function-wide standard was itself the durability mechanism, because a defined standard maintained across teams outlasts a practice that lives only in the habits of the people who first ran it.

Next case

95% → 99%

Lifting quality from 95% to 99% across 2,000+ campaigns

There is a number like this in your operation.

A diagnostic is the fastest way to find it and put a figure on what fixing it is worth.

Book a consultation