r specific events, evaluating conditions against the state machine. 4. Execution: Qualified actions invoke external services (Resend, Slack, SMS) with retry logic and idempotency keys.

Technical Implementation

1. Schema Design for State Management

Avoid flat user tables. Implement a normalized schema to track marketing state independently of user profile data. This prevents race conditions and allows parallel flows.

-- Supabase / PostgreSQL Schema

CREATE TABLE marketing_flows (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  slug TEXT UNIQUE NOT NULL, -- e.g., 'welcome_drip', 'feature_announcement'
  status TEXT CHECK (status IN ('active', 'paused', 'archived')) DEFAULT 'active',
  created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE marketing_profiles (
  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
  flow_id UUID REFERENCES marketing_flows(id),
  current_step TEXT NOT NULL, -- e.g., 'step_1_email_sent'
  last_triggered_at TIMESTAMPTZ,
  metadata JSONB DEFAULT '{}',
  PRIMARY KEY (user_id, flow_id)
);

-- Index for efficient querying of pending actions
CREATE INDEX idx_marketing_profiles_step ON marketing_profiles(current_step) 
WHERE current_step != 'completed';

2. Event-Driven Trigger Logic

Use Edge Functions or Database Triggers to process events. Edge functions provide better error handling and integration with external APIs.

// functions/on-event-trigger/index.ts
import { serve } from 'https://deno.land/std@0.168.0/http/server.ts'
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'
import { Resend } from 'npm:resend@2.0.0'

const resend = new Resend(Deno.env.get('RESEND_API_KEY'))
const supabase = createClient(
  Deno.env.get('SUPABASE_URL') ?? '',
  Deno.env.get('SUPABASE_SERVICE_KEY') ?? ''
)

serve(async (req) => {
  const { event, userId, payload } = await req.json()

  // 1. Evaluate Flow Eligibility
  // Check if user is already in a flow or eligible to enter
  const { data: profile } = await supabase
    .from('marketing_profiles')
    .select('current_step, flow_id')
    .eq('user_id', userId)
    .single()

  if (event === 'USER_SIGNED_UP') {
    // Idempotency check: ensure we don't double-trigger
    const { data: existing } = await supabase
      .from('marketing_profiles')
      .select('id')
      .eq('user_id', userId)
      .eq('flow_id', 'welcome_flow_id')
      .single()

    if (!existing) {
      await supabase.from('marketing_profiles').insert({
        user_id: userId,
        flow_id: 'welcome_flow_id',
        current_step: 'step_0_entry'
      })
      
      // Trigger immediate welcome email
      await triggerWelcomeEmail(userId)
    }
  }

  return new Response(JSON.stringify({ status: 'processed' }), {
    headers: { 'Content-Type': 'application/json' }
  })
})

async function triggerWelcomeEmail(userId: string) {
  // Fetch user email from auth.users via edge function security
  const { data: user } = await supabase.auth.admin.getUserById(userId)
  
  await resend.emails.send({
    from: 'Founder <updates@yourdomain.com>',
    to: [user.user.email],
    subject: 'Welcome to the product',
    html: `<h1>Hi there,</h1><p>Thanks for joining. Here is your first step...</p>`
  })

  // Update state
  await supabase
    .from('marketing_profiles')
    .update({ current_step: 'step_1_welcome_sent', last_triggered_at: new Date() })
    .eq('user_id', userId)
}

3. Frequency Capping and Deduplication

Solo automation fails when users are spammed. Implement a frequency cap mechanism at the database level.

// Utility for frequency capping
async function canSend(userId: string, flowId: string, intervalMinutes: number): Promise<boolean> {
  const { data } = await supabase
    .from('marketing_profiles')
    .select('last_triggered_at')
    .eq('user_id', userId)
    .eq('flow_id', flowId)
    .single()

  if (!data?.last_triggered_at) return true

  const lastTrigger = new Date(data.last_triggered_at).getTime()
  const now = Date.now()
  const diffMinutes = (now - lastTrigger) / 60000

  return diffMinutes >= intervalMinutes
}

4. Cron-Based Reactivation

Use GitHub Actions or Vercel Cron for scheduled tasks that don't rely on user events, such as weekly digests or reactivation campaigns.

# .github/workflows/marketing-cron.yml
name: Marketing Cron Jobs
on:
  schedule:
    - cron: '0 9 * * 1' # Every Monday at 9 AM UTC
  workflow_dispatch:

jobs:
  send-weekly-digest:
    runs-on: ubuntu-latest
    steps:
      - name: Trigger Digest Edge Function
        run: |
          curl -X POST https://your-project.supabase.co/functions/v1/send-weekly-digest \
            -H "Authorization: Bearer ${{ secrets.SUPABASE_SERVICE_KEY }}" \
            -H "Content-Type: application/json"

Pitfall Guide

1. Ignoring Deliverability Configuration

Mistake: Sending emails from a domain without SPF, DKIM, and DMARC records. Impact: Emails land in spam folders. Open rates drop below 10%. Best Practice: Configure DNS records immediately. Use a subdomain (e.g., updates.yourdomain.com) for marketing to protect the primary domain reputation. Warm up the domain gradually.

2. Hardcoding Flow Logic

Mistake: Embedding marketing logic directly in application code without abstraction. Impact: Changing a drip sequence requires a full app redeployment and risks breaking core features. Best Practice: Abstract flows into configuration files or database-driven definitions. Use a flow-config.ts that maps steps to actions, allowing non-code updates where possible.

3. Lack of Idempotency

Mistake: Retrying webhooks without idempotency keys, causing duplicate emails. Impact: User frustration and increased costs. Best Practice: Every external API call must include an idempotency key derived from the event hash. Store processed event IDs in a processed_events table to prevent reprocessing.

4. Over-Engineering the First Flow

Mistake: Building a complex state machine for three email steps. Impact: Wasted development time on infrastructure before validating the marketing message. Best Practice: Start with a linear script. Refactor into a state machine only when you have multiple branching flows or complex conditional logic.

5. No Error Monitoring

Mistake: Assuming edge functions succeed silently. Impact: Broken funnels that drain leads without detection. Best Practice: Integrate error tracking (Sentry, Logtail) into all marketing functions. Set up alerts for failed email sends or trigger errors. Monitor marketing_profiles for users stuck in pending states.

6. Neglecting Unsubscribe Mechanics

Mistake: Forgetting to implement a robust unsubscribe link and processing logic. Impact: Legal compliance risks (CAN-SPAM, GDPR) and spam complaints. Best Practice: Include a managed unsubscribe link in every email. Implement a webhook to catch unsubscribe events and update the marketing_profiles or a global suppression_list table immediately.

7. Data Silos

Mistake: Storing marketing events in a separate tool without syncing back to the main DB. Impact: Inability to correlate marketing actions with product usage or revenue. Best Practice: Keep all marketing state in your primary database. Export data to analytics tools (Mixpanel, PostHog) for visualization, but maintain the source of truth in your schema.

Production Bundle

Action Checklist

• Define Core Events: Identify the top 3 user actions that trigger marketing communication (e.g., SIGNUP, TRIAL_END, PAYMENT_FAILED).
• Configure DNS: Set up SPF, DKIM, and DMARC for your marketing subdomain. Verify with a tool like Mail-Tester.
• Implement Idempotency: Add processed_events table and logic to prevent duplicate triggers.
• Build Email Templates: Create React-based email templates using @react-email/render for consistent rendering.
• Deploy Edge Functions: Deploy trigger functions and cron jobs. Verify environment variables and secrets.
• Set Up Monitoring: Configure error alerts for marketing functions and track key metrics (open rate, click rate) in your analytics dashboard.
• Test Deliverability: Send test emails to major providers (Gmail, Outlook, Apple) and check spam scores.
• Document Flows: Maintain a MARKETING_FLOWS.md file describing each flow, its triggers, and current state.

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
Bootstrapped Solo Founder	Code-First (Supabase + Resend)	Minimal cost, full control, scales with revenue.	<$10/mo
High-Volume SaaS (>50k MAU)	Hybrid (Code-First Triggers + ESP for Bulk)	ESP handles bulk deliverability; code handles transactional.	$50 - $200/mo
Non-Technical Co-Founder Involved	Code-First with Admin UI	Developers build the engine; non-tech updates content via CMS/UI.	$20/mo (CMS)
Strict Compliance Requirements	Self-Hosted SMTP + Code	Full data residency control; audit logs in own DB.	$30/mo (VPS)

Configuration Template

Use this TypeScript configuration to define flows declaratively. This enables type safety and easy maintenance.

// config/marketing-flows.ts

export interface FlowStep {
  id: string;
  condition: (user: User, context: Context) => boolean;
  action: (user: User) => Promise<void>;
  delay?: number; // milliseconds
}

export interface FlowDefinition {
  slug: string;
  entryCondition: (user: User) => boolean;
  steps: FlowStep[];
}

export const MARKETING_FLOWS: Record<string, FlowDefinition> = {
  welcome_drip: {
    slug: 'welcome_drip',
    entryCondition: (user) => user.created_at > new Date(Date.now() - 86400000),
    steps: [
      {
        id: 'email_welcome',
        condition: () => true,
        action: async (user) => {
          await resend.emails.send({
            to: [user.email],
            subject: 'Welcome!',
            html: getWelcomeTemplate(user)
          });
        },
        delay: 0
      },
      {
        id: 'email_onboarding',
        condition: (user) => user.has_completed_setup,
        action: async (user) => {
          await resend.emails.send({
            to: [user.email],
            subject: 'Quick tip',
            html: getOnboardingTemplate(user)
          });
        },
        delay: 3600000 // 1 hour
      }
    ]
  }
};

Quick Start Guide

1. Initialize Project:

   npx create-solo-marketing my-marketing-engine
   cd my-marketing-engine
   

2. Configure Environment: Copy .env.example to .env. Add SUPABASE_URL, SUPABASE_SERVICE_KEY, and RESEND_API_KEY.

   cp .env.example .env
   # Edit .env with your credentials
   

3. Run Database Migrations: Apply the schema to your database to create marketing_flows and marketing_profiles.

   supabase db push
   

4. Deploy Functions: Deploy edge functions to your provider.

   supabase functions deploy on-event-trigger
   supabase functions deploy send-weekly-digest
   

5. Verify: Trigger a test event via the Supabase dashboard or API. Check the marketing_profiles table for state updates and verify email receipt.

   curl -X POST https://your-project.supabase.co/functions/v1/on-event-trigger \
     -H "Content-Type: application/json" \
     -d '{"event":"USER_SIGNED_UP","userId":"test-user-id","payload":{}}'