SponsorProof: Catch Sponsorship Mistakes Before You Hit Submit with Local AI

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

SponsorProof: Catch Sponsorship Mistakes Before You Hit Submit

What I Built

Ever finished a sponsored video script, felt confident about it, and then discovered that you missed the exact discount code, forgot a mandatory hashtag, or skipped a talking point buried in the brand brief?

That’s the problem SponsorProof is built to solve.

SponsorProof is an evidence-based compliance auditor for content creators, video editors, and marketing agencies. It compares a brand's campaign brief against a draft script, transcript, or caption and catches potential compliance issues before the content reaches the client.

Here’s what it checks:

• Exact requirements: Verifies discount codes, required hashtags, sponsor URLs, and disclosure phrases using deterministic code rather than relying on an LLM.
• Semantic requirements: Uses local Google Gemma 3 to evaluate talking points, prohibited claims, product benefits, and tone.
• Verifiable evidence: Links findings to verbatim excerpts from the brief and draft, making it easier to understand why something was flagged.
• Duration and pacing: Estimates spoken content duration using word count and an approximate speaking rate.
• Actionable corrections: Suggests copy-paste-ready text to address missing or questionable requirements.
• Shareable reports: Exports audit results as Markdown or structured JSON.

One important design decision: SponsorProof doesn't blindly trust the AI. If the model marks a requirement as compliant but the evidence verifier cannot find supporting text in the draft, that finding is downgraded to NEEDS_REVIEW.

The goal is simple: fewer avoidable revision rounds, fewer missed deliverables, and more confidence before submitting sponsored content.

For creators managing multiple brand deals and agencies reviewing content at scale, catching these mistakes early can save time and reduce unnecessary back-and-forth.

Code

GitHub Repository: https://github.com/Masham-0/payCheck

The project combines a deterministic verification engine with local AI inference, keeping exact-match checks separate from semantic interpretation.

How I Built It

SponsorProof is built with Next.js, React, TypeScript, and Tailwind CSS, with Google Gemma 3 running locally through Ollama.

The core idea was to use the right tool for each type of verification instead of making an LLM responsible for everything.

1. Deterministic verification

Some campaign requirements aren't open to interpretation.

If the brand requires STYLE15, then STYLE10 is wrong. If a campaign requires three hashtags, including only one isn't enough.

I implemented rule-based checks for exact promotional codes, individual hashtags, sponsor URLs, and recognized disclosure phrases. Each required hashtag is verified independently, using word-boundary-aware matching to avoid accidental matches.

2. Local semantic analysis with Gemma 3

Other requirements need contextual understanding.

A brief might require a creator to explain a product's privacy benefits or mention a specific feature naturally. Simple keyword matching can't reliably determine whether the draft actually communicates the intended message.

That's where Gemma 3 comes in. The model evaluates semantic talking points, claims, and tone through local Ollama inference.

The default model configuration is gemma3:1b.

3. Evidence verification

AI-generated findings are only useful when they can be checked.

SponsorProof extracts supporting quotations from the original brief and the creator's draft, along with character offsets where available. The evidence verification layer checks whether quoted text actually exists in the source material and prevents unsupported AI judgments from being treated as confirmed compliance.

4. Scoring and reporting

Findings are classified by severity: CRITICAL, IMPORTANT, or RECOMMENDED.

A weighted scoring system calculates the compliance score and determines the overall status:

• READY_TO_POST
• CHANGES_REQUIRED
• HIGH_RISK_VIOLATIONS

The results include explanations, supporting evidence, and suggested fixes, which can then be exported for a client or team review.

I also added sample campaigns, including VPN, fintech, and mobile gaming integrations, with flawed and compliant scripts to make the audit process easier to demonstrate and test.

Finally, SponsorProof reports Ollama's connection status and model availability honestly. If the model isn't available, the application doesn't pretend that an AI audit was completed.

Why Does Open Innovation Matter?

For a tool that evaluates sponsored content, privacy, transparency, and control matter just as much as accuracy.

Brand briefs and unpublished scripts can contain campaign details that creators and agencies aren't ready to share publicly. Using an open-weight model through local inference offers a way to run semantic analysis without depending on a third-party hosted LLM API for every audit.

Open innovation also made it possible to experiment with a hybrid approach: use deterministic code for requirements that must match exactly, and use a locally run language model for requirements that need contextual interpretation.

Neither approach is sufficient on its own.

A rule-based engine can't reliably understand whether a product benefit has been explained correctly. An LLM, on the other hand, shouldn't be trusted to validate an exact coupon code or invent evidence for a compliance decision.

Combining both creates a more transparent workflow in which the model provides contextual assistance while deterministic checks and source verification keep the results grounded.

There's also a practical benefit: local inference gives developers more control over model selection, deployment, and experimentation without making every semantic check depend on a paid API.

Of course, local inference is not a complete privacy guarantee by itself. The surrounding application's data handling still matters, and AI-generated findings remain reviewable recommendations rather than legal certification.

That's the kind of open innovation I wanted to explore with SponsorProof: not just adding AI to an application, but designing the workflow around its strengths and limitations.