# How to build event registration in Bubble

- Tool: Bubble
- Difficulty: Beginner
- Time required: 25-30 min
- Compatibility: All Bubble plans
- Last updated: March 2026

## TL;DR

An event registration system in Bubble uses Event, Registration, and Ticket data types to manage event creation, attendee signup with custom fields, capacity limits with automatic waitlisting, confirmation emails, and an organizer dashboard for managing attendees. This tutorial covers the complete flow from event setup to check-in.

## Overview: Building an Event Registration System in Bubble

This tutorial shows how to build a complete event registration system. Organizers create events with custom fields, attendees register through a public form, capacity is managed with waitlisting, and organizers manage their attendee lists from a dashboard.

## Before you start

- A Bubble app with user authentication
- Basic understanding of Data Types and Workflows
- Familiarity with Repeating Groups
- Optional: email sending plugin for confirmations

## Step-by-step guide

### 1. Create the event registration data model

Create these Data Types. Event: title (text), description (text), organizer (User), date (date), location (text), capacity (number), registered_count (number default 0), waitlist_count (number default 0), status (text: Draft, Open, Closed, Cancelled), registration_deadline (date), custom_fields (list of texts). Registration: event (Event), attendee_name (text), attendee_email (text), user (User), status (text: Confirmed, Waitlisted, Cancelled), registered_at (date), ticket_code (text), custom_responses (text).

**Expected result:** Data model supports events with capacity limits and registration tracking.

### 2. Build the event creation form for organizers

Create a page for organizers to create events. Add inputs for title, description, date/time, location, capacity, and registration deadline. Add a dynamic Custom Fields section where organizers can add extra questions (company name, dietary preference, etc.). Store custom field names as a list of texts on the Event. Create a workflow that saves the Event with status=Draft. Add a Publish button that sets status=Open.

**Expected result:** Organizers can create events with custom registration fields and publish them.

### 3. Create the public registration form

Build a registration page accessible via URL with the event ID. Display event details (title, date, location, remaining spots). Show registration form with attendee name, email, and dynamic custom fields generated from the event's custom_fields list. Add validation: check capacity before allowing registration. If registered_count < capacity, create Registration with status=Confirmed. If full, create with status=Waitlisted. Increment the appropriate count. Generate a unique ticket_code. Send confirmation email.

> Pro tip: Use a unique ticket_code (random 8-character string) for check-in and reference purposes.

**Expected result:** Attendees can register and receive confirmation with automatic waitlisting when full.

### 4. Build the organizer attendee management dashboard

On the organizer's event detail page, add a tab for Attendees showing a Repeating Group of Registrations filtered by event. Display attendee name, email, status, registration date, and ticket code. Add filter buttons for Confirmed and Waitlisted. Add action buttons: Cancel Registration (sets status=Cancelled, decrements count, promotes first waitlisted person), Check In (adds a checked_in flag), and Export to CSV. Show summary stats: total confirmed, waitlisted, and checked in.

**Expected result:** Organizers can view, filter, and manage all registrations for their events.

### 5. Implement waitlist promotion and notifications

When a confirmed registration is cancelled, create a backend workflow that finds the oldest waitlisted registration for that event (sorted by registered_at ascending). Change its status to Confirmed, increment registered_count, decrement waitlist_count, and send a promotion email to the attendee. Add a scheduled workflow that closes registration after the deadline by setting the event status to Closed. For complex event management with ticketing and payments, RapidDev can help build production-grade systems.

**Expected result:** Waitlisted attendees are automatically promoted when spots open up.

## Complete code example

File: `Workflow summary`

```text
EVENT REGISTRATION WORKFLOW SUMMARY
=====================================

DATA TYPES:
  Event: title, description, organizer, date, location,
    capacity, registered_count, waitlist_count, status
  Registration: event, attendee_name, email, user,
    status (Confirmed/Waitlisted/Cancelled), ticket_code

REGISTRATION FLOW:
  1. Check capacity: registered_count < capacity?
  2. YES → Create Registration (Confirmed), count +1
  3. NO → Create Registration (Waitlisted), waitlist +1
  4. Generate ticket_code
  5. Send confirmation email

CANCELLATION + PROMOTION:
  1. Set Registration status = Cancelled
  2. Decrement registered_count
  3. Find oldest Waitlisted registration
  4. Promote to Confirmed, send notification

ORGANIZER DASHBOARD:
  - Attendee list with filters
  - Check-in capability
  - Export to CSV
  - Summary statistics
```

## Common mistakes

- **Not checking capacity before creating a registration** — Without a capacity check, events can be overbooked beyond the organizer's limit Fix: Always compare registered_count to capacity before creating a Confirmed registration. Use waitlisting for overflow.
- **Using count queries instead of stored count fields** — Counting registrations with a search on every page load is slow and wastes workload units Fix: Maintain registered_count and waitlist_count on the Event record and update them in registration workflows.
- **Not handling race conditions on popular events** — Two users registering simultaneously could both get confirmed even if only one spot remains Fix: Use backend workflows for registration to serialize requests. Check capacity again inside the backend workflow before confirming.

## Best practices

- Store registration counts on the Event record for fast reads
- Use backend workflows for registration to handle concurrent signups
- Generate unique ticket codes for check-in reference
- Send confirmation emails immediately after registration
- Automatically promote waitlisted attendees when cancellations occur
- Close registration after the deadline via scheduled workflow
- Allow organizers to export attendee lists as CSV

## Frequently asked questions

### Can I add payment for paid events?

Yes. Integrate Stripe and charge during registration. Only create the Registration record after successful payment. Store the Stripe charge ID for refund handling.

### How do I implement check-in at the event?

Add a checked_in (yes/no) field to Registration. Build a check-in page where organizers search by ticket code or attendee name and click Check In to update the field.

### Can attendees cancel their own registration?

Yes. Create a My Registrations page where users can view their registrations and click Cancel. The workflow updates status and triggers waitlist promotion.

### How do I handle events with multiple ticket types?

Create a TicketType data type linked to Event with name, price, capacity, and description. Allow attendees to select a ticket type during registration.

### Can I send reminder emails before the event?

Yes. Create a scheduled backend workflow that runs 24 hours before the event date and sends reminder emails to all confirmed registrations.

### Can RapidDev help build advanced event systems?

Yes. RapidDev can build event platforms with multi-day schedules, speaker management, sponsor integration, virtual event features, and analytics.

---

Source: https://www.rapidevelopers.com/bubble-tutorial/build-an-event-registration-system-in-bubble
© RapidDev — https://www.rapidevelopers.com/bubble-tutorial/build-an-event-registration-system-in-bubble