글로벌 린다세일즈 Bounce 분석 + 최적 정책 설계

1. 캠페인 표면 수치

2. 발송워커 처리 흐름

sequence-email-worker/processor.ts 의 step 0~5 + Step 2의 6-gate pipeline + mvFailOpenGate 안 verifyEmail() 의 캐시 흐름.

3. 근본 원인

4. MV 실측 데이터 (각 50 random sample)

Score 분포 — bounced 50 vs delivered 50

핵심 관찰: Score 20 (Option B fallback) 은 bounce/delivered 양쪽에 고르게 분포 — MV API timeout 자체는 bounce 신뢰 시그널이 아님. Score 30 unknown 은 bounce 가능성 6배. Score 95 deliverable 중 1건은 MV false-positive (catch-all 도메인의 dead mailbox).

4-A. 추가 Bounce 통계

Bounce type 분포 (24h, outbound)

시간대별 분포 (KST, 2026-06-02)

13시 peak에 196건 발송 중 80건 bounce. 5% SES 임계값 초과 후에도 발송 지속 → SES reputation 손상 진행 중. 자동 pause hook 절실.

다른 ws 비교 (7일)

5. Confusion Matrix — 임계값별 trade-off

6. Domain-level prior bounce rate (강력한 추가 시그널)

같은 도메인의 24시간 발송 결과를 보면 도메인 자체가 bounce 결정적임. 같은 도메인 ≥3건 발송 중:

패턴 — 캠페인이 도메인마다 info@/sales@/export@ 3 prefix 로 발송. 도메인의 첫 hard bounce 가 발생하면 같은 도메인의 다른 prefix 도 99% 확률로 bounce. 즉 도메인 1번 bounce 시 그 도메인의 나머지 enrollment 즉시 차단 만으로도 effective recall ~70% 달성 가능.

7. 2026 최적 정책 설계 — 3-Layer Adaptive

rolling 24h bounce_rate < 5%   → ≤20 유지 (현재)
5% ≤ rate < 10%               → ≤30 강화 (precision 0.74, recall 0.68)
rate ≥ 10%                    → ≤30 + 활성 시퀀스 자동 pause (SES protect)

같은 도메인 24h hard bounce ≥ 2건 → 그 도메인 발송 즉시 차단

8. 구현 코드 (2026 권장 패턴)

Patch 1. mv-fail-open.gate.ts — 임계값 동적화 (Layer 2)

// 기존 (hard-coded ≤20):
if (verdict?.result === "risky" && verdict.score <= 20) {
  return skipStep("skipped", `Tier2 risky low-score: ${toEmail}`)
}

// 변경:
const threshold = await getEffectiveScoreThreshold(ctx.job.data.workspaceId)
if (verdict?.result === "risky" && verdict.score <= threshold) {
  return skipStep("skipped", `Tier2 risky score≤${threshold}: ${toEmail}`)
}

Patch 2. bounce-rate.service.ts (신규) — rolling 24h 계산 + Redis 캐시

import { RedisCache } from "./redis-cache.service"
import { db } from "../db"
import { emails } from "../db/schema/emails"
import { and, eq, gte, sql } from "drizzle-orm"

const cache = RedisCache.fromConfig({
  enabled: true,
  keyPrefix: "bounce_rate:ws:",
  ttlMs: 5 * 60 * 1000, // 5min — adaptive 변경 빈도 vs DB 부하 trade-off
  timeoutMs: 200,
})

export async function getRollingBounceRate(workspaceId: string): Promise<number> {
  const cached = await cache.get<number>(workspaceId)
  if (cached !== null) return cached

  const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000)
  const [row] = await db
    .select({
      sent: sql<number>`COUNT(*) FILTER (WHERE status IN ('delivered','opened','clicked','bounced','sent','spam'))::int`,
      bounced: sql<number>`COUNT(*) FILTER (WHERE status = 'bounced')::int`,
    })
    .from(emails)
    .where(and(eq(emails.workspaceId, workspaceId), eq(emails.direction, "outbound"), gte(emails.createdAt, cutoff)))

  const rate = row && row.sent > 0 ? row.bounced / row.sent : 0
  await cache.set(workspaceId, rate)
  return rate
}

export async function getEffectiveScoreThreshold(workspaceId: string): Promise<number> {
  const rate = await getRollingBounceRate(workspaceId)
  if (rate >= 0.10) {
    // Layer 4 trigger — 자동 pause (idempotent)
    await autoPauseActiveSequences(workspaceId).catch(() => {})
    return 30
  }
  if (rate >= 0.05) return 30
  return 20
}

Patch 3. domain-3-strike.gate.ts (신규) — Layer 3

import { RedisCache } from "../../../../../services/redis-cache.service"
import type { Gate } from "../types"
import { pass, skipStep } from "../types"

const domainCache = RedisCache.fromConfig({
  enabled: true,
  keyPrefix: "domain:bl:",
  ttlMs: 90 * 24 * 60 * 60 * 1000, // hard 90d
  timeoutMs: 100,
})

export const domain3StrikeGate: Gate = {
  name: "domain3Strike",
  async run({ ctx, toEmail }) {
    const domain = toEmail.split("@")[1]?.toLowerCase()
    if (!domain) return pass()

    const entry = await domainCache.get<{ count: number; firstAt: string }>(domain)
    if (entry && entry.count >= 2) {
      return skipStep("skipped", `Domain ${domain} has ${entry.count}+ hard bounces`)
    }
    return pass()
  },
}

// pipeline.ts 에 추가 (mvFailOpen 보다 먼저)
export const DEFAULT_PIPELINE: Gate[] = [
  formatGate, roleGate, dummyGate, disposableGate, dedupGate,
  domain3StrikeGate, // ← 신규
  mvFailOpenGate,
]

Patch 4. bounce-check.service.ts — onBounceDetected 확장 (domain counter)

export async function onBounceDetected(toEmail: string, bounceType: "hard" | "soft" | "complaint" = "hard"): Promise<void> {
  // 기존: blacklist + cache invalidate + lead_enrichment_state propagation
  await Promise.all([addToBounceBlacklist(toEmail, blacklistType), invalidateVerificationCache(toEmail)])

  // 신규: domain-level counter (Layer 3)
  if (bounceType === "hard") {
    const domain = toEmail.split("@")[1]?.toLowerCase()
    if (domain) await incrementDomainBounceCounter(domain)
  }
  // ... (기존 lead_enrichment_state 로직 유지)
}

async function incrementDomainBounceCounter(domain: string): Promise<void> {
  const existing = await domainCache.get<{ count: number; firstAt: string }>(domain)
  const next = existing
    ? { count: existing.count + 1, firstAt: existing.firstAt }
    : { count: 1, firstAt: new Date().toISOString() }
  await domainCache.set(domain, next, 90 * 24 * 60 * 60)
}

Patch 5. sequence-auto-pause.service.ts (신규) — Layer 4

const PAUSED_FLAG_KEY = "ws_auto_pause:"
const pauseCache = RedisCache.fromConfig({ enabled: true, keyPrefix: PAUSED_FLAG_KEY, ttlMs: 60_000 })

export async function autoPauseActiveSequences(workspaceId: string): Promise<void> {
  // idempotent — 1분 dedup
  if (await pauseCache.get<boolean>(workspaceId)) return
  await pauseCache.set(workspaceId, true)

  await db.update(sequences).set({ isActive: false, pausedReason: "auto_pause_high_bounce_rate" })
    .where(and(eq(sequences.workspaceId, workspaceId), eq(sequences.isActive, true)))

  // Slack 알림
  await slackNotify({ channel: "#alerts-ses", text: `🚨 ws ${workspaceId} bounce rate > 10% — sequences auto-paused` })
}

Patch 6. gtm_beauty_upload backfill (BullMQ job, 장기)

// workers/bullmq/lead-backfill-verify.worker.ts (신규)
export const leadBackfillVerifyWorker = createWorker("lead-backfill-verify", async (job) => {
  const { leadId, email } = job.data
  const cascade = await verifyEmailCascade(email, { caller: "backfill" })
  if (cascade.deliverable === false) {
    await db.update(leadEnrichmentState).set({ status: "unreachable" }).where(eq(leadEnrichmentState.leadId, leadId))
  } else if (cascade.deliverable === true) {
    await db.update(leadEmails).set({ verified: 1, verifiedAt: new Date() })
      .where(and(eq(leadEmails.leadId, leadId), eq(leadEmails.emailLower, email.toLowerCase())))
  }
}, { concurrency: 5, limiter: { max: 50, duration: 1000 } }) // MV 144 req/s 의 35% 사용

// 발송 전 1회 호출: source='gtm_beauty_upload' AND verified=0 일괄 enqueue

9. 2026 모범 사례 적용

10. 실행 우선순위

9. 데이터 출처

• beta DB emails 테이블 — 2026-06-02 outbound bounce 195건, delivered/opened/clicked 759건
• MV API 실측 — random 100 sample (bounced 50 + delivered 50), credit ~100 사용 (잔량 876,191)
• 코드: elysia-server/src/workers/bullmq/sequence-email-worker/ + services/million-verifier.service.ts
• git history — Phase 1 (commit 06e3c47ce, 2026-03-09, #1978 Cheolhee Lee), Phase 2 (#6594 Ahmed Mansy), Phase 3 (#7787 이예인 cleanup)