Cold Outreach Pack

The Deliverability Trap: Why Your Outreach Tech Stack is Breaking Standards

We built this pack because we watched too many engineering teams treat email like it's just another HTTP POST request. You write a script, loop through a CSV, and hit an API endpoint. On the surface, it works. The API returns a 200 OK. But three days later, your domain is flagged, your inboxes are empty, and your CTO is asking why the sales pipeline is dry.

The problem isn't your code logic. It's that you're ignoring the underlying protocols that govern how mail actually moves across the internet. RFC 5321 defines the Simple Mail Transfer Protocol, the standard for how mail is exchanged between servers ^[1]. When you bypass the envelope checks, mishandle MIME boundaries, or ignore the strict requirements of modern authentication, you aren't just "sending an email"; you're violating the transport layer.

We've seen teams use SendGrid and hit a wall when the provider silently breaks RFCs by MIME-encoding ASCII characters in ways that trigger spam filters on stricter receiving servers ^[7]. Your outreach script might be generating valid JSON, but if the resulting MIME structure violates the transport standards, your emails land in the junk folder. This isn't a marketing problem; it's a protocol compliance problem. Most teams don't have a schema for their campaign data, they don't validate their SMTP headers, and they certainly don't handle the state machine for bounces and unsubscribes.

If you're building outreach infrastructure, you need to treat it like a distributed system. That means you need CRM Setup & Optimization Pack to ensure your data hygiene is solid before you even touch the mail server, and you need to understand that deliverability is a technical constraint, not a creative one.

The Cost of Ignoring Protocol Compliance and State Machines

When you ignore the engineering requirements of email, the cost compounds fast. We're not talking about a few lost clicks. We're talking about domain reputation death.

Effective May 5, 2025, Microsoft began requiring strict authentication from senders delivering more than 5,000 emails per day to their consumer domains ^[5]. If your SPF, DKIM, or DMARC records are misconfigured, or if you're sending from a shared IP without proper warming, your emails are being rejected at the SMTP level. This is a hard block. No amount of copywriting can fix a protocol rejection.

Beyond the inbox, the downstream impact on your sales operations is severe. If you don't implement a proper state machine to track engagement, you risk sending follow-ups to people who have already unsubscribed or bounced. This isn't just bad UX; it's a compliance risk and a trust killer. When your outreach tool fails to sync state back to your CRM, your sales reps are calling leads that have gone cold or actively opted out.

You need a system that handles the bidirectional flow of data. If your outreach tool doesn't push unsubscribe events back to your Sales Pipeline Pack, your pipeline data becomes garbage. You're forecasting based on stale leads. You're wasting SDR time. And when you finally get a reply, if your CRM isn't optimized to capture that signal, you lose the deal. We've audited workflows where the lack of a validation layer meant that 15% of campaigns contained malformed headers, causing immediate blacklisting. The cost of fixing that reputation damage is months of IP warming and domain rotation. That's hundreds of hours of engineering time lost to a problem that could have been caught by a JSON schema validator.

A Fintech Team's Three-Week Deliverability Black Hole

Imagine a fintech startup preparing for a seed round. They have a list of 5,000 potential investors and angels. They need to reach out, track replies, and update their CRM. The engineering team decides to build a custom outreach bot to save on SaaS costs. They write a Python script, hook it up to a transactional email API, and point it at a CSV.

Week one looks good. The API returns success for every request. The team celebrates. But by week two, reply rates are near zero. By week three, their primary domain is bouncing emails to Gmail and Outlook. The CTO digs into the logs and finds the issue: the script was sending internationalized email headers without proper encoding, violating RFC 6530 requirements for UTF-8 support in email transport ^[2]. Worse, the script didn't handle the SMTP envelope sender correctly, causing a mismatch with the From header. Receiving servers flagged this as spoofing.

The team had no validation step. They had no state machine to handle the 4xx and 5xx SMTP responses. They just kept hammering the API. They had to rotate their sending domain, spend two weeks warming a new IP, and manually clean up their CRM to remove the leads that got spammed. They lost three weeks of outreach time and damaged their brand reputation with a segment of investors who rely on strict email security.

This is a hypothetical illustration of a common failure mode. The team had the data, they had the intent, but they lacked the engineering rigor. They didn't have a schema to validate their campaign structure. They didn't have a routing configuration to handle inbound replies. They didn't have a reference guide on deliverability engineering. If they had a structured workflow, they could have caught the encoding errors before sending a single email. They could have synced their state to the CRM in real-time. And they could have avoided the Proposal & RFP Writing Pack stage entirely because they never got past the inbox. Outreach is the gatekeeper; if you fail there, nothing else matters.

What Changes Once You Install the Pack

When you install the Cold Outreach Pack, you shift from "sending emails" to engineering a compliant, state-aware delivery system. You get a complete workflow that enforces standards at every step.

First, you get strict validation. Our campaign-schema.json ensures that your SendGrid and Mailgun configurations are structurally sound before you run a single campaign. You can't ship a malformed YAML. The validate_campaign.sh script uses jq and Python to check your headers, your tracking flags, and your routing rules. If you try to send a campaign with invalid expressions or missing SPF indicators, the script exits non-zero. This prevents the "it worked on my machine" problem.

Second, you get protocol compliance out of the box. Our templates are grounded in real API docs and RFC standards. You don't have to guess how to handle MIME boundaries or internationalized characters. The references/deliverability-engineering.md file gives you the canonical knowledge on SPF, DKIM, DMARC, and IP warming. It embeds the 2026 tactics that matter, like the new Microsoft authentication requirements. You get a clear path to domain rotation and bounce handling that keeps your reputation intact.

Third, you get full state management. The skill.md orchestrator defines how to run your sequences, handle replies, and sync with your CRM. You get patterns for bidirectional data flow between your outreach tools and your CRM webhooks. You can integrate with n8n or Make.com loops to automate your follow-ups based on real engagement signals. This isn't a static template; it's a dynamic system that adapts to your pipeline. As deliverability in 2026 becomes less about ESP quirks and more about engineering, marketing, and compliance alignment, this pack gives you the technical foundation to win ^[6]. You can focus on your message, knowing the transport layer is handled by a system that respects the standards.

What's in the Cold Outreach Pack

This is a multi-file deliverable. Every file is designed to be used together to build a production-grade outreach system. Here's exactly what you get:

• skill.md — Orchestrator skill that defines the cold outreach engineering workflow, explains how to use templates, run validators, and integrate with CRMs. References all other files and provides step-by-step execution instructions.
• templates/sendgrid-automation.yaml — Production-grade SendGrid automation configuration. Defines sequence steps, click tracking settings, and API endpoints for stats export. Grounded in SendGrid v3 API docs.
• templates/mailgun-routing.yaml — Production-grade Mailgun route configuration for handling inbound replies, bounces, and unsubscribes. Uses real Mailgun expression/action syntax and priority routing.
• scripts/scaffold_campaign.py — Executable Python script that reads a lead CSV, generates personalized email drafts, and outputs a structured campaign YAML. Uses SendGrid API patterns for tracking and step generation.
• scripts/validate_campaign.sh — Executable Bash script that validates campaign YAMLs against the JSON schema, checks for deliverability misconfigurations, and exits non-zero on failure. Uses jq and python for strict validation.
• validators/campaign-schema.json — JSON Schema defining the strict structure for sendgrid-automation.yaml and mailgun-routing.yaml. Ensures required fields, valid expressions, and correct tracking flags.
• references/deliverability-engineering.md — Canonical knowledge on SPF, DKIM, DMARC, IP warming, domain rotation, bounce handling, and tracking setup. Embeds authoritative 2026 deliverability tactics.
• references/crm-integration-patterns.md — Canonical knowledge on CRM webhooks, pipeline state sync, n8n/Make.com automation loops, and API rate limiting. Covers bidirectional data flow between outreach tools and CRMs.
• examples/tech-startup-seed.yaml — Worked example of a complete outreach pack for a tech startup seed round campaign. Demonstrates real-world usage of templates, state machine, and routing.

We built this so you don't have to reverse-engineer the SMTP layer or debug MIME encoding issues at 2 AM. You get the schema, the scripts, the templates, and the reference docs. You install it, validate your campaign, and ship.

Stop Guessing. Start Shipping.

Your outreach system is only as good as its weakest protocol violation. If you're building sequences, you need a pack that enforces standards, manages state, and integrates with your pipeline. Upgrade to Pro to install the Cold Outreach Pack and stop wasting time on deliverability fires. Get the engineering guide that actually works.