# How to Build a Conference Management System with V0
- Tool: v0
- Difficulty: Advanced
- Compatibility: V0 Premium recommended, Supabase free tier, Stripe account
- Last updated: April 2026
## TL;DR
Build a conference management system with multi-track schedule grids, tiered ticket sales through Stripe, QR code check-in, and speaker profiles. V0 generates the Next.js App Router pages while Supabase enforces non-overlapping sessions per track using exclusion constraints with tstzrange and GiST indexes.
## Before you start
- A V0 account (Premium recommended for multi-file generation)
- A Supabase project with btree_gist extension enabled
- A Stripe account with Checkout enabled
- Basic familiarity with Next.js App Router and TypeScript
## Step-by-step guide
### 1. Create the Supabase Schema with Exclusion Constraints
*Exclusion constraints with tstzrange prevent scheduling two sessions in the same track at overlapping times at the database level, making it impossible to create conflicting schedules regardless of application bugs.*
Set up the full conference schema with tracks, sessions, speakers, tickets, and registrations. Enable the btree_gist extension required for exclusion constraints, then create the constraint that enforces non-overlapping sessions per track.
```
-- Enable required extension
create extension if not exists btree_gist;
-- Conferences
create table conferences (
id uuid primary key default gen_random_uuid(),
organizer_id uuid references auth.users not null,
name text not null,
slug text unique not null,
description text,
venue jsonb default '{}',
starts_at timestamptz not null,
ends_at timestamptz not null,
status text default 'draft',
created_at timestamptz default now()
);
-- Tracks
create table tracks (
id uuid primary key default gen_random_uuid(),
conference_id uuid references conferences on delete cascade not null,
name text not null,
color text default '#3B82F6',
sort_order int default 0
);
-- Sessions with exclusion constraint
create table sessions (
id uuid primary key default gen_random_uuid(),
track_id uuid references tracks on delete cascade not null,
conference_id uuid references conferences on delete cascade not null,
title text not null,
description text,
starts_at timestamptz not null,
ends_at timestamptz not null,
room text,
capacity int default 100,
registered_count int default 0,
-- Prevent overlapping sessions in the same track
exclude using gist (
track_id with =,
tstzrange(starts_at, ends_at) with &&
)
);
-- Speakers
create table speakers (
id uuid primary key default gen_random_uuid(),
name text not null,
bio text,
company text,
avatar_url text,
social_links jsonb default '{}'
);
-- Session-Speaker junction
create table session_speakers (
session_id uuid references sessions on delete cascade,
speaker_id uuid references speakers on delete cascade,
primary key (session_id, speaker_id)
);
-- Tickets
create table tickets (
id uuid primary key default gen_random_uuid(),
conference_id uuid references conferences on delete cascade not null,
tier text not null,
price numeric not null,
capacity int not null,
sold_count int default 0,
stripe_price_id text
);
-- Registrations
create table registrations (
id uuid primary key default gen_random_uuid(),
conference_id uuid references conferences not null,
user_id uuid references auth.users not null,
ticket_id uuid references tickets not null,
stripe_payment_intent_id text,
qr_code text unique,
checked_in boolean default false,
checked_in_at timestamptz,
created_at timestamptz default now()
);
-- Session RSVPs
create table session_registrations (
registration_id uuid references registrations on delete cascade,
session_id uuid references sessions on delete cascade,
primary key (registration_id, session_id)
);
-- RLS
alter table conferences enable row level security;
alter table tracks enable row level security;
alter table sessions enable row level security;
alter table speakers enable row level security;
alter table session_speakers enable row level security;
alter table tickets enable row level security;
alter table registrations enable row level security;
alter table session_registrations enable row level security;
-- Public read for conference content
create policy "Public read conferences" on conferences for select using (true);
create policy "Public read tracks" on tracks for select using (true);
create policy "Public read sessions" on sessions for select using (true);
create policy "Public read speakers" on speakers for select using (true);
create policy "Public read session_speakers" on session_speakers for select using (true);
create policy "Public read tickets" on tickets for select using (true);
create policy "Users read own registrations" on registrations for select using (auth.uid() = user_id);
create policy "Users read own session regs" on session_registrations for select
using (registration_id in (select id from registrations where user_id = auth.uid()));
```
**Expected result:** Database schema created with exclusion constraint preventing overlapping sessions per track. All tables have RLS enabled with public read for conference content.
### 2. Build the Multi-Track Schedule Grid
*The schedule grid is the centerpiece of any conference app. Positioning sessions as absolute blocks within a CSS Grid timeline gives attendees a clear visual of what is happening across all tracks simultaneously.*
Create the public schedule page that renders tracks as columns and time as the vertical axis. Each session is positioned using calculated top and height values based on its start and end times relative to the conference day. Use prompt queuing in V0 to generate the grid layout first, then add the session detail dialog.
```
// app/conference/[slug]/schedule/page.tsx
import { createClient } from '@/lib/supabase/server';
import { Card } from '@/components/ui/card';
import { Badge } from '@/components/ui/badge';
import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogTrigger } from '@/components/ui/dialog';
import { Avatar, AvatarFallback, AvatarImage } from '@/components/ui/avatar';
const HOUR_HEIGHT = 80; // pixels per hour
const START_HOUR = 8; // 8 AM
const END_HOUR = 18; // 6 PM
function getPosition(startTime: string, endTime: string, dayStart: Date) {
const start = new Date(startTime);
const end = new Date(endTime);
const startOffset = (start.getTime() - dayStart.getTime()) / (1000 * 60 * 60);
const duration = (end.getTime() - start.getTime()) / (1000 * 60 * 60);
return {
top: (startOffset - START_HOUR) * HOUR_HEIGHT,
height: duration * HOUR_HEIGHT,
};
}
export default async function SchedulePage({
params,
}: {
params: Promise<{ slug: string }>;
}) {
const { slug } = await params;
const supabase = await createClient();
const { data: conference } = await supabase
.from('conferences')
.select('*')
.eq('slug', slug)
.single();
if (!conference) return
at {new Date(result.registration.checked_in_at).toLocaleTimeString()}
)}
{result?.status === 'not_found' && (
Not Found
No registration with this code
)}
);
}
```
**Expected result:** A check-in page that validates QR codes against registrations and shows success, already-checked-in, or not-found states with clear visual feedback.
### 5. Wire Up Environment Variables and Deploy
*Proper environment variable management keeps your Stripe keys secure while ensuring the webhook endpoint and Checkout redirect URLs work correctly in production.*
Set all required environment variables in V0's Vars tab. Register the production webhook URL in Stripe Dashboard. Use prompt queuing in V0 to generate the registration flow, admin dashboard, and check-in scanner as separate focused prompts.
```
// Environment variables to set in V0's Vars tab:
// STRIPE_SECRET_KEY=sk_live_...
// STRIPE_WEBHOOK_SECRET=whsec_...
// NEXT_PUBLIC_SUPABASE_URL=https://xxx.supabase.co
// NEXT_PUBLIC_SUPABASE_ANON_KEY=eyJ...
// SUPABASE_SERVICE_ROLE_KEY=eyJ...
// NEXT_PUBLIC_APP_URL=https://your-app.vercel.app
// Helper: increment ticket sold count (Supabase function)
// Run in Supabase SQL editor:
//
// create or replace function increment_ticket_sold(p_ticket_id uuid)
// returns void as $$
// begin
// update tickets set sold_count = sold_count + 1
// where id = p_ticket_id and sold_count < capacity;
// end;
// $$ language plpgsql;
// app/conference/[slug]/register/page.tsx
import { createClient } from '@/lib/supabase/server';
import { Card, CardContent, CardFooter, CardHeader, CardTitle } from '@/components/ui/card';
import { Badge } from '@/components/ui/badge';
import { CheckoutButton } from './checkout-button';
export default async function RegisterPage({
params,
}: {
params: Promise<{ slug: string }>;
}) {
const { slug } = await params;
const supabase = await createClient();
const { data: conference } = await supabase
.from('conferences')
.select('*')
.eq('slug', slug)
.single();
if (!conference) return