Event Management

Event Management

Streamline event operations to improve attendee experience and drive measurable outcomes across in-person, virtual, and hybrid NABIP events.

When to Use

Activate this skill when:

• Creating event registration workflows
• Implementing capacity and waitlist management
• Building QR code check-in systems
• Designing virtual/hybrid event support
• Creating multi-tier pricing (early bird, member, non-member)
• Implementing post-event analytics and feedback
• Working on event calendar and scheduling
• Building event communication workflows (confirmations, reminders)

Event Types

NABIP Event Categories

1. Conferences: Multi-day, large-scale events (500+ attendees)
2. Webinars: Online-only educational sessions (100-300 attendees)
3. Workshops: Hands-on training sessions (25-75 attendees)
4. Networking: Social and professional connection events (50-200 attendees)
5. Chapter Meetings: Local/state gatherings (15-50 attendees)

Event Lifecycle States

draft → published → registration_open → registration_closed → in_progress → completed → archived

State Transition Rules

1. draft → published: Event details finalized, ready for announcement
2. published → registration_open: Registration portal activated
3. registration_open → registration_closed: Registration deadline reached OR capacity filled
4. registration_closed → in_progress: Event start date/time reached
5. in_progress → completed: Event end date/time reached
6. completed → archived: Post-event tasks finished (30 days after completion)

Event Data Model

interface Event {
  id: string
  title: string
  description: string
  eventType: "conference" | "webinar" | "workshop" | "networking" | "chapter_meeting"
  deliveryMode: "in_person" | "virtual" | "hybrid"
  status: "draft" | "published" | "registration_open" | "registration_closed" | "in_progress" | "completed" | "archived"

  // Scheduling
  startDate: Date
  endDate: Date
  timezone: string
  registrationOpenDate: Date
  registrationCloseDate: Date

  // Capacity
  capacity: number
  currentRegistrations: number
  waitlistEnabled: boolean
  waitlistCapacity?: number

  // Location (for in-person/hybrid)
  venueName?: string
  venueAddress?: string
  venueCity?: string
  venueState?: string
  venueZip?: string

  // Virtual (for virtual/hybrid)
  virtualPlatform?: "zoom" | "teams" | "webex" | "custom"
  virtualMeetingUrl?: string
  virtualAccessCode?: string

  // Pricing
  pricingTiers: EventPricingTier[]

  // Organizer
  organizerId: string
  chapterId: string

  // Metadata
  createdAt: Date
  updatedAt: Date
}

interface EventPricingTier {
  id: string
  eventId: string
  name: string // "Early Bird", "Member", "Non-Member", "Student"
  price: number
  currency: string
  validFrom?: Date
  validUntil?: Date
  memberTypesEligible?: string[] // ["national", "state", "local"]
  maxQuantity?: number
}

interface EventRegistration {
  id: string
  eventId: string
  memberId: string
  status: "pending" | "confirmed" | "cancelled" | "waitlisted" | "attended" | "no_show"
  pricingTierId: string
  amountPaid: number
  paymentStatus: "pending" | "completed" | "refunded" | "failed"
  registrationDate: Date
  cancellationDate?: Date
  checkInTime?: Date
  checkInMethod?: "qr_code" | "manual" | "self_service"

  // Attendee info (for non-members)
  guestName?: string
  guestEmail?: string
  guestPhone?: string

  // Dietary/accessibility
  dietaryRequirements?: string
  accessibilityNeeds?: string
  specialRequests?: string
}

Registration Workflow

Event Registration Process

async function registerForEvent(
  eventId: string,
  memberId: string,
  pricingTierId: string,
  additionalInfo?: {
    dietaryRequirements?: string
    accessibilityNeeds?: string
    specialRequests?: string
  }
) {
  // Step 1: Validate event availability
  const event = await getEvent(eventId)
  if (event.status !== "registration_open") {
    throw new Error("Registration is not currently open for this event")
  }

  // Step 2: Check capacity
  if (event.currentRegistrations >= event.capacity) {
    if (event.waitlistEnabled && event.waitlistCapacity) {
      return addToWaitlist(eventId, memberId)
    }
    throw new Error("Event is at full capacity")
  }

  // Step 3: Validate pricing tier eligibility
  const member = await getMember(memberId)
  const pricingTier = event.pricingTiers.find(pt => pt.id === pricingTierId)

  if (!pricingTier) {
    throw new Error("Invalid pricing tier")
  }

  if (pricingTier.memberTypesEligible) {
    if (!pricingTier.memberTypesEligible.includes(member.memberType)) {
      throw new Error("You are not eligible for this pricing tier")
    }
  }

  // Step 4: Check for duplicate registration
  const existingRegistration = await db
    .select()
    .from(eventRegistrations)
    .where(
      and(
        eq(eventRegistrations.eventId, eventId),
        eq(eventRegistrations.memberId, memberId),
        ne(eventRegistrations.status, "cancelled")
      )
    )
    .limit(1)

  if (existingRegistration.length > 0) {
    throw new Error("You are already registered for this event")
  }

  // Step 5: Create registration record
  const registration = await db
    .insert(eventRegistrations)
    .values({
      eventId,
      memberId,
      pricingTierId,
      status: "pending",
      amountPaid: pricingTier.price,
      paymentStatus: "pending",
      registrationDate: new Date(),
      ...additionalInfo
    })
    .returning()

  // Step 6: Process payment
  const payment = await processEventPayment(
    registration[0].id,
    pricingTier.price,
    memberId
  )

  if (!payment.success) {
    // Mark registration as failed
    await db
      .update(eventRegistrations)
      .set({ paymentStatus: "failed" })
      .where(eq(eventRegistrations.id, registration[0].id))

    throw new Error("Payment processing failed")
  }

  // Step 7: Confirm registration
  await db
    .update(eventRegistrations)
    .set({
      status: "confirmed",
      paymentStatus: "completed"
    })
    .where(eq(eventRegistrations.id, registration[0].id))

  // Step 8: Update event capacity
  await db
    .update(events)
    .set({
      currentRegistrations: sql`${events.currentRegistrations} + 1`
    })
    .where(eq(events.id, eventId))

  // Step 9: Send confirmation email
  await sendEventConfirmationEmail(member.email, {
    eventTitle: event.title,
    startDate: event.startDate,
    location: event.deliveryMode === "in_person" ? event.venueName : "Virtual",
    confirmationCode: registration[0].id,
    amount: pricingTier.price
  })

  // Step 10: Add to calendar (generate .ics file)
  const calendarInvite = generateCalendarInvite(event, registration[0])
  await emailCalendarInvite(member.email, calendarInvite)

  return registration[0]
}

Waitlist Management

async function addToWaitlist(eventId: string, memberId: string) {
  const event = await getEvent(eventId)

  if (!event.waitlistEnabled) {
    throw new Error("Waitlist is not available for this event")
  }

  const waitlistCount = await db
    .select({ count: sql`COUNT(*)` })
    .from(eventRegistrations)
    .where(
      and(
        eq(eventRegistrations.eventId, eventId),
        eq(eventRegistrations.status, "waitlisted")
      )
    )

  if (waitlistCount[0].count >= (event.waitlistCapacity || 0)) {
    throw new Error("Waitlist is full")
  }

  const registration = await db
    .insert(eventRegistrations)
    .values({
      eventId,
      memberId,
      status: "waitlisted",
      registrationDate: new Date()
    })
    .returning()

  await sendWaitlistEmail(memberId, event)

  return registration[0]
}

async function promoteFromWaitlist(eventId: string, count: number = 1) {
  // Get waitlisted registrations in order
  const waitlisted = await db
    .select()
    .from(eventRegistrations)
    .where(
      and(
        eq(eventRegistrations.eventId, eventId),
        eq(eventRegistrations.status, "waitlisted")
      )
    )
    .orderBy(asc(eventRegistrations.registrationDate))
    .limit(count)

  for (const registration of waitlisted) {
    // Update status to pending (requires payment)
    await db
      .update(eventRegistrations)
      .set({ status: "pending" })
      .where(eq(eventRegistrations.id, registration.id))

    // Send promotion email with payment link
    const member = await getMember(registration.memberId)
    await sendWaitlistPromotionEmail(member.email, {
      eventId,
      registrationId: registration.id,
      paymentDeadline: new Date(Date.now() + 48 * 60 * 60 * 1000) // 48 hours
    })
  }
}

QR Code Check-In System

import { QRCodeSVG } from "qrcode.react"

// Generate unique QR code for each registration
function generateCheckInQR(registrationId: string): string {
  const checkInData = {
    registrationId,
    timestamp: Date.now(),
    signature: generateHMAC(registrationId) // Security verification
  }

  return JSON.stringify(checkInData)
}

// Render QR code in confirmation email
export function RegistrationQRCode({ registrationId }: { registrationId: string }) {
  const qrData = generateCheckInQR(registrationId)

  return (
    <div className="flex flex-col items-center gap-4">
      <QRCodeSVG
        value={qrData}
        size={200}
        level="H"
        includeMargin
      />
      <p className="text-sm text-muted-foreground">
        Show this QR code at event check-in
      </p>
      <p className="text-xs text-muted-foreground font-mono">
        Confirmation: {registrationId.slice(0, 8).toUpperCase()}
      </p>
    </div>
  )
}

// Check-in scanning endpoint
async function processCheckIn(scannedData: string) {
  const checkInData = JSON.parse(scannedData)

  // Verify signature
  if (!verifyHMAC(checkInData.registrationId, checkInData.signature)) {
    throw new Error("Invalid QR code")
  }

  // Verify registration exists
  const registration = await db
    .select()
    .from(eventRegistrations)
    .where(eq(eventRegistrations.id, checkInData.registrationId))
    .limit(1)

  if (!registration.length) {
    throw new Error("Registration not found")
  }

  if (registration[0].status !== "confirmed") {
    throw new Error(`Registration status: ${registration[0].status}`)
  }

  // Mark as attended
  await db
    .update(eventRegistrations)
    .set({
      status: "attended",
      checkInTime: new Date(),
      checkInMethod: "qr_code"
    })
    .where(eq(eventRegistrations.id, checkInData.registrationId))

  return {
    success: true,
    attendeeName: registration[0].guestName || (await getMember(registration[0].memberId)).name
  }
}

Virtual/Hybrid Event Support

interface VirtualEventSession {
  id: string
  eventId: string
  sessionName: string
  startTime: Date
  endTime: Date
  platform: "zoom" | "teams" | "webex" | "custom"
  meetingUrl: string
  meetingId?: string
  passcode?: string
  hostId: string
  recordingEnabled: boolean
  recordingUrl?: string
}

async function sendVirtualEventAccess(registrationId: string) {
  const registration = await getRegistration(registrationId)
  const event = await getEvent(registration.eventId)
  const member = await getMember(registration.memberId)

  if (event.deliveryMode === "in_person") {
    throw new Error("This is not a virtual event")
  }

  // Generate unique access link (with tracking)
  const accessToken = generateAccessToken(registrationId)
  const trackableUrl = `${event.virtualMeetingUrl}?ref=${accessToken}`

  await sendEmail({
    to: member.email,
    subject: `Virtual Access: ${event.title}`,
    template: "virtual-event-access",
    data: {
      eventTitle: event.title,
      startDate: event.startDate,
      platform: event.virtualPlatform,
      meetingUrl: trackableUrl,
      accessCode: event.virtualAccessCode,
      instructions: getVirtualPlatformInstructions(event.virtualPlatform)
    }
  })

  // Send reminder 1 hour before
  await scheduleReminder(registrationId, {
    sendAt: new Date(event.startDate.getTime() - 60 * 60 * 1000),
    template: "virtual-event-reminder",
    includeAccessLink: true
  })
}

Post-Event Analytics

interface EventPerformanceMetrics {
  totalRegistrations: number
  totalAttendees: number
  attendanceRate: number
  noShowRate: number
  cancellationRate: number
  totalRevenue: number
  revenueByTier: Record<string, number>
  averageTicketPrice: number
  capacityUtilization: number
  waitlistPromotions: number
  checkInMethods: Record<string, number>
  feedbackAverageRating?: number
  feedbackResponseRate?: number
}

async function calculateEventMetrics(eventId: string): Promise<EventPerformanceMetrics> {
  const event = await getEvent(eventId)
  const registrations = await db
    .select()
    .from(eventRegistrations)
    .where(eq(eventRegistrations.eventId, eventId))

  const totalRegistrations = registrations.length
  const totalAttendees = registrations.filter(r => r.status === "attended").length
  const noShows = registrations.filter(r => r.status === "no_show").length
  const cancelled = registrations.filter(r => r.status === "cancelled").length

  const totalRevenue = registrations
    .filter(r => r.paymentStatus === "completed")
    .reduce((sum, r) => sum + r.amountPaid, 0)

  return {
    totalRegistrations,
    totalAttendees,
    attendanceRate: (totalAttendees / totalRegistrations) * 100,
    noShowRate: (noShows / totalRegistrations) * 100,
    cancellationRate: (cancelled / totalRegistrations) * 100,
    totalRevenue,
    revenueByTier: calculateRevenueByTier(registrations),
    averageTicketPrice: totalRevenue / totalRegistrations,
    capacityUtilization: (totalRegistrations / event.capacity) * 100,
    waitlistPromotions: registrations.filter(r =>
      r.status === "confirmed" && r.promotedFromWaitlist
    ).length,
    checkInMethods: countCheckInMethods(registrations)
  }
}

// Automated post-event survey
async function sendPostEventSurvey(eventId: string) {
  const attendees = await db
    .select()
    .from(eventRegistrations)
    .where(
      and(
        eq(eventRegistrations.eventId, eventId),
        eq(eventRegistrations.status, "attended")
      )
    )

  for (const attendee of attendees) {
    const member = await getMember(attendee.memberId)
    const surveyToken = generateSurveyToken(attendee.id)

    await sendEmail({
      to: member.email,
      subject: "How was your experience?",
      template: "post-event-survey",
      data: {
        eventTitle: (await getEvent(eventId)).title,
        surveyUrl: `https://ams.nabip.org/surveys/${surveyToken}`
      }
    })
  }
}

Integration with Other Skills

• Use with supabase-schema-validator for event data models
• Combine with component-generator for event UI
• Works with analytics-helper for performance metrics
• Supports member-workflow for attendee management

Best for: Developers building event management features including registration, check-in, virtual event delivery, and post-event analytics for the NABIP AMS.

Converted and distributed by TomeVault — claim your Tome and manage your conversions.