Diff the live ad every night

Problem: the approved ad and the served ad can differ. Platform AI features add links, translate copy, generate images. Some switch on by default or through account updates. Under Meta’s new terms the advertiser carries the risk of whatever its AI features create or change.

Approval is a one-time event. The ad keeps running. So the check has to keep running too.

This is the job I’d want. It’s a design, not something I’m claiming runs today.

The job (nightly, per account):

1. Load the approved version of every live ad: copy, headline, image hashes, links, language, enhancement settings.
2. Snapshot what’s actually serving, from whatever the platform exposes about the delivered version.
3. Snapshot the enhancement settings too. A setting that flipped is a change even if nothing rendered differently yet.
4. Diff field by field.
5. For each difference, look up our own change log. Matched to a person or our own tool? Note it. No match? It’s a platform change.
6. Platform change on a field we didn’t open to the platform? Flag it for a person, with before and after.
7. Snapshot failed, timed out, or came back empty? Flag it. Don’t record “no changes.”

for ad in live_ads(account):
    approved = approved_version(ad)
    try:
        served = snapshot(ad)
    except Exception:
        flag(ad, "snapshot failed, unknown state")
        continue
    for field, before, after in diff(approved, served):
        actor = our_change_log.match(ad, field, after)
        if actor:
            record(ad, field, before, after, actor)
        else:
            flag(ad, field, before, after, actor="platform")
    store(ad, served, taken_at=now())

Why nightly. The changes that matter happen after launch. A weekly check gives a changed ad up to a week of delivery before anyone looks. Nightly is a knob. High-spend or regulated accounts could justify more often.

Why “who changed it” is a column. The diff alone says something changed. The useful report says whether we did it. Without our own change log, every difference looks the same and the flags get ignored.

Why a failed snapshot is a flag. The tempting bug is treating “couldn’t read it” as “nothing changed.” That turns every API hiccup into a clean night, which is the exact blind spot the job exists to close.

Why store every snapshot. The nightly store is the record. If someone later asks what a customer saw on a given date, the answer is a dated snapshot, not the approval email.

What gets logged, every run:

• ad id, snapshot time, fields compared
• each difference: before, after, actor (person, our tool, platform, unknown)
• flags raised, and who cleared them
• snapshots that failed, and why

Not solved:

• What the platform reports may be the asset we uploaded, not what rendered after enhancement. If the reporting surface doesn’t show the enhanced version, the job needs a rendered capture, and that’s harder to automate.
• Dynamic creative legitimately serves many combinations. The baseline has to be the set of approved variants, not one ad, or every night is a false alarm.
• Placements render differently. A crop on one surface isn’t the same as a generated image. The diff needs rules for what counts as a change.
• Translations: is a translated headline a change to the approved copy? I’d say yes, flag it, and let a person decide.

Tells you don’t have this:

• The first sign of a platform edit is a customer screenshot.
• Nobody can say which AI enhancements are on in a given account today.
• “What ran on the 14th?” gets answered with the approved file.

Diff the served ad against the approved one. Treat a missing snapshot as a flag, not a pass.

If a platform's AI can change a live ad and the advertiser carries the risk, I want a nightly diff.

Snapshot what's actually serving. Compare it to what was approved. Flag anything nobody on the team changed. Missing snapshot counts as a flag, not a pass.

Ad platforms are adding AI features that can change a live ad after launch, such as added links, translated copy and generated images, and Meta's new business terms put the risk of those changes on the advertiser. Approving the ad once isn't enough when the served version can drift from the approved one. The job I'd want is small: every night, snapshot what each live ad is actually serving, compare it field by field with the approved version, attribute each difference to a person, our own tools, or the platform, and flag anything the platform changed that nobody approved. If the snapshot can't be taken, that's a flag too, because silence isn't proof the ad is unchanged. I wrote up the design and the parts I haven't solved.

https://acidlemon.com/posts/2026-11-02-diff-the-live-ad-every-night/