Trade Show & Event Lead Processor

You spent thousands on that trade show booth. Now turn those business cards and badge scans into customers - before they forget who you are.

The Event Lead Problem

What usually happens:

1. Collect 200 business cards
2. Return to office Monday
3. Spend days entering data
4. Send generic "nice to meet you" email
5. Wonder why nobody responds

What should happen:

1. Scan business card at booth
2. AI sends personalized message within hours
3. Lead replies while still at conference
4. Meeting booked before they fly home

System Architecture

┌─────────────────────────────────────────────────────────────┐
│                  Lead Capture at Event                       │
│  Badge Scan | Business Card | QR Code | Manual Entry        │
└───────────────────────┬─────────────────────────────────────┘
                        │
                        ↓
┌─────────────────────────────────────────────────────────────┐
│              Data Extraction & Normalization                 │
│         OCR | Parse | Enrich | Score                        │
└───────────────────────┬─────────────────────────────────────┘
                        │
                        ↓
┌─────────────────────────────────────────────────────────────┐
│                  GoHighLevel Import                          │
│       Create Contact | Add Event Tags | Assign              │
└───────────────────────┬─────────────────────────────────────┘
                        │
              ┌─────────┼─────────┐
              ↓         ↓         ↓
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Hot Lead     │ │ Warm Lead    │ │ Cold Lead    │
│ (Decision    │ │ (Interested) │ │ (Just        │
│  Maker +     │ │              │ │  Scanning)   │
│  Budget)     │ │              │ │              │
└──────┬───────┘ └──────┬───────┘ └──────┬───────┘
       │                │                │
       ↓                ↓                ↓
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Same-day     │ │ Same-day     │ │ Post-event   │
│ Call + Email │ │ Email        │ │ Nurture      │
└──────────────┘ └──────────────┘ └──────────────┘

Lead Capture Methods

1. Badge Scanner Integration

// Major badge scanner providers
const badgeScannerIntegrations = {
  cvent: {
    webhook: "https://your-n8n.com/webhook/cvent-scan",
    format: "json",
  },
  eventbrite: {
    webhook: "https://your-n8n.com/webhook/eventbrite-scan",
    format: "json",
  },
  expo_logic: {
    csvExport: true,
    format: "csv",
  },
};

// Process badge scan webhook
const processBadgeScan = (data) => ({
  source: "badge_scan",
  eventName: data.event_name,
  eventDate: data.event_date,
  boothId: data.booth_id,
  scanTime: data.timestamp,
  firstName: data.first_name,
  lastName: data.last_name,
  email: data.email,
  company: data.company,
  title: data.job_title,
  phone: data.phone,
});

2. Business Card OCR

// Business card scanning with AI
const processBusinessCard = async (imageBase64) => {
  // Use OpenAI Vision to extract info
  const response = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: `Extract contact information from this business card. Return JSON with:
          - firstName
          - lastName
          - email
          - phone
          - company
          - title
          - address
          - website
          Return null for any field not visible.`,
          },
          {
            type: "image_url",
            image_url: {
              url: `data:image/jpeg;base64,${imageBase64}`,
            },
          },
        ],
      },
    ],
    response_format: { type: "json_object" },
  });

  return JSON.parse(response.choices[0].message.content);
};

// Mobile app for scanning (webhook endpoint)
app.post("/api/scan-card", async (req, res) => {
  const { image, eventId, notes, scannedBy } = req.body;

  // Extract card data
  const cardData = await processBusinessCard(image);

  // Add context
  const lead = {
    ...cardData,
    source: "business_card",
    eventId,
    notes,
    scannedBy,
    scanTime: new Date().toISOString(),
  };

  // Process immediately
  await processEventLead(lead);

  res.json({ success: true, extracted: cardData });
});

3. Manual Entry Form

// Quick entry form for booth staff
const quickEntrySchema = {
  required: ["firstName", "company"],
  optional: [
    "lastName",
    "email",
    "phone",
    "title",
    "notes",
    "interest",
    "priority",
  ],
  defaults: {
    source: "manual_entry",
    scannedBy: "{{currentUser}}",
  },
};

// Mobile-friendly form endpoint
app.post("/api/quick-entry", async (req, res) => {
  const lead = {
    ...quickEntrySchema.defaults,
    ...req.body,
    eventId: req.body.eventId,
    entryTime: new Date().toISOString(),
  };

  await processEventLead(lead);
  res.json({ success: true });
});

4. Bulk CSV Import

// Post-event CSV import
const importEventCSV = async (csvFile, eventConfig) => {
  const rows = await parseCSV(csvFile);

  const leads = rows.map((row) => ({
    source: "csv_import",
    eventId: eventConfig.eventId,
    eventName: eventConfig.eventName,
    ...mapCSVColumns(row, eventConfig.columnMapping),
  }));

  // Process in batches
  for (const batch of chunk(leads, 50)) {
    await Promise.all(batch.map(processEventLead));
    await delay(1000); // Rate limiting
  }

  return { imported: leads.length };
};

Lead Scoring for Events

const scoreEventLead = (lead, eventContext) => {
  let score = 20; // Base score for attending event

  // Title/Role scoring
  const titleScores = {
    CEO: 40,
    CTO: 40,
    CFO: 40,
    Owner: 40,
    VP: 35,
    Director: 30,
    Head: 30,
    Manager: 20,
    Senior: 15,
    Analyst: 10,
    Coordinator: 5,
  };

  for (const [title, points] of Object.entries(titleScores)) {
    if (lead.title?.toLowerCase().includes(title.toLowerCase())) {
      score += points;
      break;
    }
  }

  // Company size (if enriched)
  if (lead.companySize > 500) score += 20;
  else if (lead.companySize > 100) score += 15;
  else if (lead.companySize > 20) score += 10;

  // Booth interaction notes
  if (lead.notes?.toLowerCase().includes("demo")) score += 25;
  if (lead.notes?.toLowerCase().includes("pricing")) score += 20;
  if (lead.notes?.toLowerCase().includes("ready")) score += 30;
  if (lead.notes?.toLowerCase().includes("budget")) score += 25;

  // Priority flag from booth staff
  if (lead.priority === "high") score += 30;
  if (lead.priority === "hot") score += 50;

  return {
    score,
    temperature: score >= 80 ? "hot" : score >= 50 ? "warm" : "cold",
  };
};

Same-Day Follow-Up Messages

Hot Lead (Decision Maker + Interest)

const hotLeadFollowUp = {
  sms: {
    timing: "within_2_hours",
    message: `Great meeting you at {{eventName}}, {{firstName}}! I'd love to continue our conversation about {{interest}}. Are you free for a quick call tomorrow?`,
  },
  email: {
    timing: "within_4_hours",
    subject: `Following up from {{eventName}}`,
    body: `Hi {{firstName}},

Great chatting with you at the {{companyName}} booth today!

You mentioned being interested in {{interest}} - I put together some info that might be helpful:

{{relevantResource}}

Would love to schedule a proper call to discuss how we could help {{theirCompany}}. Here's my calendar: {{calendarLink}}

Looking forward to connecting!

{{senderName}}`,
  },
};

Warm Lead (Interested)

const warmLeadFollowUp = {
  email: {
    timing: "same_day_evening",
    subject: `Nice meeting you at {{eventName}}!`,
    body: `Hi {{firstName}},

It was great meeting you at {{eventName}} today!

As promised, here's some information about {{topic}} that we discussed:

{{resourceLinks}}

If you have any questions, feel free to reply to this email or book a call: {{calendarLink}}

Enjoy the rest of the conference!

{{senderName}}`,
  },
};

Cold Lead (Just Scanning)

const coldLeadFollowUp = {
  email: {
    timing: "day_after_event",
    subject: `Thanks for stopping by at {{eventName}}`,
    body: `Hi {{firstName}},

Thanks for visiting the {{companyName}} booth at {{eventName}}!

In case you'd like to learn more about what we do, here are some resources:

• {{resource1}}
• {{resource2}}
• {{resource3}}

Feel free to reach out if you have any questions!

Best,
{{senderName}}`,
  },
};

AI-Powered Personalization

const generatePersonalizedFollowUp = async (lead, eventContext) => {
  const prompt = `Generate a personalized follow-up message for an event lead.

Lead Info:
- Name: ${lead.firstName} ${lead.lastName}
- Title: ${lead.title}
- Company: ${lead.company}
- Event: ${eventContext.eventName}
- Booth notes: ${lead.notes}
- Interest: ${lead.interest}

Requirements:
1. Reference the specific event
2. Mention their company or role if relevant
3. Connect to what they were interested in
4. Include a clear next step
5. Keep SMS under 160 characters, email under 150 words

Generate both SMS and email versions.`;

  const response = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [{ role: "user", content: prompt }],
    response_format: { type: "json_object" },
  });

  return JSON.parse(response.choices[0].message.content);
};

Event ROI Tracking

const trackEventROI = async (eventId) => {
  const leads = await getLeadsByEvent(eventId);
  const event = await getEvent(eventId);

  const metrics = {
    eventName: event.name,
    eventCost: event.cost, // Booth, travel, materials
    totalLeads: leads.length,

    byTemperature: {
      hot: leads.filter((l) => l.temperature === "hot").length,
      warm: leads.filter((l) => l.temperature === "warm").length,
      cold: leads.filter((l) => l.temperature === "cold").length,
    },

    conversions: {
      appointments: leads.filter((l) => l.hadAppointment).length,
      opportunities: leads.filter((l) => l.opportunity).length,
      closedWon: leads.filter((l) => l.status === "customer").length,
      revenue: leads.reduce((sum, l) => sum + (l.dealValue || 0), 0),
    },

    calculated: {},
  };

  // Calculate derived metrics
  metrics.calculated = {
    costPerLead: metrics.eventCost / metrics.totalLeads,
    appointmentRate: metrics.conversions.appointments / metrics.totalLeads,
    conversionRate: metrics.conversions.closedWon / metrics.totalLeads,
    roi:
      ((metrics.conversions.revenue - metrics.eventCost) / metrics.eventCost) *
      100,
    revenuePerLead: metrics.conversions.revenue / metrics.totalLeads,
  };

  return metrics;
};

Pre-Event Setup Checklist

const preEventSetup = {
  "1_week_before": [
    "Create event in GHL with unique tag",
    "Set up badge scanner webhook integration",
    "Prepare booth staff training on lead capture",
    "Create email templates for each lead tier",
    "Set up mobile scanning app on staff phones",
    "Test end-to-end flow with sample data",
  ],

  day_before: [
    "Verify all integrations are working",
    "Brief booth staff on lead qualification criteria",
    "Ensure adequate data/WiFi for mobile scanning",
    "Pre-schedule follow-up campaigns",
    "Set up real-time lead alert to sales team",
  ],

  day_of: [
    "Turn on real-time lead processing",
    "Monitor first few leads for issues",
    "Have backup manual entry process ready",
    "Check follow-up messages are sending",
  ],

  post_event: [
    "Import any remaining CSV data",
    "Review and adjust lead scores",
    "Analyze same-day response rates",
    "Schedule post-event nurture sequences",
  ],
};

n8n Workflow

1. Webhook: Receive lead from any source
      ↓
2. Normalize data (map fields to standard schema)
      ↓
3. Extract/enrich data (OCR if image, company lookup)
      ↓
4. Score lead (title, notes, interest level)
      ↓
5. Create GoHighLevel contact
      ↓
6. Apply event tags and assignment
      ↓
7. Route to appropriate follow-up:
   - Hot: Immediate SMS + Email + Sales Alert
   - Warm: Same-day Email
   - Cold: Next-day Nurture
      ↓
8. Track metrics for event ROI

---

Ready to maximize your event ROI? Get the implementation package or let us handle your next event.