diff --git a/.env.development.local.example b/.env.development.local.example
index 0fcaa9cb9..a246a5252 100644
--- a/.env.development.local.example
+++ b/.env.development.local.example
@@ -1,7 +1,6 @@
-# Email provider: 'customerio' (default) or 'mailgun'
-# EMAIL_PROVIDER=customerio
 # MAILGUN_API_KEY=key-...
 # MAILGUN_DOMAIN=app.kilocode.ai
+# NEVERBOUNCE_API_KEY=...
 
 # Stripe integration
 STRIPE_WEBHOOK_SECRET="...extract this from: stripe listen --forward-to http://localhost:3000/api/stripe/webhook"
diff --git a/.env.test b/.env.test
index 42cb5bd5e..2d8f83f64 100644
--- a/.env.test
+++ b/.env.test
@@ -3,7 +3,6 @@ NEXTAUTH_URL=http://localhost:3000
 NEXTAUTH_SECRET=test-only-non-secret
 XAI_API_KEY=invalid-mock-grok-key
 MISTRAL_API_KEY=invalid-mock-mistral-key
-CUSTOMERIO_EMAIL_API_KEY=invalid-mock-customerio-key
 STRIPE_SECRET_KEY=invalid-mock-stripe-key
 POSTGRES_URL="postgres://postgres:postgres@localhost:5432/postgres"
 POSTGRES_CONNECT_TIMEOUT=10000
@@ -84,4 +83,3 @@ STRIPE_KILOCLAW_STANDARD_FIRST_MONTH_COUPON_ID=coupon_test_kiloclaw_standard_fir
 NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=pk_test_invalid_mock_key
 
 CREDIT_CATEGORIES_ENCRYPTION_KEY=
-EMAIL_PROVIDER=customerio
diff --git a/package.json b/package.json
index 5cc39f8bf..9d468ede6 100644
--- a/package.json
+++ b/package.json
@@ -106,7 +106,6 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
-    "customerio-node": "^4.3.0",
     "date-fns": "^4.1.0",
     "dayjs": "^1.11.20",
     "discord-api-types": "^0.38.42",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 93f2d6a0a..2cefc2afb 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -308,9 +308,6 @@ importers:
       cmdk:
         specifier: ^1.1.1
         version: 1.1.1(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
-      customerio-node:
-        specifier: ^4.3.0
-        version: 4.3.0
       date-fns:
         specifier: ^4.1.0
         version: 4.1.0
@@ -8574,9 +8571,6 @@ packages:
   csstype@3.2.3:
     resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
 
-  customerio-node@4.3.0:
-    resolution: {integrity: sha512-umNxZzBNmyT+OQRQE1M7IgARgrgvnoY8bw+XGAuazB9QMfPTktkPnXImmyR8WAQHhnyfnsi8pqc1PzzToZmB5g==}
-
   cwd@0.10.0:
     resolution: {integrity: sha512-YGZxdTTL9lmLkCUTpg4j0zQ7IhRB5ZmqNBbGCl3Tg6MP/d5/6sY7L5mmTjzbc6JKgVZYiqTQTNhPFsbXNGlRaA==}
     engines: {node: '>=0.8'}
@@ -22848,8 +22842,6 @@ snapshots:
 
   csstype@3.2.3: {}
 
-  customerio-node@4.3.0: {}
-
   cwd@0.10.0:
     dependencies:
       find-pkg: 0.1.2
diff --git a/src/app/admin/email-testing/page.tsx b/src/app/admin/email-testing/page.tsx
index 616edc03b..76b19f111 100644
--- a/src/app/admin/email-testing/page.tsx
+++ b/src/app/admin/email-testing/page.tsx
@@ -34,11 +34,9 @@ export default function EmailTestingPage() {
   const { data: session } = useSession();
 
   const [selectedTemplate, setSelectedTemplate] = useState<string | null>(null);
-  const [selectedProvider, setSelectedProvider] = useState<string | null>(null);
   const [recipient, setRecipient] = useState<string>('');
 
   const { data: templates } = useQuery(trpc.admin.emailTesting.getTemplates.queryOptions());
-  const { data: providers } = useQuery(trpc.admin.emailTesting.getProviders.queryOptions());
 
   // Pre-fill recipient with logged-in admin's email
   useEffect(() => {
@@ -47,44 +45,34 @@ export default function EmailTestingPage() {
     }
   }, [session?.user?.email, recipient]);
 
-  // Auto-select first template and provider on load
+  // Auto-select first template on load
   useEffect(() => {
     if (templates && templates.length > 0 && !selectedTemplate) {
       setSelectedTemplate(templates[0].name);
     }
   }, [templates, selectedTemplate]);
 
-  useEffect(() => {
-    if (providers && providers.length > 0 && !selectedProvider) {
-      setSelectedProvider(providers[0]);
-    }
-  }, [providers, selectedProvider]);
-
   const previewQuery = useQuery(
     trpc.admin.emailTesting.getPreview.queryOptions(
       {
-        // Values come directly from the server's getTemplates/getProviders responses,
-        // so the cast is safe — tRPC zod will reject anything invalid at runtime anyway.
         template: (selectedTemplate ?? 'orgSubscription') as TemplateName,
-        provider: (selectedProvider ?? 'customerio') as 'customerio' | 'mailgun',
       },
-      { enabled: selectedTemplate !== null && selectedProvider !== null }
+      { enabled: selectedTemplate !== null }
     )
   );
 
   const sendTestMutation = useMutation(trpc.admin.emailTesting.sendTest.mutationOptions());
 
   const handleSend = () => {
-    if (!selectedTemplate || !selectedProvider || !recipient) return;
+    if (!selectedTemplate || !recipient) return;
     sendTestMutation.mutate(
       {
         template: selectedTemplate as TemplateName,
-        provider: selectedProvider as 'customerio' | 'mailgun',
         recipient,
       },
       {
         onSuccess: result => {
-          toast.success(`Test email sent via ${result?.provider} to ${result?.recipient}`);
+          toast.success(`Test email sent to ${result?.recipient}`);
         },
         onError: error => {
           toast.error(error.message || 'Failed to send test email');
@@ -111,11 +99,11 @@ export default function EmailTestingPage() {
               Test Email Controls
             </CardTitle>
             <CardDescription>
-              Select a template and provider, then send a test email to any address.
+              Select a template, then send a test email to any address.
             </CardDescription>
           </CardHeader>
           <CardContent className="space-y-4">
-            <div className="grid gap-4 sm:grid-cols-3">
+            <div className="grid gap-4 sm:grid-cols-2">
               <div>
                 <Label htmlFor="template">Template</Label>
                 <Select value={selectedTemplate ?? ''} onValueChange={v => setSelectedTemplate(v)}>
@@ -132,22 +120,6 @@ export default function EmailTestingPage() {
                 </Select>
               </div>
 
-              <div>
-                <Label htmlFor="provider">Provider</Label>
-                <Select value={selectedProvider ?? ''} onValueChange={v => setSelectedProvider(v)}>
-                  <SelectTrigger id="provider">
-                    <SelectValue placeholder="Select provider..." />
-                  </SelectTrigger>
-                  <SelectContent>
-                    {providers?.map(p => (
-                      <SelectItem key={p} value={p}>
-                        {p}
-                      </SelectItem>
-                    ))}
-                  </SelectContent>
-                </Select>
-              </div>
-
               <div>
                 <Label htmlFor="recipient">Recipient</Label>
                 <Input
@@ -162,9 +134,7 @@ export default function EmailTestingPage() {
 
             <Button
               onClick={handleSend}
-              disabled={
-                !selectedTemplate || !selectedProvider || !recipient || sendTestMutation.isPending
-              }
+              disabled={!selectedTemplate || !recipient || sendTestMutation.isPending}
             >
               <Send className="mr-2 h-4 w-4" />
               {sendTestMutation.isPending ? 'Sending...' : 'Send Test Email'}
@@ -173,7 +143,7 @@ export default function EmailTestingPage() {
         </Card>
 
         {/* Preview Pane */}
-        {selectedTemplate && selectedProvider && (
+        {selectedTemplate && (
           <Card>
             <CardHeader>
               <CardTitle className="flex items-center gap-2">
@@ -185,49 +155,13 @@ export default function EmailTestingPage() {
                   </span>
                 )}
               </CardTitle>
-              <CardDescription>
-                {selectedProvider === 'customerio'
-                  ? 'Variables that will be sent to the Customer.io API'
-                  : 'Rendered HTML email'}
-              </CardDescription>
+              <CardDescription>Rendered HTML email</CardDescription>
             </CardHeader>
             <CardContent>
               {previewQuery.isPending && (
                 <p className="text-muted-foreground text-sm">Loading preview...</p>
               )}
-              {previewQuery.data?.type === 'customerio' && (
-                <div className="space-y-2">
-                  <p className="text-muted-foreground text-xs">
-                    Template ID:{' '}
-                    <span className="font-mono">{previewQuery.data.transactional_message_id}</span>
-                  </p>
-                  <div className="rounded-lg border">
-                    <table className="w-full text-sm">
-                      <thead>
-                        <tr className="border-b">
-                          <th className="text-muted-foreground px-4 py-2 text-left font-medium">
-                            Variable
-                          </th>
-                          <th className="text-muted-foreground px-4 py-2 text-left font-medium">
-                            Value
-                          </th>
-                        </tr>
-                      </thead>
-                      <tbody>
-                        {Object.entries(previewQuery.data.message_data).map(([key, value]) => (
-                          <tr key={key} className="border-b last:border-0">
-                            <td className="px-4 py-2 font-mono text-xs">{key}</td>
-                            <td className="px-4 py-2 font-mono text-xs break-all">
-                              {String(value)}
-                            </td>
-                          </tr>
-                        ))}
-                      </tbody>
-                    </table>
-                  </div>
-                </div>
-              )}
-              {previewQuery.data?.type === 'mailgun' && (
+              {previewQuery.data && (
                 <iframe
                   srcDoc={previewQuery.data.html}
                   className="h-[600px] w-full rounded-lg border"
diff --git a/src/app/api/auth/magic-link/route.test.ts b/src/app/api/auth/magic-link/route.test.ts
index f2a0b1802..14a2a9096 100644
--- a/src/app/api/auth/magic-link/route.test.ts
+++ b/src/app/api/auth/magic-link/route.test.ts
@@ -54,7 +54,7 @@ describe('POST /api/auth/magic-link', () => {
 
     // Default: Magic link creation succeeds
     mockCreateMagicLinkToken.mockResolvedValue(mockMagicLinkToken);
-    mockSendMagicLinkEmail.mockResolvedValue(undefined);
+    mockSendMagicLinkEmail.mockResolvedValue({ sent: true });
 
     // Default: User does not exist (new user signup)
     mockFindUserByEmail.mockResolvedValue(undefined);
diff --git a/src/app/api/auth/magic-link/route.ts b/src/app/api/auth/magic-link/route.ts
index 33366bd45..35648e629 100644
--- a/src/app/api/auth/magic-link/route.ts
+++ b/src/app/api/auth/magic-link/route.ts
@@ -56,7 +56,17 @@ export async function POST(request: NextRequest) {
   }
 
   const magicLink = await createMagicLinkToken(email);
-  await sendMagicLinkEmail(magicLink, callbackUrl);
+  const result = await sendMagicLinkEmail(magicLink, callbackUrl);
+
+  if (!result.sent) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: 'Unable to deliver email to this address. Please use a different email.',
+      },
+      { status: 400 }
+    );
+  }
 
   return NextResponse.json({
     success: true,
diff --git a/src/lib/autoTopUp.test.ts b/src/lib/autoTopUp.test.ts
index 6da584350..652645288 100644
--- a/src/lib/autoTopUp.test.ts
+++ b/src/lib/autoTopUp.test.ts
@@ -29,7 +29,7 @@ const toMicrodollars = (dollars: number) => dollars * 1_000_000;
 
 // Mock email sending to avoid CustomerIO errors in tests
 jest.mock('@/lib/email', () => ({
-  sendAutoTopUpFailedEmail: jest.fn().mockResolvedValue(undefined),
+  sendAutoTopUpFailedEmail: jest.fn().mockResolvedValue({ sent: true }),
 }));
 
 jest.mock('@/lib/stripe-client', () => {
diff --git a/src/lib/config.server.ts b/src/lib/config.server.ts
index b762cb003..da908d4fe 100644
--- a/src/lib/config.server.ts
+++ b/src/lib/config.server.ts
@@ -8,17 +8,9 @@ import 'server-only';
 
 export const IS_IN_AUTOMATED_TEST = !!getEnvVariable('IS_IN_AUTOMATED_TEST');
 export const NEXTAUTH_URL = APP_URL;
-export const CUSTOMERIO_EMAIL_API_KEY = getEnvVariable('CUSTOMERIO_EMAIL_API_KEY');
 export const MAILGUN_API_KEY = getEnvVariable('MAILGUN_API_KEY');
 export const MAILGUN_DOMAIN = getEnvVariable('MAILGUN_DOMAIN');
-// Which email backend to use: 'customerio' (default) or 'mailgun'
-const emailProviderRaw = getEnvVariable('EMAIL_PROVIDER') || 'customerio';
-if (emailProviderRaw !== 'customerio' && emailProviderRaw !== 'mailgun') {
-  throw new Error(
-    `Invalid EMAIL_PROVIDER: '${emailProviderRaw}'. Must be 'customerio' or 'mailgun'`
-  );
-}
-export const EMAIL_PROVIDER = emailProviderRaw;
+export const NEVERBOUNCE_API_KEY = getEnvVariable('NEVERBOUNCE_API_KEY');
 export const WORKOS_API_KEY = getEnvVariable('WORKOS_API_KEY');
 export const WORKOS_CLIENT_ID = getEnvVariable('WORKOS_CLIENT_ID');
 export const GOOGLE_CLIENT_ID = getEnvVariable('GOOGLE_CLIENT_ID');
diff --git a/src/lib/email-customerio.ts b/src/lib/email-customerio.ts
deleted file mode 100644
index c6cac6019..000000000
--- a/src/lib/email-customerio.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { CUSTOMERIO_EMAIL_API_KEY } from '@/lib/config.server';
-import { captureMessage } from '@sentry/nextjs';
-import { APIClient, SendEmailRequest } from 'customerio-node';
-import type { SendEmailRequestOptions } from 'customerio-node/dist/lib/api/requests';
-
-export type { SendEmailRequestOptions };
-
-export function sendViaCustomerIo(mailRequest: SendEmailRequestOptions) {
-  if (!CUSTOMERIO_EMAIL_API_KEY) {
-    const message = 'CUSTOMERIO_EMAIL_API_KEY is not set - cannot send email';
-    console.warn(message);
-
-    captureMessage(message, {
-      level: 'warning',
-      tags: { source: 'email_service' },
-    });
-    return;
-  }
-  console.log('sending email with customerio');
-  const client = new APIClient(CUSTOMERIO_EMAIL_API_KEY);
-  const request = new SendEmailRequest(mailRequest);
-  return client.sendEmail(request);
-}
diff --git a/src/lib/email-neverbounce.test.ts b/src/lib/email-neverbounce.test.ts
new file mode 100644
index 000000000..780cd9389
--- /dev/null
+++ b/src/lib/email-neverbounce.test.ts
@@ -0,0 +1,119 @@
+import { captureMessage } from '@sentry/nextjs';
+import { verifyEmail } from '@/lib/email-neverbounce';
+
+jest.mock('@sentry/nextjs', () => ({
+  captureMessage: jest.fn(),
+}));
+
+const mockCaptureMessage = captureMessage as jest.MockedFunction<typeof captureMessage>;
+
+let mockApiKey: string | undefined = 'test-api-key';
+
+jest.mock('@/lib/config.server', () => ({
+  get NEVERBOUNCE_API_KEY() {
+    return mockApiKey;
+  },
+}));
+
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+
+function mockNeverBounceResponse(result: string, status = 'success') {
+  mockFetch.mockResolvedValue({
+    ok: true,
+    json: async () => ({
+      status,
+      result,
+      flags: ['has_dns', 'has_dns_mx'],
+      suggested_correction: '',
+      execution_time: 100,
+    }),
+  });
+}
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  mockApiKey = 'test-api-key';
+});
+
+describe('verifyEmail', () => {
+  it('returns true when API key is not configured', async () => {
+    mockApiKey = undefined;
+    expect(await verifyEmail('test@example.com')).toBe(true);
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('returns true for valid emails', async () => {
+    mockNeverBounceResponse('valid');
+    expect(await verifyEmail('good@example.com')).toBe(true);
+    expect(mockCaptureMessage).not.toHaveBeenCalled();
+  });
+
+  it('returns false for invalid emails and reports to Sentry', async () => {
+    mockNeverBounceResponse('invalid');
+    expect(await verifyEmail('bad@example.com')).toBe(false);
+    expect(mockCaptureMessage).toHaveBeenCalledWith(
+      'Blocked email send to invalid address',
+      expect.objectContaining({
+        level: 'info',
+        tags: { source: 'neverbounce', result: 'invalid' },
+      })
+    );
+  });
+
+  it('returns false for disposable emails', async () => {
+    mockNeverBounceResponse('disposable');
+    expect(await verifyEmail('temp@mailinator.com')).toBe(false);
+  });
+
+  it('returns true for catchall emails', async () => {
+    mockNeverBounceResponse('catchall');
+    expect(await verifyEmail('anyone@catchall.com')).toBe(true);
+  });
+
+  it('returns true for unknown emails', async () => {
+    mockNeverBounceResponse('unknown');
+    expect(await verifyEmail('mystery@example.com')).toBe(true);
+  });
+
+  it('returns true on HTTP error (fail-open)', async () => {
+    mockFetch.mockResolvedValue({ ok: false, status: 500 });
+    expect(await verifyEmail('test@example.com')).toBe(true);
+  });
+
+  it('returns true on network error (fail-open) and reports to Sentry', async () => {
+    mockFetch.mockRejectedValue(new Error('fetch failed'));
+    expect(await verifyEmail('test@example.com')).toBe(true);
+    expect(mockCaptureMessage).toHaveBeenCalledWith(
+      'NeverBounce verification check failed',
+      expect.objectContaining({ level: 'warning' })
+    );
+  });
+
+  it('returns true on non-success API status and reports to Sentry', async () => {
+    mockNeverBounceResponse('valid', 'auth_failure');
+    expect(await verifyEmail('test@example.com')).toBe(true);
+    expect(mockCaptureMessage).toHaveBeenCalledWith(
+      'NeverBounce API returned non-success status: auth_failure',
+      expect.objectContaining({ level: 'warning' })
+    );
+  });
+
+  it('passes email and API key as query parameters', async () => {
+    mockNeverBounceResponse('valid');
+    await verifyEmail('user@test.com');
+    const calledUrl = new URL(mockFetch.mock.calls[0][0]);
+    expect(calledUrl.origin + calledUrl.pathname).toBe(
+      'https://api.neverbounce.com/v4.2/single/check'
+    );
+    expect(calledUrl.searchParams.get('key')).toBe('test-api-key');
+    expect(calledUrl.searchParams.get('email')).toBe('user@test.com');
+  });
+
+  it('sets a 5-second timeout on the fetch call', async () => {
+    mockNeverBounceResponse('valid');
+    await verifyEmail('user@test.com');
+    const fetchOptions = mockFetch.mock.calls[0][1];
+    expect(fetchOptions.signal).toBeDefined();
+  });
+});
diff --git a/src/lib/email-neverbounce.ts b/src/lib/email-neverbounce.ts
new file mode 100644
index 000000000..2e522431f
--- /dev/null
+++ b/src/lib/email-neverbounce.ts
@@ -0,0 +1,69 @@
+import { NEVERBOUNCE_API_KEY } from '@/lib/config.server';
+import { captureMessage } from '@sentry/nextjs';
+
+type NeverBounceResult = 'valid' | 'invalid' | 'disposable' | 'catchall' | 'unknown';
+
+type NeverBounceResponse = {
+  status: string;
+  result: NeverBounceResult;
+  flags: string[];
+  suggested_correction: string;
+  execution_time: number;
+};
+
+const BLOCKED_RESULTS = new Set<NeverBounceResult>(['invalid', 'disposable']);
+
+/**
+ * Returns true if the email is safe to send to, false if it should be skipped.
+ * If NeverBounce is not configured or the check fails, defaults to allowing the send.
+ */
+export async function verifyEmail(email: string): Promise<boolean> {
+  if (!NEVERBOUNCE_API_KEY) {
+    return true;
+  }
+
+  try {
+    const url = new URL('https://api.neverbounce.com/v4.2/single/check');
+    url.searchParams.set('key', NEVERBOUNCE_API_KEY);
+    url.searchParams.set('email', email);
+
+    const response = await fetch(url, { signal: AbortSignal.timeout(5_000) });
+    if (!response.ok) {
+      console.warn(`[neverbounce] API returned ${response.status} for ${email}, allowing send`);
+      return true;
+    }
+
+    const data: NeverBounceResponse = await response.json();
+
+    if (data.status !== 'success') {
+      console.warn(`[neverbounce] API returned status=${data.status} for ${email}, allowing send`);
+      captureMessage(`NeverBounce API returned non-success status: ${data.status}`, {
+        level: 'warning',
+        tags: { source: 'neverbounce' },
+        extra: { email, status: data.status },
+      });
+      return true;
+    }
+
+    if (BLOCKED_RESULTS.has(data.result)) {
+      captureMessage(`Blocked email send to ${data.result} address`, {
+        level: 'info',
+        tags: { source: 'neverbounce', result: data.result },
+        extra: { email, flags: data.flags, suggested_correction: data.suggested_correction },
+      });
+      console.log(`[neverbounce] Blocked send to ${email}: result=${data.result}`);
+      return false;
+    }
+
+    return true;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn(`[neverbounce] Check failed for ${email}: ${errorMessage}, allowing send`);
+    captureMessage('NeverBounce verification check failed', {
+      level: 'warning',
+      tags: { source: 'neverbounce' },
+      extra: { email, error: errorMessage },
+    });
+    return true;
+  }
+}
diff --git a/src/lib/email.ts b/src/lib/email.ts
index 6bec571a0..24f546b7b 100644
--- a/src/lib/email.ts
+++ b/src/lib/email.ts
@@ -2,38 +2,12 @@ import fs from 'fs';
 import path from 'path';
 import type { Organization } from '@kilocode/db/schema';
 import { getMagicLinkUrl, type MagicLinkTokenWithPlaintext } from '@/lib/auth/magic-link-tokens';
-import { EMAIL_PROVIDER, NEXTAUTH_URL } from '@/lib/config.server';
-import { sendViaCustomerIo } from '@/lib/email-customerio';
+import { NEXTAUTH_URL } from '@/lib/config.server';
 import { sendViaMailgun } from '@/lib/email-mailgun';
+import { verifyEmail } from '@/lib/email-neverbounce';
 
-export const templates = {
-  orgSubscription: '10',
-  orgRenewed: '11',
-  orgCancelled: '12',
-  orgSSOUserJoined: '13',
-  orgInvitation: '6',
-  magicLink: '14',
-  balanceAlert: '16',
-  autoTopUpFailed: '17',
-  ossInviteNewUser: '18',
-  ossInviteExistingUser: '19',
-  ossExistingOrgProvisioned: '20',
-  deployFailed: '21',
-  clawTrialEndingSoon: '22',
-  clawTrialExpiresTomorrow: '23',
-  clawSuspendedTrial: '24',
-  clawSuspendedSubscription: '25',
-  clawSuspendedPayment: '26',
-  clawDestructionWarning: '27',
-  clawInstanceDestroyed: '28',
-  clawEarlybirdEndingSoon: '29',
-  clawEarlybirdExpiresTomorrow: '30',
-} as const;
-
-export type TemplateName = keyof typeof templates;
-
-// Subject lines for each template — used by Mailgun (PR 2) and the admin testing page
-export const subjects: Record<TemplateName, string> = {
+// Subject lines for each template — also serves as the canonical list of template names
+export const subjects = {
   orgSubscription: 'Welcome to Kilo for Teams!',
   orgRenewed: 'Kilo: Your Teams Subscription Renewal',
   orgCancelled: 'Kilo: Your Teams Subscription is Cancelled',
@@ -55,7 +29,9 @@ export const subjects: Record<TemplateName, string> = {
   clawInstanceDestroyed: 'Your KiloClaw Instance Has Been Deleted',
   clawEarlybirdEndingSoon: 'Your KiloClaw Earlybird Access Ends Soon',
   clawEarlybirdExpiresTomorrow: 'Your KiloClaw Earlybird Access Expires Tomorrow',
-};
+} as const;
+
+export type TemplateName = keyof typeof subjects;
 
 function escapeHtml(str: string): string {
   return str
@@ -93,15 +69,9 @@ export function buildCreditsSection(monthlyCreditsUsd: number): RawHtml {
   );
 }
 
-// CIO templates still use Liquid {% if has_credits %}{{ monthly_credits_usd }}{% endif %}.
-// Mailgun templates use {{ credits_section }} instead. Pass both so each provider
-// gets the vars it needs; unrecognized keys are harmlessly ignored by both paths.
 export function creditsVars(monthlyCreditsUsd: number): TemplateVars {
   return {
     credits_section: buildCreditsSection(monthlyCreditsUsd),
-    ...(monthlyCreditsUsd > 0
-      ? { has_credits: 'true', monthly_credits_usd: String(monthlyCreditsUsd) }
-      : {}),
   };
 }
 
@@ -112,31 +82,21 @@ type SendParams = {
   subjectOverride?: string;
 };
 
-export async function send(params: SendParams) {
-  if (EMAIL_PROVIDER === 'mailgun') {
-    const subject = params.subjectOverride ?? subjects[params.templateName];
-    const html = renderTemplate(params.templateName, {
-      ...params.templateVars,
-      year: String(new Date().getFullYear()),
-    });
-    return sendViaMailgun({ to: params.to, subject, html });
-  }
-  // Customer.io handles its own rendering; pass raw string values.
-  // If a subjectOverride is provided, include it as `subject` in message_data
-  // so CIO templates can reference it via Liquid ({{ subject }}).
-  const messageData: Record<string, string> = Object.fromEntries(
-    Object.entries(params.templateVars).map(([k, v]) => [k, v instanceof RawHtml ? v.html : v])
-  );
-  if (params.subjectOverride) {
-    messageData.subject = params.subjectOverride;
+type SendResult = { sent: true } | { sent: false; reason: 'neverbounce_rejected' };
+
+export async function send(params: SendParams): Promise<SendResult> {
+  const isSafeToSend = await verifyEmail(params.to);
+  if (!isSafeToSend) {
+    return { sent: false, reason: 'neverbounce_rejected' };
   }
-  return sendViaCustomerIo({
-    transactional_message_id: templates[params.templateName],
-    to: params.to,
-    message_data: messageData,
-    identifiers: { email: params.to },
-    reply_to: 'hi@kilocode.ai',
+
+  const subject = params.subjectOverride ?? subjects[params.templateName];
+  const html = renderTemplate(params.templateName, {
+    ...params.templateVars,
+    year: String(new Date().getFullYear()),
   });
+  await sendViaMailgun({ to: params.to, subject, html });
+  return { sent: true };
 }
 
 type OrganizationInviteEmailData = {
diff --git a/src/lib/kiloclaw/billing-lifecycle-cron.ts b/src/lib/kiloclaw/billing-lifecycle-cron.ts
index a4437952b..cea686ffc 100644
--- a/src/lib/kiloclaw/billing-lifecycle-cron.ts
+++ b/src/lib/kiloclaw/billing-lifecycle-cron.ts
@@ -76,7 +76,22 @@ async function trySendEmail(
     return false;
   }
   try {
-    await sendEmail({ to: userEmail, templateName, templateVars, subjectOverride });
+    const emailResult = await sendEmail({
+      to: userEmail,
+      templateName,
+      templateVars,
+      subjectOverride,
+    });
+    if (!emailResult.sent) {
+      // Remove idempotency guard so the next cron run can retry
+      await database
+        .delete(kiloclaw_email_log)
+        .where(
+          and(eq(kiloclaw_email_log.user_id, userId), eq(kiloclaw_email_log.email_type, emailType))
+        );
+      summary.emails_skipped++;
+      return false;
+    }
   } catch (error) {
     try {
       await database
diff --git a/src/routers/admin/email-testing-router.ts b/src/routers/admin/email-testing-router.ts
index b166893c7..d3c4ef66b 100644
--- a/src/routers/admin/email-testing-router.ts
+++ b/src/routers/admin/email-testing-router.ts
@@ -1,51 +1,21 @@
 import { TRPCError } from '@trpc/server';
 import { adminProcedure, createTRPCRouter } from '@/lib/trpc/init';
 import { NEXTAUTH_URL } from '@/lib/config.server';
-import { sendViaCustomerIo } from '@/lib/email-customerio';
-import { sendViaMailgun } from '@/lib/email-mailgun';
 import {
-  templates,
+  send,
   subjects,
   creditsVars,
   renderTemplate,
-  RawHtml,
+  type RawHtml,
   type TemplateName,
 } from '@/lib/email';
 import * as z from 'zod';
 import { format } from 'date-fns';
 
-const templateNames: [TemplateName, ...TemplateName[]] = [
-  'orgSubscription',
-  'orgRenewed',
-  'orgCancelled',
-  'orgSSOUserJoined',
-  'orgInvitation',
-  'magicLink',
-  'balanceAlert',
-  'autoTopUpFailed',
-  'ossInviteNewUser',
-  'ossInviteExistingUser',
-  'ossExistingOrgProvisioned',
-  'deployFailed',
-  'clawTrialEndingSoon',
-  'clawTrialExpiresTomorrow',
-  'clawSuspendedTrial',
-  'clawSuspendedSubscription',
-  'clawSuspendedPayment',
-  'clawDestructionWarning',
-  'clawInstanceDestroyed',
-  'clawEarlybirdEndingSoon',
-  'clawEarlybirdExpiresTomorrow',
-];
+const templateNames = Object.keys(subjects) as [TemplateName, ...TemplateName[]];
 
 const TemplateNameSchema = z.enum(templateNames);
 
-const providerNames = ['customerio', 'mailgun'] as const;
-
-type ProviderName = (typeof providerNames)[number];
-
-const ProviderNameSchema = z.enum(providerNames);
-
 function fixtureTemplateVars(template: TemplateName): Record<string, string | RawHtml> {
   const formatDate = (d: Date) => format(d, 'MMMM d, yyyy');
   const orgId = 'fixture-org-id';
@@ -96,16 +66,6 @@ function fixtureTemplateVars(template: TemplateName): Record<string, string | Ra
         ...creditsVars(500),
       };
     case 'ossInviteExistingUser':
-      return {
-        organization_name: 'Acme OSS',
-        organization_url,
-        integrations_url,
-        code_reviews_url,
-        tier_name: 'Premier',
-        seats: '25',
-        seat_value: '48,000',
-        ...creditsVars(500),
-      };
     case 'ossExistingOrgProvisioned':
       return {
         organization_name: 'Acme OSS',
@@ -126,17 +86,10 @@ function fixtureTemplateVars(template: TemplateName): Record<string, string | Ra
     case 'clawTrialEndingSoon':
       return { days_remaining: '5', claw_url: `${NEXTAUTH_URL}/claw` };
     case 'clawTrialExpiresTomorrow':
+    case 'clawInstanceDestroyed':
       return { claw_url: `${NEXTAUTH_URL}/claw` };
     case 'clawSuspendedTrial':
-      return {
-        destruction_date: formatDate(new Date(Date.now() + 7 * 86_400_000)),
-        claw_url: `${NEXTAUTH_URL}/claw`,
-      };
     case 'clawSuspendedSubscription':
-      return {
-        destruction_date: formatDate(new Date(Date.now() + 7 * 86_400_000)),
-        claw_url: `${NEXTAUTH_URL}/claw`,
-      };
     case 'clawSuspendedPayment':
       return {
         destruction_date: formatDate(new Date(Date.now() + 7 * 86_400_000)),
@@ -147,8 +100,6 @@ function fixtureTemplateVars(template: TemplateName): Record<string, string | Ra
         destruction_date: formatDate(new Date(Date.now() + 2 * 86_400_000)),
         claw_url: `${NEXTAUTH_URL}/claw`,
       };
-    case 'clawInstanceDestroyed':
-      return { claw_url: `${NEXTAUTH_URL}/claw` };
     case 'clawEarlybirdEndingSoon':
       return { days_remaining: '14', expiry_date: '2026-09-26', claw_url: `${NEXTAUTH_URL}/claw` };
     case 'clawEarlybirdExpiresTomorrow':
@@ -162,29 +113,13 @@ export const emailTestingRouter = createTRPCRouter({
     return templateNames.map(name => ({ name, subject: subjects[name] }));
   }),
 
-  getProviders: adminProcedure.query((): ProviderName[] => {
-    return [...providerNames];
-  }),
-
   getPreview: adminProcedure
-    .input(z.object({ template: TemplateNameSchema, provider: ProviderNameSchema }))
+    .input(z.object({ template: TemplateNameSchema }))
     .query(({ input }) => {
       const vars = fixtureTemplateVars(input.template);
-      if (input.provider === 'mailgun') {
-        return {
-          type: 'mailgun' as const,
-          subject: subjects[input.template],
-          html: renderTemplate(input.template, { ...vars, year: String(new Date().getFullYear()) }),
-        };
-      }
-      const messageData: Record<string, string> = Object.fromEntries(
-        Object.entries(vars).map(([k, v]) => [k, v instanceof RawHtml ? v.html : v])
-      );
       return {
-        type: 'customerio' as const,
-        transactional_message_id: templates[input.template],
         subject: subjects[input.template],
-        message_data: messageData,
+        html: renderTemplate(input.template, { ...vars, year: String(new Date().getFullYear()) }),
       };
     }),
 
@@ -192,45 +127,23 @@ export const emailTestingRouter = createTRPCRouter({
     .input(
       z.object({
         template: TemplateNameSchema,
-        provider: ProviderNameSchema,
         recipient: z.string().email(),
       })
     )
     .mutation(async ({ input }) => {
       const vars = fixtureTemplateVars(input.template);
-
-      if (input.provider === 'customerio') {
-        const messageData: Record<string, string> = Object.fromEntries(
-          Object.entries(vars).map(([k, v]) => [k, v instanceof RawHtml ? v.html : v])
-        );
-        const result = await sendViaCustomerIo({
-          transactional_message_id: templates[input.template],
-          to: input.recipient,
-          message_data: messageData,
-          identifiers: { email: input.recipient },
-          reply_to: 'hi@kilocode.ai',
-        });
-        if (!result) {
-          throw new TRPCError({
-            code: 'INTERNAL_SERVER_ERROR',
-            message: 'CUSTOMERIO_EMAIL_API_KEY is not configured — email was not sent',
-          });
-        }
-        return { provider: input.provider, recipient: input.recipient };
-      }
-
-      const subject = subjects[input.template];
-      const html = renderTemplate(input.template, {
-        ...vars,
-        year: String(new Date().getFullYear()),
+      const result = await send({
+        to: input.recipient,
+        templateName: input.template,
+        templateVars: vars,
       });
-      const result = await sendViaMailgun({ to: input.recipient, subject, html });
-      if (!result) {
+      if (!result.sent) {
         throw new TRPCError({
-          code: 'INTERNAL_SERVER_ERROR',
-          message: 'MAILGUN_API_KEY/MAILGUN_DOMAIN is not configured — email was not sent',
+          code: 'BAD_REQUEST',
+          message:
+            'Email blocked by NeverBounce verification. This address is invalid or disposable.',
         });
       }
-      return { provider: input.provider, recipient: input.recipient };
+      return { recipient: input.recipient };
     }),
 });
diff --git a/src/routers/organizations/organization-members-router.test.ts b/src/routers/organizations/organization-members-router.test.ts
index 14add39e0..6a5fd1d77 100644
--- a/src/routers/organizations/organization-members-router.test.ts
+++ b/src/routers/organizations/organization-members-router.test.ts
@@ -5,7 +5,7 @@ import type { User, Organization } from '@kilocode/db/schema';
 
 // Mock the email service to prevent actual API calls during tests
 jest.mock('@/lib/email', () => ({
-  sendOrganizationInviteEmail: jest.fn().mockResolvedValue(undefined),
+  sendOrganizationInviteEmail: jest.fn().mockResolvedValue({ sent: true }),
 }));
 
 // Test users and organization will be created dynamically
diff --git a/src/routers/organizations/organization-members-router.ts b/src/routers/organizations/organization-members-router.ts
index d568e5332..7c0e00829 100644
--- a/src/routers/organizations/organization-members-router.ts
+++ b/src/routers/organizations/organization-members-router.ts
@@ -218,13 +218,26 @@ export const organizationsMembersRouter = createTRPCRouter({
     }
     const acceptInviteUrl = getAcceptInviteUrl(invitation.token);
 
-    await sendOrganizationInviteEmail({
+    const emailResult = await sendOrganizationInviteEmail({
       to: email,
       organizationName: organization.name,
       inviterName: user.google_user_name,
       acceptInviteUrl,
     });
 
+    if (!emailResult.sent) {
+      // Expire the invitation so it doesn't block future invites to the same email
+      await db
+        .update(organization_invitations)
+        .set({ expires_at: sql`NOW()` })
+        .where(eq(organization_invitations.id, invitation.id));
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message:
+          'Unable to deliver the invitation email to this address. Please use a different email.',
+      });
+    }
+
     await createAuditLog({
       action: 'organization.user.send_invite',
       actor_email: user.google_user_email,