Dynamic Self-Optimizing Ad Campaigns: How AI Rewrites Your Copy in Real-Time

// Meta Ads API data retrieval
async function getCampaignMetrics(campaignId: string, dateRange: string) {
  const response = await fetch(
    `https://graph.facebook.com/v18.0/${campaignId}/insights`,
    {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${accessToken}`
      },
      params: {
        fields: [
          'impressions',
          'clicks',
          'spend',
          'ctr',
          'cpc',
          'actions',
          'cost_per_action_type',
          'purchase_roas'
        ].join(','),
        date_preset: dateRange,
        level: 'ad',
        breakdowns: 'publisher_platform,placement'
      }
    }
  );

  return response.json();
}

// Webhook handler for campaign alerts
app.post('/webhooks/meta-ads', (req, res) => {
  const { entry } = req.body;

  for (const change of entry) {
    if (change.changes) {
      for (const item of change.changes) {
        if (item.field === 'ad_account') {
          // Campaign performance alert triggered
          triggerOptimizationWorkflow(item.value);
        }
      }
    }
  }

  res.sendStatus(200);
});

┌─────────────────────────────────────────────────────────┐
│                    Trigger Layer                         │
│  (Scheduled: every 4hr) OR (Webhook: threshold alert)   │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│                   Data Collection                        │
│  - Pull campaign metrics from Meta API                  │
│  - Pull conversion data from Conversions API            │
│  - Aggregate by ad creative                             │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│                  Performance Analysis                    │
│  - Calculate performance vs. benchmarks                 │
│  - Identify underperformers (CTR < 1%, ROAS < 2x)       │
│  - Identify outperformers for pattern extraction        │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│                  Content Generation                      │
│  - Extract patterns from winning copy                   │
│  - Generate variations for underperformers              │
│  - Apply brand guidelines and constraints               │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│                   Review Gateway                         │
│  (Auto-approve if within guardrails)                    │
│  (Queue for human review if significant change)         │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│                    Deployment                           │
│  - Update ad creative via Meta API                      │
│  - Log changes for audit trail                          │
│  - Set monitoring for new variations                    │
└─────────────────────────────────────────────────────────┘

// Self-optimizing campaign workflow
const campaignOptimizer = {
  name: "Meta Campaign Auto-Optimizer",
  trigger: {
    type: "schedule",
    interval: "every 4 hours",
    // Also trigger on webhook alerts
    additionalTriggers: ["meta-performance-alert"]
  },

  steps: [
    {
      id: "fetch-metrics",
      action: "meta.getInsights",
      params: {
        campaignIds: "{{activeCampaigns}}",
        dateRange: "last_7d",
        breakdown: ["placement", "age", "gender"]
      }
    },
    {
      id: "analyze-performance",
      action: "ai.analyze",
      params: {
        model: "gpt-4",
        prompt: `
          Analyze these campaign metrics and identify:
          1. Ads with CTR below 1% that have 1000+ impressions
          2. Ads with ROAS below 2x target
          3. Patterns in top-performing ads (3x+ ROAS)

          Metrics: {{steps.fetch-metrics.output}}

          Return JSON with:
          - underperformers: [{adId, issue, currentMetrics}]
          - topPatterns: [{pattern, exampleAds}]
        `
      }
    },
    {
      id: "generate-variations",
      action: "ai.generate",
      condition: "{{steps.analyze-performance.underperformers.length > 0}}",
      params: {
        model: "claude-3-5-sonnet",
        prompt: `
          Generate 3 headline and body variations for each underperforming ad.

          Underperformers: {{steps.analyze-performance.underperformers}}
          Winning patterns: {{steps.analyze-performance.topPatterns}}

          Brand guidelines:
          - Tone: Professional but approachable
          - Max headline: 40 characters
          - Max body: 125 characters
          - Required CTA: Learn More, Get Started, or Try Free

          Return variations as array with original adId.
        `
      }
    },
    {
      id: "apply-guardrails",
      action: "rules.check",
      params: {
        content: "{{steps.generate-variations.output}}",
        rules: [
          "no-competitor-mentions",
          "approved-claims-only",
          "brand-voice-check",
          "legal-compliance"
        ]
      }
    },
    {
      id: "route-approval",
      action: "conditional",
      branches: [
        {
          condition: "{{steps.apply-guardrails.passedAll}}",
          next: "auto-deploy"
        },
        {
          condition: "{{steps.apply-guardrails.needsReview}}",
          next: "queue-review"
        }
      ]
    },
    {
      id: "auto-deploy",
      action: "meta.updateAds",
      params: {
        updates: "{{steps.generate-variations.output}}",
        mode: "create_variation", // Don't replace, create A/B test
        budgetSplit: 0.3 // Give new variation 30% of budget
      }
    },
    {
      id: "log-changes",
      action: "database.insert",
      params: {
        table: "campaign_changes",
        data: {
          timestamp: "{{now}}",
          campaignId: "{{trigger.campaignId}}",
          originalAds: "{{steps.analyze-performance.underperformers}}",
          newVariations: "{{steps.generate-variations.output}}",
          autoApproved: "{{steps.apply-guardrails.passedAll}}"
        }
      }
    }
  ]
};

const patternAnalysisPrompt = `
Analyze these top-performing ad copies and extract reusable patterns:

Top performers (3x+ ROAS):
{{topAds}}

For each ad, identify:
1. Headline structure (question/statement/number/urgency)
2. Opening hook type (problem/benefit/proof/curiosity)
3. Value proposition positioning
4. CTA style and placement
5. Emotional trigger (fear/aspiration/curiosity/urgency)

Then synthesize into 5 actionable patterns that can be applied to new ads.

Output format:
{
  "patterns": [
    {
      "name": "Question + Number Headline",
      "description": "Headlines that open with a question and include a specific number",
      "example": "Want to cut ad costs by 40%?",
      "applicability": "Works best for awareness campaigns"
    }
  ]
}
`;

const brandGuardrails = {
  voice: {
    allowed: ["professional", "helpful", "confident", "friendly"],
    prohibited: ["aggressive", "manipulative", "fear-based", "clickbait"]
  },

  claims: {
    requireSubstantiation: true,
    approvedClaims: [
      "Save up to 40% on ad spend",
      "Used by 500+ companies",
      "Set up in under 30 minutes"
    ],
    prohibitedClaims: [
      "guaranteed results",
      "best in the market",
      "instant success"
    ]
  },

  competitors: {
    mentionPolicy: "never",
    comparisonPolicy: "never"
  },

  legal: {
    requireDisclosures: true,
    ftcCompliant: true,
    gdprCompliant: true
  }
};

const approvalRules = {
  autoApprove: {
    // Minor wording changes
    changeType: ["headline_variation", "cta_swap"],
    // Within existing approved language
    usesApprovedClaims: true,
    // Budget impact limited
    budgetChange: { max: 0.2 }, // Max 20% budget shift
    // Performance impact expected
    expectedImprovement: { min: 0.1 } // At least 10% expected lift
  },

  requireReview: {
    // New messaging angles
    changeType: ["value_prop_change", "target_audience_shift"],
    // Significant budget changes
    budgetChange: { min: 0.2 },
    // New claims or positioning
    newClaims: true
  },

  requireApproval: {
    // Campaign structure changes
    changeType: ["campaign_pause", "campaign_create"],
    // Major budget changes
    budgetChange: { min: 0.5 },
    // New creative assets
    newCreative: true
  }
};

// Campaign optimization dashboard data
async function getDashboardData(dateRange: string) {
  const [activity, performance, quality] = await Promise.all([
    // Automation activity metrics
    db.query(`
      SELECT
        DATE(timestamp) as date,
        COUNT(*) as optimization_runs,
        SUM(CASE WHEN auto_approved THEN 1 ELSE 0 END) as auto_approved,
        SUM(variations_generated) as total_variations
      FROM campaign_changes
      WHERE timestamp > DATE_SUB(NOW(), INTERVAL ${dateRange})
      GROUP BY DATE(timestamp)
    `),

    // Performance comparison
    db.query(`
      SELECT
        cc.campaign_id,
        AVG(before_ctr) as avg_before_ctr,
        AVG(after_ctr) as avg_after_ctr,
        AVG(before_roas) as avg_before_roas,
        AVG(after_roas) as avg_after_roas
      FROM campaign_changes cc
      JOIN campaign_metrics cm ON cc.campaign_id = cm.campaign_id
      WHERE cc.timestamp > DATE_SUB(NOW(), INTERVAL ${dateRange})
      GROUP BY cc.campaign_id
    `),

    // Quality metrics
    db.query(`
      SELECT
        COUNT(CASE WHEN guardrail_violations > 0 THEN 1 END) as violations_caught,
        COUNT(CASE WHEN human_override THEN 1 END) as human_overrides,
        AVG(CASE WHEN after_roas > before_roas THEN 1 ELSE 0 END) as success_rate
      FROM campaign_changes
      WHERE timestamp > DATE_SUB(NOW(), INTERVAL ${dateRange})
    `)
  ]);

  return {
    activity,
    performance,
    quality
  };
}