diff --git a/src/app/SignupCode.php b/src/app/SignupCode.php
index f66caef3..1538f03a 100644
--- a/src/app/SignupCode.php
+++ b/src/app/SignupCode.php
@@ -1,102 +1,92 @@
 <?php
 
 namespace App;
 
 use Carbon\Carbon;
 use Illuminate\Database\Eloquent\Model;
 
 /**
  * The eloquent definition of a SignupCode.
  *
  * @property datetime $expires_at
  */
 class SignupCode extends Model
 {
-    // Note: Removed '0', 'O', '1', 'I' as problematic with some fonts
-    public const SHORTCODE_CHARS   = '23456789ABCDEFGHJKLMNPQRSTUVWXYZ';
     public const SHORTCODE_LENGTH  = 5;
     public const CODE_LENGTH       = 32;
 
     // Code expires after so many hours
     public const CODE_EXP_HOURS    = 24;
 
 
     /**
      * The primary key associated with the table.
      *
      * @var string
      */
     protected $primaryKey = 'code';
 
     /**
      * Indicates if the IDs are auto-incrementing.
      *
      * @var bool
      */
     public $incrementing = false;
 
     /**
      * The "type" of the auto-incrementing ID.
      *
      * @var string
      */
     protected $keyType = 'string';
 
     /**
      * Indicates if the model should be timestamped.
      *
      * @var bool
      */
     public $timestamps = false;
 
     /**
      * The attributes that are mass assignable.
      *
      * @var array
      */
     protected $fillable = ['code', 'short_code', 'data', 'expires_at'];
 
     /**
      * The attributes that should be cast to native types.
      *
      * @var array
      */
     protected $casts = ['data' => 'array'];
 
     /**
      * The attributes that should be mutated to dates.
      *
      * @var array
      */
     protected $dates = ['expires_at'];
 
     /**
      * Check if code is expired.
      *
      * @return bool True if code is expired, False otherwise
      */
     public function isExpired()
     {
         return $this->expires_at ? Carbon::now()->gte($this->expires_at) : false;
     }
 
     /**
      * Generate a short code (for human).
      *
      * @return string
      */
     public static function generateShortCode(): string
     {
         $code_length = env('SIGNUP_CODE_LENGTH', self::SHORTCODE_LENGTH);
-        $code_chars  = env('SIGNUP_CODE_CHARS', self::SHORTCODE_CHARS);
-        $random      = [];
 
-        for ($i = 1; $i <= $code_length; $i++) {
-            $random[] = $code_chars[rand(0, strlen($code_chars) - 1)];
-        }
-
-        shuffle($random);
-
-        return implode('', $random);
+        return \App\Utils::randStr($code_length);
     }
 }
diff --git a/src/app/Utils.php b/src/app/Utils.php
index 3eb059f2..dbd23d60 100644
--- a/src/app/Utils.php
+++ b/src/app/Utils.php
@@ -1,164 +1,204 @@
 <?php
 
 namespace App;
 
 use App\Rules\UserEmailLocal;
 use Illuminate\Support\Facades\Validator;
 use Illuminate\Support\Str;
 use Ramsey\Uuid\Uuid;
 
 /**
  * Small utility functions for App.
  */
 class Utils
 {
+    // Note: Removed '0', 'O', '1', 'I' as problematic with some fonts
+    public const CHARS = '23456789ABCDEFGHJKLMNPQRSTUVWXYZ';
+
     /**
      * Provide all unique combinations of elements in $input, with order and duplicates irrelevant.
      *
      * @param array $input The input array of elements.
      *
      * @return array[]
      */
     public static function powerSet(array $input): array
     {
         $output = [];
 
         for ($x = 0; $x < count($input); $x++) {
             self::combine($input, $x + 1, 0, [], 0, $output);
         }
 
         return $output;
     }
 
+    /**
+     * Returns a random string consisting of a quantity of segments of a certain length joined.
+     *
+     * Example:
+     *
+     * ```php
+     * $roomName = strtolower(\App\Utils::randStr(3, 3, '-');
+     * // $roomName == '3qb-7cs-cjj'
+     * ```
+     *
+     * @param int $length  The length of each segment
+     * @param int $qty     The quantity of segments
+     * @param string $join The string to use to join the segments
+     *
+     * @return string
+     */
+    public static function randStr($length, $qty = 1, $join = '')
+    {
+        $chars = env('SHORTCODE_CHARS', self::CHARS);
+
+        $randStrs = [];
+
+        for ($x = 0; $x < $qty; $x++) {
+            $randStrs[$x] = [];
+
+            for ($y = 0; $y < $length; $y++) {
+                $randStrs[$x][] = $chars[rand(0, strlen($chars) - 1)];
+            }
+
+            shuffle($randStrs[$x]);
+
+            $randStrs[$x] = implode('', $randStrs[$x]);
+        }
+
+        return implode($join, $randStrs);
+    }
+
     /**
      * Returns a UUID in the form of an integer.
      *
      * @return integer
      */
     public static function uuidInt(): int
     {
         $hex = Uuid::uuid4();
         $bin = pack('h*', str_replace('-', '', $hex));
         $ids = unpack('L', $bin);
         $id = array_shift($ids);
 
         return $id;
     }
 
     /**
      * Returns a UUID in the form of a string.
      *
      * @return string
      */
     public static function uuidStr(): string
     {
         return Uuid::uuid4()->toString();
     }
 
     private static function combine($input, $r, $index, $data, $i, &$output): void
     {
         $n = count($input);
 
         // Current cobination is ready
         if ($index == $r) {
             $output[] = array_slice($data, 0, $r);
             return;
         }
 
         // When no more elements are there to put in data[]
         if ($i >= $n) {
             return;
         }
 
         // current is included, put next at next location
         $data[$index] = $input[$i];
         self::combine($input, $r, $index + 1, $data, $i + 1, $output);
 
         // current is excluded, replace it with next (Note that i+1
         // is passed, but index is not changed)
         self::combine($input, $r, $index, $data, $i + 1, $output);
     }
 
     /**
      * Create a configuration/environment data to be passed to
      * the UI
      *
      * @todo For a lack of better place this is put here for now
      *
      * @return array Configuration data
      */
     public static function uiEnv(): array
     {
         $opts = ['app.name', 'app.url', 'app.domain'];
         $env = \app('config')->getMany($opts);
 
         $countries = include resource_path('countries.php');
         $env['countries'] = $countries ?: [];
 
         $isAdmin = strpos(request()->getHttpHost(), 'admin.') === 0;
         $env['jsapp'] = $isAdmin ? 'admin.js' : 'user.js';
 
         return $env;
     }
 
     /**
      * Email address (login or alias) validation
      *
      * @param string    $email    Email address
      * @param \App\User $user     The account owner
      * @param bool      $is_alias The email is an alias
      *
      * @return string Error message on validation error
      */
     public static function validateEmail(
         string $email,
         \App\User $user,
         bool $is_alias = false
     ): ?string {
         $attribute = $is_alias ? 'alias' : 'email';
 
         if (strpos($email, '@') === false) {
             return \trans('validation.entryinvalid', ['attribute' => $attribute]);
         }
 
         list($login, $domain) = explode('@', $email);
 
         // Check if domain exists
         $domain = Domain::where('namespace', Str::lower($domain))->first();
 
         if (empty($domain)) {
             return \trans('validation.domaininvalid');
         }
 
         // Validate login part alone
         $v = Validator::make(
             [$attribute => $login],
             [$attribute => ['required', new UserEmailLocal(!$domain->isPublic())]]
         );
 
         if ($v->fails()) {
             return $v->errors()->toArray()[$attribute][0];
         }
 
         // Check if it is one of domains available to the user
         // TODO: We should have a helper that returns "flat" array with domain names
         //       I guess we could use pluck() somehow
         $domains = array_map(
             function ($domain) {
                 return $domain->namespace;
             },
             $user->domains()
         );
 
         if (!in_array($domain->namespace, $domains)) {
             return \trans('validation.entryexists', ['attribute' => 'domain']);
         }
 
         // Check if user with specified address already exists
         if (User::findByEmail($email)) {
             return \trans('validation.entryexists', ['attribute' => $attribute]);
         }
 
         return null;
     }
 }
diff --git a/src/database/seeds/OpenViduRoomSeeder.php b/src/database/seeds/OpenViduRoomSeeder.php
index 5cb80ca7..f4eef6d2 100644
--- a/src/database/seeds/OpenViduRoomSeeder.php
+++ b/src/database/seeds/OpenViduRoomSeeder.php
@@ -1,24 +1,33 @@
 <?php
 
 use App\OpenVidu\Room;
 use Illuminate\Database\Seeder;
 
 // phpcs:ignore
 class OpenViduRoomSeeder extends Seeder
 {
     /**
      * Run the database seeds.
      *
      * @return void
      */
     public function run()
     {
-        $user = \App\User::where('email', 'john@kolab.org')->first();
-        $room = \App\OpenVidu\Room::create(
+        $john = \App\User::where('email', 'john@kolab.org')->first();
+        $jack = \App\User::where('email', 'jack@kolab.org')->first();
+
+        \App\OpenVidu\Room::create(
             [
-                'user_id' => $user->id,
+                'user_id' => $john->id,
                 'name' => 'john'
             ]
         );
+
+        \App\OpenVidu\Room::create(
+            [
+                'user_id' => $jack->id,
+                'name' => strtolower(\App\Utils::randStr(3, 3, '-'))
+            ]
+        );
     }
 }