Events · App Starter
Events Template
A working events platform — public pages, capacity-aware registration, door check-in — generated into a codebase you own.
Describe the events you run, and Dual7 generates this platform around them: public event pages, ticket types with real capacity limits, and a check-in screen that works on a phone at the door. It ships as a full-stack app in your repository — no per-ticket fee taking a cut of every registration.
- 6 core entities
- No per-ticket fees
- Code you own
- Vibe + Governed modes
01 · Data model
What's inside: the data model
An events platform is a registration ledger with a public face. This starter generates six connected entities — the public pages, the capacity math, and the door screen all read from the same tables, which is why the attendee count can't disagree with itself.
| table | what it holds |
|---|---|
events | What you're running — title, venue, schedule, description, and publish status for the public page. |
ticket_types | Admission tiers per event — general, VIP, early-bird — each with its own price, capacity, and sales window. |
registrations | The transaction: who registered, for which tickets, when, at what price, with what promo code. |
attendees | The people attached to registrations — one buyer can register four names, and each gets a check-in record. |
check_ins | Timestamped arrival records per attendee, so the door count is live and duplicates are caught at scan time. |
promo_codes | Discount and access codes with usage limits and validity windows, tracked per registration. |
02 · Screens
Signature modules
Public event pages
01Each published event gets a clean page with schedule, venue, and a registration flow — on your domain, in your branding, indexed under your name. There's no marketplace around it steering your audience toward other people's events.
Registration with real capacity
02Capacity is enforced per ticket type at the database level, so two last-minute buyers can't both take the final seat. Sold-out tiers can roll to a waitlist, and every registration records its price and promo code for clean reconciliation later.
Check-in screen
03A fast, phone-friendly door view: search or scan, tap, checked in. Arrivals are timestamped, duplicates flag instantly, and the live count on the organizer's screen is read from the same table — no morning-after export to learn who actually showed.
03 · Process
How it works
- 1You
Describe your events
Tell Dual7 what you run — one-off conferences, a monthly series, paid or free, single venue or many. The starter supplies structure; your description supplies the shape.
- 2Vibe mode
Generate and adjust in Vibe mode
Get the working platform in minutes, then tune it conversationally: add a dietary-requirements field, a session agenda, or an approval step before registration confirms. Every change lands in inspectable code.
- 3Governed mode
Publish through the governed pipeline
When registrations are real money and real people, ship through Dual7's approval gates to your own infrastructure — attendee data in your database, audit trail included.
04 · Fit
Who the Events starter is for
Organizers tired of platform fees
A percentage of every ticket is a strange price for a form, a list, and a door screen. Generate those once, run them on your infrastructure, and the per-ticket cost of your next thousand registrations rounds to zero.
Teams running a recurring series
Monthly meetups, quarterly trainings, an annual conference — recurring events deserve an owned system that accumulates history. Attendance patterns, no-show rates, and repeat-attendee lists live in your tables, queryable across every event you've ever run.
Organizations that own their attendee relationship
On a ticketing marketplace, your attendees are the platform's users first. With your own registration flow the audience list, the email relationship, and the data all belong to the organization that did the work of drawing the crowd.
Builders with a format no ticketing tool matches
Application-gated dinners, member-priced workshops, multi-venue festivals — when the registration flow is the differentiator, generic ticket pages flatten it. Here the flow is generated from your description, and the odd steps are yours to keep.
05 · Yours
Customize it, own it
Make it yours
Start from the generated shape and make it yours. Rename events to shows, workshops, or matches and the screens follow. Add fields conversationally in Vibe mode — a t-shirt size on attendees, a table assignment, an accessibility-needs prompt on registration — and the check-in screen and exports pick them up automatically.
Structural changes are just code changes: add a sessions entity for multi-track agendas, gate a ticket type behind an application review, or wire your payment provider into the registration flow. The generated app is a normal full-stack codebase with no runtime dependency on Dual7 — your team can take it anywhere the events go.
Why a starter, not a subscription
Ticketing platforms charge rent on your audience: a fee per ticket, their branding on your page, your attendee list living in their CRM. This starter inverts the deal — the registration flow, the attendee data, and the door tooling are generated as source code in your repository, deployed on your infrastructure. The economics stop scaling against your success.
You do take on running an app, and event nights are unforgiving of surprises. That's what the governed pipeline is for: approval gates so changes don't ship mid-sale, an audit trail for every modification, and regeneration when next year's format needs restructuring instead of patching.
06 · Industries
Industry versions
Nonprofit Events
Fundraising events without platform fees — sponsors, tables, and donations modeled in code your organization owns.
Venue Events
Run your rooms, not just your events — spaces, private bookings, and function sheets in code your venue owns.
School & Campus Events
Campus events without the ticketing detour — sessions, room capacity, and family registrations in code your school owns.
Events template — frequently asked questions
What do I get when I start from this events template?
A working full-stack events platform in a codebase you own: public event pages, ticket types with enforced capacity, registration with promo codes, attendee management, and a phone-friendly check-in screen. It deploys to your infrastructure with every registration in your database.
Does it charge per ticket or per registration?
No — there's no per-ticket fee anywhere, because there's no platform in the middle. You run the generated app yourself; a sold-out event costs you the same to operate as a quiet one.
Can it handle paid tickets?
The registration and pricing model is built in — ticket types carry prices, registrations record what was paid, and promo codes discount correctly. You connect your own payment provider in your code, which means payouts land in your account on your provider's terms.
How does check-in work at the door?
Staff open the check-in screen on any phone or tablet, search a name or scan a code, and tap to check in. Each check-in is timestamped per attendee, duplicates are flagged on the spot, and the organizer's live count updates from the same table.
Can I run recurring events or a series?
Yes — events are rows, not one-off sites, so a monthly series is just many events sharing your attendee history. Cross-event queries like repeat attendance and no-show rates are yours to write against your own data.
Related
Dual7 App Starters
Build your Events on your terms
A working events platform — public pages, capacity-aware registration, door check-in — generated into a codebase you own. Describe your version to start — the output is a project you own.