Email Frequency & Fatigue Governor

The problem this kills

In a lot of companies, more than one team emails the same list. The product team sends a launch. Lifecycle sends a nurture. The events team sends a webinar invite. Sales drops in a "checking in." Nobody can see the whole picture, so the same poor subscriber gets five emails in a week, gets annoyed, and hits unsubscribe - or worse, marks you as spam, which quietly wrecks your deliverability for everyone.

You probably already have a rule in your head: "nobody should get more than 3 emails in 7 days." But there's no easy way to enforce it. Before each send you'd have to cross-reference the planned recipient list against everything else that went out recently - by hand, across exports, in a spreadsheet, under time pressure. So it doesn't happen, and the list slowly burns out.

This tool makes the cap real. It keeps a running tally of who got what and when, checks every planned send against your cap before it goes out, and surfaces exactly the contacts who would get over-mailed - so a human can decide what to do before the damage is done.

What you'll build

A small, private web app - only your team can log in - that does five things:

1. Imports your send history (contact, campaign, send date) from a CSV, with a duplicate guard so the same send never gets counted twice.
2. Stores your frequency caps - configurable per segment and window (for example, max 3 emails per 7 days for the main list, but max 1 per 14 days for a VIP segment).
3. Checks a planned send - you upload the recipient list for an upcoming campaign, and the tool tells you exactly which contacts would breach the cap.
4. Routes the over-cap list to a manager who reviews it and either suppresses those contacts from this send or records an explicit override (with a reason) - nothing is committed until they approve.
5. Exports a cap-compliant recipient CSV in the exact columns your email platform expects, ready to upload.

What's inside the Implementation Plan

The plan is a complete, paste-and-go runbook for an AI coding agent (Claude Code). You don't write code - you paste the plan, answer some questions, and approve as it builds.

It opens by interviewing you about your business. Before a single line of code is written, the agent asks how you email today, which teams send independently, what your list and segments look like, how your send-history and recipient files are actually shaped and named, your real volumes, and your exact cap rules and exceptions. Then it reads back a short tailored spec and waits for your thumbs-up. That's the difference between a tool that fits your list and a generic template that doesn't.

After that, the plan walks step by step through the data model, the importer with its duplicate guard, the cap-checker, the manager approval gate, the audit trail, and the CSV export - each step ending in a ready-to-copy prompt you paste into the agent.

The governance it includes (this is the point)

This isn't a throwaway script. Governance is built in from the start, because over-mailing is exactly the kind of mistake that's expensive and irreversible:

• Login so only your team can use the tool.
• Row-level security so each organization only ever sees its own contacts and sends.
• A complete audit trail - who imported what, who approved which suppression or override, and when.
• A hard human-in-the-loop approval gate - the tool flags the over-cap contacts, but a person reviews and approves the suppression (or override) before any final recipient list is produced.
• Duplicate guards - a send is keyed on contact + campaign + date so re-importing a file can't double-count, and the same planned send can't be processed twice.

Who it's for

Email and lifecycle ops at companies where multiple teams email the same list independently - anyone who has watched the unsubscribe rate climb after a heavy week and wished there were a referee. If you can manage a CSV and you know your cap rule, you can build and run this.

You've got this - paste the first prompt and let the agent interview you.