Email deliverability protection for B2B outbound teams.
Active middleware that sits between your enrichment data and sending platforms.
Monitors, gates, and auto-heals your email infrastructure in real time.
Website | Blog | Medium | Getting Started | Architecture
Every cold email guide focuses on copy and subject lines. Nobody talks about what happens when your infrastructure breaks at scale.
A single bad lead list with 8% invalid emails spikes your bounce rate overnight. One domain gets blacklisted and the others sharing that IP range suffer too. A mailbox sending fine yesterday gets flagged because Gmail changed their filtering rules.
At scale, outbound isn't a marketing problem. It's an infrastructure problem.
The cost: A burned domain = ~$20,000 in lost pipeline revenue (10 missed meetings x $10K deal size x 20% close rate). Most teams burn 2-3 domains per quarter without realizing it.
Superkabe is a Deliverability Protection Layer (DPL) — active middleware that physically gates SMTP and API traffic between your data sources and sending platforms.
| Capability | What it does |
|---|---|
| Email Validation | Validates emails before they reach your sender — syntax, MX, disposable, catch-all detection, MillionVerifier API fallback |
| Real-Time Monitoring | Ingests webhooks from Smartlead/Instantly/EmailBison, tracks bounce rates per mailbox every 60 seconds |
| Automated Kill Switch | Auto-pauses mailboxes, domains, or campaigns when bounce thresholds are breached |
| Correlation Engine | Detects if failures are mailbox-level, domain-level, or campaign-level — pauses the right thing |
| 5-Phase Healing Pipeline | PAUSED → QUARANTINE → RESTRICTED_SEND → WARM_RECOVERY → HEALTHY — graduated recovery with warmup re-enablement |
| Risk-Aware Routing | GREEN/YELLOW/RED lead classification with per-mailbox risk caps (max 2 risky leads per 60 emails) |
| Load Balancing | Distributes sends based on mailbox health, not round-robin |
| Multi-Platform Support | Smartlead, Instantly, EmailBison via adapter pattern — add a new platform by implementing 4 methods |
| Slack Alerts | Real-time notifications for pauses, blacklistings, recovery milestones |
Clay / CSV Upload
→ Email Validation (syntax, MX, disposable, catch-all, API)
→ Health Gate (GREEN / YELLOW / RED classification)
→ Risk-Aware Routing (persona + health score)
→ Smartlead / Instantly / EmailBison (sending)
→ Bounce webhooks back to Superkabe
→ Monitoring → Auto-Pause → Healing Pipeline
The sending platforms are dumb pipes. The data source is an external feed. All the intelligence sits in the control plane.
┌──────────────┐
│ Slack │ (real-time alerts)
└──────┬───────┘
│
┌─────────────┐ ┌────────────┴─────────────┐ ┌──────────────────┐
│ Clay │──▶│ Superkabe (DPL) │──▶│ Smartlead │
│ CSV Upload │ │ │ │ Instantly │
└─────────────┘ │ ▪ Email Validation │ │ EmailBison │
│ ▪ Health Gate │ │ (sending) │
│ ▪ Risk-Aware Routing │ └────────┬─────────┘
│ ▪ Monitoring (60s cycle) │ │
│ ▪ Healing Pipeline │◀───────────┘
│ ▪ Load Balancing │ (bounce webhooks)
└──────────────────────────┘
When a mailbox gets paused, it doesn't sit in limbo. It enters a 5-phase graduated recovery:
PAUSED (cooldown: 24h/72h/7d)
→ QUARANTINE (DNS health check — SPF, DKIM, blacklist)
→ RESTRICTED_SEND (warmup 10/day, 15 clean sends required)
→ WARM_RECOVERY (50/day + ramp, 3+ days, <2% bounce)
→ HEALTHY (re-added to campaigns, maintenance warmup)
Each phase has explicit graduation criteria. Relapse penalties escalate: 1st → quarantine, 2nd → full pause 72h, 3rd+ → 7 day pause + manual review.
interface PlatformAdapter {
pauseCampaign(orgId: string, campaignId: string): Promise<void>;
resumeCampaign(orgId: string, campaignId: string): Promise<void>;
addMailboxToCampaign(orgId: string, campaignId: string, mailboxId: string): Promise<void>;
removeMailboxFromCampaign(orgId: string, campaignId: string, mailboxId: string): Promise<void>;
}Three implementations: SmartleadAdapter, InstantlyAdapter, EmailBisonAdapter. Adding a new sending platform = implement 4 methods.
| Layer | Technology |
|---|---|
| Backend | Node.js + Express, TypeScript |
| Database | PostgreSQL + Prisma ORM |
| Job Processing | BullMQ + Redis |
| Frontend | Next.js 14 (App Router), React Server Components |
| Styling | TailwindCSS + Framer Motion |
| Deployment | Railway |
| Alerts | Slack webhook integration |
src/
├── routes/ # REST API routing
├── controllers/ # Request handling, validation
├── services/ # Core business logic
│ ├── emailValidationService.ts # Email validation pipeline
│ ├── leadHealthService.ts # GREEN/YELLOW/RED classification
│ ├── routingService.ts # Risk-aware lead routing
│ ├── monitoringService.ts # Real-time health monitoring
│ ├── healingService.ts # 5-phase recovery pipeline
│ ├── warmupService.ts # Warmup management during recovery
│ ├── correlationService.ts # Cross-entity failure correlation
│ ├── entityStateService.ts # State machine (single authority)
│ ├── stateTransitionService.ts # Transition validation + cooldowns
│ ├── loadBalancingService.ts # Health-aware send distribution
│ └── smartleadInfrastructureMutator.ts # Platform API mutations
├── adapters/ # Platform adapters (Smartlead, Instantly, EmailBison)
├── workers/ # Background workers (metrics, warmup tracking)
└── types/ # TypeScript types, state machines, enums
- Node.js 20+
- PostgreSQL 15+
- Redis 7+
# Clone the repository
git clone https://github.com/Superkabereal/Superkabe.git
cd Superkabe
# Install dependencies
npm install
# Set up environment variables
cp .env.example .env
# Edit .env with your database URL, Redis URL, and API keys
# Run database migrations
npx prisma migrate deploy
# Start the development server
npm run devDATABASE_URL="postgresql://user:pass@localhost:5432/superkabe"
REDIS_URL="redis://localhost:6379"
SMARTLEAD_API_KEY="your-smartlead-api-key"
INSTANTLY_API_KEY="your-instantly-api-key"
MILLION_VERIFIER_API_KEY="your-millionverifier-api-key" # Optional, for API validation tier
SLACK_WEBHOOK_URL="https://hooks.slack.com/services/..." # OptionalBefore Superkabe:
- Bounce rate: 6-9% (should be under 2%)
- Domains burned per month: 2-3
- Infrastructure firefighting: ~15 hours/week
After Superkabe:
- Bounce rate: 1.2%
- Domains burned in 6 months: 0
- Infrastructure management: ~2 hours/week
- Inbox placement: 91% (up from 52%)
| Platform | Ingestion | Mutation | Status |
|---|---|---|---|
| Smartlead | Webhook | REST API | Production |
| Instantly | Webhook | REST API | Production |
| EmailBison | Webhook | REST API | Production |
| Clay | Webhook | — | Production |
| Slack | — | Webhook | Production |
- RevOps engineers managing 50+ mailboxes across multiple domains
- B2B growth agencies running outbound for multiple clients
- Technical founders who can't afford to burn domains
- GTM teams scaling cold outreach past 10,000 emails/month
We welcome contributions. See CONTRIBUTING.md for guidelines.
- From Domain Purchase to First Reply: Engineering Deliverability-First Outbound — Hashnode
- Why 90% of Cold Outreach Fails (It's Not Your Copy) — Medium
- Building an Outbound Email Engine That Doesn't Burn Your Domains — Dev.to