---
title: 'How to Build an Event Management System in Airtable'
description: 'Build a complete Airtable event management system — registration forms, RSVP tracking, session scheduling, vendor and budget management, QR check-in, and automated confirmations and reminders.'
canonical_url: 'https://www.business-automated.com/tutorials/airtable-event-management-system'
md_url: 'https://www.business-automated.com/tutorials/airtable-event-management-system.md'
last_updated: 2026-06-11
---

Event teams end up in a familiar mess: registrations in Eventbrite, the run-of-show in a spreadsheet, vendor contracts in email, the budget in another spreadsheet, and survey results in Google Forms. Nothing links, so nobody can answer "who's confirmed, what's it costing, and are we ready?" without opening five tabs. [Airtable](/airtable-consultant) fixes this by putting registration, attendees, sessions, vendors, budget, and surveys in one relational base — with automations doing the confirmations and reminders your team currently does by hand.

This guide is the complete build. If you only need a simple registration form, start with our [Airtable forms guide](/tutorials/how-to-create-airtable-forms) — this tutorial assumes you want the whole event management system.

## When Airtable Wins (and When a Dedicated Event Platform Wins)

Be honest about the fit before you build.

**Airtable wins when:**

- Your events are **free or invitation-based** — internal events, community meetups, workshops, client dinners, webinars. No ticketing fees, full data ownership.
- You need **operations, not just registration** — vendors, budgets, run-of-show, tasks, and attendees in one place. No event platform does the back office well.
- You run **many small-to-mid events per year** and want one reusable system instead of per-event platform fees.
- You want **custom fields and workflows** — approval steps, member-only pricing logic, sponsor tracking — that ticketing platforms don't model.

**A dedicated platform wins when:**

- You're **selling tickets to the public**. Airtable has no native payments or ticketing. Eventbrite charges 3.7% + $1.79 per ticket plus 2.9% payment processing (about 15.5% of a $20 ticket, and as of 2026 there's no fee cap), but it gives you checkout, refunds, and marketplace discovery you can't replicate. Luma's free plan takes 5% of paid tickets; Luma Plus ($59/month billed annually) drops that to 0% and unlocks Zapier and API access.
- You run **large conferences** needing a mobile attendee app, badge printing at scale, and exhibitor management — that's Whova (roughly $2K–15K+ per event) or Cvent (quote-only; median annual contracts around $19.5K) territory.
- You need **hard capacity enforcement at checkout** — Airtable forms can't refuse the 101st registration on their own (we'll cover the workarounds).

The pattern we deploy most for clients: **a ticketing front door (Eventbrite, Luma, or Stripe) synced into an Airtable back office.** Registration happens where payments work; everything else happens in Airtable. We'll show the sync in Step 8.

## Step 1: Schema

Seven tables. The crucial design decision is the Registrations junction table — don't link Attendees directly to Events, or you'll lose per-event status the moment someone attends a second event. (Background: [junction tables explained](/tutorials/airtable-junction-tables-many-to-many).)

| Table | Purpose |
| --- | --- |
| **Events** | One record per event (or per occurrence of a recurring event) |
| **Attendees** | People, deduplicated by email — your long-term audience list |
| **Registrations** | Junction: one Attendee at one Event, with RSVP status |
| **Sessions** | Talks, workshops, agenda blocks within an event |
| **Vendors** | Caterers, venues, AV, printers — and their per-event engagements |
| **Budget Items** | Planned vs. actual line items per event |
| **Survey Responses** | Post-event feedback linked to Registrations |

### Events fields

| Field | Type | Purpose |
| --- | --- | --- |
| Event Name | Single line text | Primary field |
| Status | Single select | Planning / Announced / Open / Sold Out / In Progress / Completed / Cancelled |
| Event Date | Date | Start date/time |
| End Date | Date | For multi-day events |
| Venue | Linked record (Vendors) | Or single line text for virtual links |
| Format | Single select | In-Person / Virtual / Hybrid |
| Capacity | Number | Maximum attendees |
| Registration Count | Rollup/Count (Registrations) | Confirmed + Registered only |
| Spots Left | Formula | `{Capacity} - {Registration Count}` |
| Budget | Currency | Approved budget |
| Actual Spend | Rollup (Budget Items) | SUM of actuals |
| Owner | Collaborator | Lead organizer |

### Attendees fields

| Field | Type | Purpose |
| --- | --- | --- |
| Full Name | Single line text | Primary field |
| Email | Email | Dedupe key |
| Company | Single line text | For badges |
| Registrations | Linked records | Their event history |
| Events Attended | Count (Registrations, Attended only) | Engagement scoring |

### Registrations fields

| Field | Type | Purpose |
| --- | --- | --- |
| Registration ID | Formula | `{Event Name} & " – " & {Attendee Name}` via lookups |
| Event | Linked record (Events) | One event |
| Attendee | Linked record (Attendees) | One person |
| RSVP Status | Single select | Registered / Confirmed / Waitlist / Cancelled / Attended / No-Show |
| Ticket Type | Single select | General / VIP / Speaker / Sponsor / Staff |
| Dietary Needs | Multiple select | Vegetarian / Vegan / GF / Allergies |
| Registered At | Created time | First-come ordering for waitlists |
| QR Code | Formula | QR image URL (Step 7) |
| Checked In | Checkbox | Flipped at the door |
| Check-In Time | Last modified time (Checked In only) | Arrival analytics |
| Confirmation Sent | Checkbox | Automation guard |
| Reminder Sent | Checkbox | Automation guard |

## Step 2: The Registration Form

Build a form on the **Registrations** table, not the Attendees table — a registration is the thing being created.

1. Show: name, email, ticket type, dietary needs, and the Event as a linked-record picker (limit selectable records to a view filtered to `Status = Open`).
2. For single-event forms, **prefill and hide the Event field** via URL parameters (`?prefill_Event=...&hide_Event=true`). One form serves every event — just change the link. Note prefill URLs are bound by URL length limits (keep them under roughly 2,000 characters to be safe across browsers) and don't work for attachment fields.
3. Hidden prefilled fields also let you track sources: a `?prefill_Source=Newsletter` link tells you which channel drove the registration.

One wrinkle: the form captures the attendee's name and email as text on the Registration, but you want a linked, deduplicated Attendee record. Fix it with an automation — **when a Registration is created**, find Attendees matching the submitted email; if found, link it; if not, create the Attendee then link it. (A short script handles the find-or-create cleanly; a two-automation pattern works without code.)

If registrants need to edit their RSVP later, see [updating existing records via forms](/tutorials/airtable-form-update-existing-record).

## Step 3: Capacity and Waitlists

This is Airtable's weakest spot for events, so handle it deliberately. A native Airtable form **will not stop accepting submissions when the event is full**. Your options, in increasing order of rigor:

1. **Soft cap with auto-waitlist (native).** When a Registration is created, the automation checks the event's `{Spots Left}`. If it's 0 or less, set RSVP Status to Waitlist instead of Registered, and send a "you're on the waitlist" email rather than a confirmation. Registrants always get an honest answer; the form just doesn't refuse them up front.
2. **Promote from waitlist.** When a Registration changes to Cancelled, find the oldest Waitlist record (sort by Registered At) for that event, flip it to Registered, and email the attendee. This is the automation clients thank us for most.
3. **Manual form swap.** When `Spots Left = 0`, an automation alerts the organizer, who swaps the live link to a "registration closed" form. Crude but reliable for one-off events.
4. **Hard enforcement (third-party forms).** Tools like Fillout validate against live Airtable rollups before accepting a submission — the only way to truly block registration number 101 at submit time.

## Step 4: Confirmation and Reminder Automations

This is where Airtable stops being a database and starts being an event system. Four automations cover 90% of event communication. (Foundations: [Airtable automation guide](/tutorials/airtable-automation-guide); email patterns: [Airtable email automation](/tutorials/airtable-email-automation-guide).)

### Automation 1: Instant confirmation

1. **Trigger:** When a Registration is created and `RSVP Status = Registered`.
2. **Action:** Send email to the attendee — event name, date, venue, calendar link, QR code.
3. **Action:** Check `Confirmation Sent`.

Add a condition that `Confirmation Sent` is unchecked so the automation can never double-send.

### Automation 2: Seven-day reminder

1. **Trigger:** Scheduled, daily at 8 AM.
2. **Find records:** Registrations where the event date is exactly 7 days out, status is Registered or Confirmed, and `Reminder Sent` is unchecked. (Use a lookup of the event date and a formula like `DATETIME_DIFF({Event Date}, TODAY(), 'days') = 7` — more patterns in our [date formulas guide](/tutorials/airtable-date-formulas).)
3. **Action:** Send the reminder; check `Reminder Sent`.

Clone it for a day-before reminder with parking, agenda, and check-in instructions — the single biggest lever on attendance rates we see.

### Automation 3: Organizer alerts

Scheduled daily: find Events where `Spots Left <= 5` and status is Open, then Slack or email the owner. Catching "almost sold out" early lets you open a waitlist or a bigger room while it still matters.

### Automation 4: No-show follow-up

The morning after the event, find Registrations still in Confirmed (never checked in), flip them to No-Show, and send a "sorry we missed you" email with the recording or next event link. Recovered no-shows are the cheapest re-engagement you'll ever run.

Mind the platform limits: each base allows **50 automations**, and runs are metered monthly by plan — fine for most event programs, but a 5,000-person conference emailing through Airtable will chew through runs. At that scale, batch the sends through Make or an email platform.

## Step 5: Session Scheduling

For anything beyond a single-track meetup, model the agenda in a **Sessions** table:

| Field | Type | Purpose |
| --- | --- | --- |
| Session Title | Single line text | Primary field |
| Event | Linked record (Events) | Parent event |
| Start / End Time | Date (with time) | Schedule |
| Room | Single select | Track/location |
| Speaker | Linked record (Attendees) | Speakers are attendees too |
| Session Capacity | Number | For breakout sign-ups |
| Description | Long text | For the published agenda |

Two views make this table sing:

- **Timeline view** grouped by Room — your run-of-show, with overlapping sessions instantly visible. Drag to reschedule.
- **Calendar view** on Start Time for the at-a-glance agenda.

If attendees pick breakout sessions, add a `Session Signups` junction table (Registration ↔ Session) and reuse the Step 3 capacity pattern per session.

## Step 6: Vendors and Budget

The part no ticketing platform handles — and the reason event teams keep a "real" system behind Eventbrite.

**Vendors table:** Vendor Name, Category (Venue / Catering / AV / Print / Speaker / Other), Contact, Email, Phone, Contract (attachment), Status (Researching / Quoted / Booked / Paid), Events (linked), Notes. Group a grid view by Category; filter a "Chase list" view to `Status = Quoted`.

**Budget Items table:**

| Field | Type | Purpose |
| --- | --- | --- |
| Line Item | Single line text | Primary field |
| Event | Linked record (Events) | Parent |
| Category | Single select | Venue / F&B / AV / Marketing / Staff / Misc |
| Vendor | Linked record (Vendors) | Who's billing you |
| Estimated | Currency | Planned cost |
| Actual | Currency | Invoiced cost |
| Variance | Formula | `{Estimated} - {Actual}` |
| Paid | Checkbox | AP tracking |

Roll up `SUM(Actual)` to the Event as Actual Spend, and add a Budget Health formula on Events: `IF({Actual Spend} > {Budget}, "🔴 Over", IF({Actual Spend} > {Budget} * 0.9, "🟡 Watch", "🟢 OK"))`. An automation that pings the owner when a budget tips red replaces the end-of-event invoice surprise.

## Step 7: Check-In Day (QR Codes)

Generate a QR code per registration with a formula field calling a QR image API, encoding the record ID:

```airtable
"https://quickchart.io/qr?size=300&text=" & RECORD_ID()
```

Drop that image into the confirmation email and onto printed badges. Then, at the door:

- **Small events:** the Airtable mobile app's built-in scanner feeds the search bar — scan the badge, the registration record appears, tap, tick `Checked In`. Note the barcode field type doesn't work in forms or desktop browsers, so check-in is a mobile-app workflow.
- **Bigger events:** a scanning interface or miniExtensions processes a scan per second with no record-tapping. We built a full walkthrough of this pattern in [custom interfaces with QR code scanning](/tutorials/airtable-custom-interfaces-qr-code-scanning).

A "Door List" grid view — filtered to the event, grouped by RSVP Status, sorted by last name, with `Checked In` as the first field — is the manual fallback when someone forgets their QR code. It will happen.

## Step 8: Syncing Eventbrite, Luma, or Zoom

When ticketing lives elsewhere, sync it in rather than maintaining two lists by hand:

1. **Eventbrite → Airtable:** Zapier's "New Attendee Registered" trigger creates a Registration record; a find-record step on email prevents duplicate Attendees. Add a second Zap on the "Updated Attendee" trigger, filtered to cancelled status, to flip RSVP Status to Cancelled automatically — there's no dedicated cancellation trigger. (Setup details: [automate Airtable with Zapier](/tutorials/automate-airtable-with-zapier-guide).)
2. **Luma → Airtable:** same pattern — but note Zapier/API access requires Luma Plus.
3. **Zoom webinars:** sync registrants in, and push attendance data back after the event to mark Attended vs. No-Show without manual reconciliation.

Airtable stays the source of truth for operations; the ticketing platform remains the source of truth for money.

## Step 9: Post-Event Surveys

Close the loop in the same base:

1. **Survey Responses table:** Registration (linked), Overall Rating (1–5), NPS (0–10), Best Session, What to Improve (long text), Would Attend Again (checkbox).
2. **Form with prefill:** build the form on Survey Responses and prefill the Registration link per attendee, so every response ties to a real person and event — no anonymous-spreadsheet matching afterward.
3. **Automation:** the morning after the event, find Registrations with `RSVP Status = Attended` and email each their personal survey link. Send within 24 hours; response rates fall off a cliff after that.
4. **Report:** roll up average rating and NPS to the Event record. After three events you have trend data no standalone survey tool would have linked for you.

## Views and Interfaces

Give each role its own lens instead of one giant grid:

- **Event Command Center (Interface):** per-event dashboard — registration count vs. capacity (progress bar), budget health, session timeline, open vendor items. Built in Interface Designer; see our [interface designer guide](/tutorials/airtable-interface-designer-guide).
- **Check-In interface:** big search box, attendee list, one-tap check-in button for door staff who've never seen Airtable.
- **Registrations Kanban** grouped by RSVP Status — drag from Waitlist to Registered as spots open.
- **Events Calendar** colored by Status for the program-level view.
- **My Tasks per organizer** if you add an event task checklist table.

## Comparison: Airtable vs. Dedicated Event Platforms

| Factor | Airtable | Eventbrite | Luma | Cvent/Whova |
| --- | --- | --- | --- | --- |
| Cost | $20–$45/seat/mo | 3.7% + $1.79/ticket + 2.9% processing | Free (5% paid-ticket fee) or $59/mo Plus | ~$2K–15K+/event; quote-only |
| Payments/ticketing | Via Stripe/integration | Native | Native | Native |
| Vendor + budget management | Native, fully custom | No | No | Partial (enterprise) |
| Capacity/waitlist enforcement | Workaround or form add-on | Native | Native | Native |
| Attendee mobile app | No | Basic | Basic | Yes (conference-grade) |
| Custom data model | Unlimited | No | No | Limited |
| Best for | Free/internal events + ops back office | Paid public tickets | Community events | Large conferences |

The honest summary: Airtable is the best **event operations system** and a perfectly good **registration system for free events**. It is not a ticketing platform — don't fight that; integrate it.

## Common Mistakes

**Linking Attendees straight to Events.** Without the Registrations junction table, a repeat attendee's second event overwrites the context of their first. Fix it on day one; migrating later is painful.

**No automation guards.** A reminder automation without a `Reminder Sent` checkbox will eventually double-email your entire list. Every send needs a guard field and a condition.

**Trusting the form to enforce capacity.** It won't. Build the waitlist automation or use a validating form tool before launch, not after the venue is oversold.

**One-off bases per event.** Rebuilding per event throws away your attendee history — the most valuable asset the system produces. One base, many Event records.

**Skipping the survey link prefill.** Anonymous surveys can't tell you whether VIPs or first-timers were unhappy. Prefilled links cost five minutes and make feedback segmentable.

## Troubleshooting

**Confirmation emails landing in spam.** Native automation emails come from Airtable's domain. For external audiences, send via a Gmail/Outlook automation action or an email platform with your own domain.

**Registration count doesn't match reality.** The rollup is counting Cancelled or Waitlist records — add a condition so only Registered/Confirmed/Attended count.

**Duplicate attendees.** The find-or-create automation matches on exact email; trailing spaces and case break it. Normalize with `LOWER(TRIM({Email}))` in the matching formula.

**QR scan finds nothing at the door.** The scanner searches visible fields in the current view — make sure the encoded value (record ID or registration ID) is a visible field, and you're scanning from the table, not a filtered view that excludes the record.

**Hit the 50-automation ceiling.** Consolidate per-event automations into generic ones driven by record data (one reminder automation for all events, not one per event).

## Next Steps

Run one real event through the system before adding anything fancy — the gaps you find at the door teach you more than another week of base design. Then the natural extensions:

- **Recurring event templates** — a button automation that clones an event with its sessions, budget skeleton, and task checklist (see [recurring tasks and reminders](/tutorials/airtable-recurring-tasks-reminders)).
- **Sponsor pipeline** — sponsors are just Deals; bolt on a lightweight pipeline.
- **Paid tickets** — Stripe checkout links generated from Airtable for member pricing without Eventbrite's percentage.

If you're scoping an event operations build with real volume — multi-event programs, synced ticketing, conference check-in — that's exactly the kind of system we build for clients. [Get in touch](/contact).


## Sitemap

See the full [sitemap](/sitemap.md) for all pages.