Creating Tournaments

This guide walks you through creating a tournament from initial setup to opening registration.

Prerequisites

You need the Tournament Organizer role or higher to create tournaments. Contact your administrator if you don’t have access.

Creating a Tournament

Navigate to Tournaments

Go to the Tournaments page and click Create Tournament.

Enter Basic Information

Fill in the required tournament details:

Tournament Name: A clear, descriptive name
Description: Optional detailed information about your tournament
Start Date & Time: When the tournament should begin
Auto Start: Enable to automatically start at scheduled time

Configure Match Options

Set default match configuration for all tournament matches:

Core Settings

Match Type: Competitive, Wingman, or Premier
Map Pool: Select available maps
Map Veto: Enable/disable map veto phase

Advanced Options

View All Match Options

Knife Round: Enable for side selection
Overtime: Enable MR3 overtime
Coaches: Allow coaches in match
Default Models: Force default player models
Number of Substitutes: 0-2 subs per team
TV Delay: Broadcast delay (0-120 seconds)
Timeout Settings: Who can call tactical timeouts
Tech Timeout Settings: Who can call technical timeouts
Region Settings: Server region preferences
Check-in Settings: Who must check in
Ready Settings: Who can ready up

Create Tournament

Click Create Tournament to save. You’ll be redirected to the tournament page in Setup status.

Example: Tournament Creation Form

Here’s how the tournament creation is handled in the codebase:

<template>
  <form @submit.prevent="updateCreateTournament" class="grid gap-4">
    <FormField v-slot="{ componentField }" name="name">
      <FormItem>
        <FormLabel>Tournament Name</FormLabel>
        <FormControl>
          <Input v-bind="componentField" />
        </FormControl>
        <FormMessage />
      </FormItem>
    </FormField>

    <FormField v-slot="{ componentField }" name="description">
      <FormItem>
        <FormLabel>Description</FormLabel>
        <FormControl>
          <Input v-bind="componentField" />
        </FormControl>
      </FormItem>
    </FormField>

    <FormField v-slot="{ componentField }" name="start">
      <FormItem>
        <FormLabel>Start Date & Time</FormLabel>
        <FormControl>
          <div class="flex">
            <Popover>
              <PopoverTrigger as-child>
                <Button variant="outline" class="w-[280px]">
                  <CalendarIcon class="mr-2 h-4 w-4" />
                  {{ startDate || 'Pick a date' }}
                </Button>
              </PopoverTrigger>
              <PopoverContent>
                <Calendar v-model="startDate" />
              </PopoverContent>
            </Popover>
            <Input type="time" v-model="startTime" />
          </div>
        </FormControl>
      </FormItem>
    </FormField>

    <FormField v-slot="{ value, handleChange }" name="auto_start">
      <FormItem>
        <div class="flex items-center justify-between">
          <FormLabel>Auto Start</FormLabel>
          <Switch :model-value="value" @update:model-value="handleChange" />
        </div>
        <FormDescription>
          Automatically start tournament at scheduled time
        </FormDescription>
      </FormItem>
    </FormField>

    <Button type="submit">Create Tournament</Button>
  </form>
</template>

The tournament will be created in Setup status. You’ll need to add stages before opening registration.

Adding Tournament Stages

After creating the tournament, you need to add at least one stage:

Add Stage

On the tournament overview, click Add Stage to create the first stage.

Configure Stage Format

Select the tournament format for this stage:

Swiss
Round Robin
Single Elimination
Double Elimination

Team Range: 10-64 teams (must be even)
Best Of: Default match format (BO1, BO3, BO5)
Round Configuration: Set best-of for specific match types

Set Team Count

Specify minimum and maximum teams for this stage:

Min Teams: Minimum required to start
Max Teams: Maximum allowed in stage

For elimination formats, brackets are sized to the next power of 2. A max of 12 teams will create a 16-team bracket with 4 byes.

Configure Groups (Optional)

For formats that support groups:

Number of Groups: Split teams into parallel groups
Teams are distributed evenly across groups
Each group runs independently

Advanced Stage Settings

Expand Advanced Settings to override tournament defaults:

Stage-Specific Overrides

TV Delay: Different delay for this stage
Region Settings: Stage-specific server regions
Check-in Settings: Custom check-in requirements
Ready Settings: Different ready-up rules
Tech Timeout Settings: Stage-specific timeout rules

Save Stage

Click Create Stage. The stage will be added to your tournament.

Stage Configuration Example

Here’s the TypeScript interface for stage configuration:

interface TournamentStageConfig {
  stage_type: 'Swiss' | 'RoundRobin' | 'SingleElimination' | 'DoubleElimination';
  groups: number;              // Number of parallel groups
  min_teams: number;           // Minimum teams required
  max_teams: number;           // Maximum teams allowed
  default_best_of: number;     // Default match format (1, 3, or 5)
  third_place_match?: boolean; // SE only: enable 3rd place match
  decider_best_of?: number;    // Best-of for 3rd place match
  settings?: {
    round_best_of?: Record<string, number>; // Per-round overrides
  };
}

Multi-Stage Tournament Example

Create a tournament with multiple stages for complex progression:

Stage 1: Swiss

{
  stage_type: 'Swiss',
  groups: 1,
  min_teams: 32,
  max_teams: 64,
  default_best_of: 1
}

All teams start here. Top 16 advance to playoffs.

Stage 2: Single Elimination

{
  stage_type: 'SingleElimination',
  groups: 1,
  min_teams: 16,
  max_teams: 16,
  default_best_of: 3,
  third_place_match: true,
  settings: {
    round_best_of: {
      'WB:4': 5  // Grand Final is BO5
    }
  }
}

Top 16 from Swiss compete in BO3 bracket, with BO5 grand final.

Round-Specific Best-Of Configuration

For elimination tournaments, you can configure different best-of settings per round:

Single Elimination
Double Elimination
Swiss

settings: {
  round_best_of: {
    'WB:1': 1,  // Round 1: BO1
    'WB:2': 1,  // Round 2: BO1  
    'WB:3': 3,  // Semifinals: BO3
    'WB:4': 5   // Grand Final: BO5
  }
}

settings: {
  round_best_of: {
    'WB:1': 1,  // Winners Round 1: BO1
    'WB:2': 3,  // Winners Round 2: BO3
    'LB:1': 1,  // Losers Round 1: BO1
    'LB:2': 1,  // Losers Round 2: BO1
    'LB:3': 3,  // Losers Semifinals: BO3
    'GF': 5     // Grand Final: BO5
  }
}

settings: {
  round_best_of: {
    'regular': 1,       // Regular rounds: BO1
    'advancement': 3,   // Advancement matches: BO3
    'elimination': 3    // Elimination matches: BO3
  }
}

Opening Registration

Once your tournament is configured:

Review Configuration

Double-check all tournament and stage settings.

Open Registration

Click the Settings button → Open RegistrationTournament status changes to Registration Open and teams can join.

Monitor Teams

Watch teams register on the Teams tab. You can:

Manually add teams
Remove teams
Edit team rosters
Assign seed positions

Close Registration

When ready, click Settings → Close RegistrationStatus changes to Registration Closed. Finalize seeding before starting.

Starting the Tournament

Once started, tournaments cannot be reconfigured. Ensure all settings are correct before starting.

Verify Teams

Ensure you have at least the minimum number of teams required.

Finalize Seeding

Set team seeds on the Teams tab if using manual seeding.

Start Tournament

Click Settings → Start Tournament

Status changes to Live
Brackets are automatically generated
Initial matches are created

Tournament State Management

The tournament status is managed through GraphQL mutations:

async function updateTournamentStatus(tournamentId: string, status: TournamentStatus) {
  await apolloClient.mutate({
    mutation: gql`
      mutation UpdateTournamentStatus($id: uuid!, $status: e_tournament_status_enum!) {
        update_tournaments_by_pk(
          pk_columns: { id: $id }
          _set: { status: $status }
        ) {
          id
          status
        }
      }
    `,
    variables: { id: tournamentId, status }
  });
}

Discord Notifications

Enable Discord notifications for automatic match updates:

Enable Notifications

In tournament settings, toggle Discord Notifications.

Configure Webhook

On the Notifications tab:

Add Discord webhook URL
Optional: Add role ID to ping
Select which events to notify

Test Notifications

Send a test notification to verify configuration.

Best Practices

Team Count Planning

For Swiss: Use even numbers (10, 12, 14, etc.)
For Elimination: Plan for bracket size (8, 16, 32, 64)
For Round Robin: Keep groups small (4-8 teams max)
Set min_teams slightly below max_teams for flexibility

Best-Of Configuration

Use BO1 for early rounds to save time
Increase to BO3 for semifinals/finals
Reserve BO5 for grand finals only
Consider total match time when planning

Multi-Stage Progression

Clearly communicate advancement criteria
Ensure stage team counts align (Stage 1 max ≥ Stage 2 min)
Test progression with smaller tournaments first
Have clear tiebreaker rules

Registration Period

Open registration at least 2-3 days before start
Close registration 1-2 hours before start
Allow time for seeding and final checks
Communicate deadlines clearly to teams

Troubleshooting

Cannot create tournament

Verify you have Tournament Organizer role or higher
Check that start time is in the future
Ensure all required fields are filled

Cannot add stage

Verify tournament is in Setup status
Check team count constraints for format
Ensure groups number is valid

Cannot open registration

Tournament must have at least one stage
Verify stage configuration is complete
Check that tournament is in Setup status

Cannot start tournament

Ensure minimum teams are registered
Registration must be closed
All stages must be properly configured

Next Steps

Tournament Formats

Learn about each tournament format in detail

Managing Teams

Add, remove, and seed teams

Bracket Visualization

Understand bracket display and navigation

Match Scheduling

Schedule matches and manage tournament flow

Get Started

User Guide

Matches

Tournaments

Server Management

Administration

Creating Tournaments

Prerequisites

Creating a Tournament

Core Settings

Advanced Options

Example: Tournament Creation Form

Adding Tournament Stages

Stage Configuration Example

Multi-Stage Tournament Example

Round-Specific Best-Of Configuration

Opening Registration

Starting the Tournament

Tournament State Management

Discord Notifications

Best Practices

Troubleshooting

Next Steps

Tournament Formats

Managing Teams

Bracket Visualization

Match Scheduling

Build docs developers (and LLMs) love

Get Started

User Guide

Matches

Tournaments

Server Management

Administration

​Prerequisites

​Creating a Tournament

​Core Settings

​Advanced Options

​Example: Tournament Creation Form

​Adding Tournament Stages

​Stage Configuration Example

​Multi-Stage Tournament Example

​Round-Specific Best-Of Configuration

​Opening Registration

​Starting the Tournament

​Tournament State Management

​Discord Notifications

​Best Practices

​Troubleshooting

​Next Steps

Tournament Formats

Managing Teams

Bracket Visualization

Match Scheduling

Build docs developers (and LLMs) love

Prerequisites

Creating a Tournament

Core Settings

Advanced Options

Example: Tournament Creation Form

Adding Tournament Stages

Stage Configuration Example

Multi-Stage Tournament Example

Round-Specific Best-Of Configuration

Opening Registration

Starting the Tournament

Tournament State Management

Discord Notifications

Best Practices

Troubleshooting

Next Steps