SaaS Beta Testers

A private beta programme: cohorts by wave, a structured bug intake, release notes and a feature-request board.

  • 6 categories
  • 21 channels
  • 10 roles
  • Medium
Download Discord JSON

Choose a server, review what will be created or reused, then confirm. Merge keeps what you have; replace rebuilds the server. Vetox takes a safety backup first either way.

No uses yetNo views yet

Server structure

Channels

START HERE

  • welcome

    What the beta is and what we need from you.

  • beta-terms

    Confidentiality, what may be shared publicly, and when the beta ends.

  • your-platform

    Self-Roles panel: web, mobile, desktop.

  • announcements

    Wave openings, downtime, programme news.

BUGS

  • report-a-bug

    What you did, what happened, what you expected, and your version.

  • bug-triage

    Status of each report. This is why people keep reporting.

  • known-issues

    Read before reporting.

  • private-report

    Account or security issues. Opens a ticket.

WAVES

  • wave-oneHidden from @everyone

    First cohort. Small enough that we read everything.

  • wave-twoHidden from @everyone

    Second cohort. Load and edge cases.

  • wave-threeHidden from @everyone

    Third cohort. Close to launch conditions.

RELEASES

  • release-notes

    Every build, and what changed in it.

  • whats-coming

    Direction, not dates.

FEEDBACK

  • feature-requests

    One per post. Votes decide.

  • first-impressions

    Your first hour. We can never collect this from you twice.

  • workflow-and-use-cases

    What you are actually trying to do with it.

  • general

    Everything else.

  • Office Hours
  • Testing Session

TEAM

  • triage-notes

    Internal. What is actually happening with each report.

  • tester-roster

    Who is in which wave, and who is active.

Roles

  • TeamAdministrator
  • SupportModerator
  • Wave One
  • Wave Two
  • Wave Three
  • Web
  • Mobile
  • Desktop
  • Muted

Overview

A beta programme fails in one of two ways: testers cannot tell you anything useful because there is no format, or they tell you plenty and it disappears into a chat channel. This layout fixes both. #report-a-bug requires four things stated in the topic — what you did, what happened, what you expected, and your browser or version — and #bug-triage is where the team posts the status of each, so a tester can see their report was read, which is the single thing that keeps people reporting. #known-issues is read-only and stops the same bug arriving nine times. Waves is how the programme is actually run: Wave One, Wave Two and Wave Three are separate channels with their own roles, so a feature can be released to fifty people before five hundred, and the team can see which cohort a piece of feedback came from. #release-notes carries every build with what changed, and #whats-coming sets expectations without promising dates. Feedback is deliberately split from bugs: #feature-requests is votable, #first-impressions captures the reaction of someone using it for the first time, which is information you can never collect again from that person, and #workflow-and-use-cases is where testers describe what they are actually trying to do. A hidden Team category holds triage notes and the tester roster.

When to use it

Beta feedback arrives as a stream of unstructured messages, so the team cannot reproduce anything, testers stop reporting when nothing visibly happens, and the same known bug is filed a dozen times. This layout enforces a report format, publishes triage status so reporting feels worthwhile, keeps a read-only known-issues list, and splits testers into waves so a risky feature reaches fifty people before it reaches everyone.

What makes it different

  • Bug reports follow a four-part format stated in the channel topic.
  • Triage status is public, which is what keeps testers reporting after the first week.
  • Waves let a feature reach fifty testers before five hundred, with feedback traceable to a cohort.
  • First impressions get their own channel, because you can never collect them from that person again.

Recommended Vetox setup

  • Suggestions

    Run Suggestions on #feature-requests so the team sees what testers voted for rather than who posted loudest.

  • Self-Roles

    Post a Self-Roles panel in #your-platform so a browser-specific bug can ping the testers on that platform.

  • Tickets

    Point Tickets at #private-report so a tester can send an account or security issue without posting it publicly.

  • Notifications

    Point Notifications at your build feed so #release-notes fills automatically and testers know what changed.

Questions

Why publish triage status at all?

Because unacknowledged reports stop arriving. A tester who files three careful bugs and hears nothing reasonably concludes the channel is a suggestion box, and their fourth bug never gets written. A one-line status — confirmed, cannot reproduce, fixed in the next build, working as intended — costs seconds and is the difference between a beta that reports for months and one that goes quiet in three weeks.

How many waves should a programme have?

Three is enough for most products and the numbers matter more than the count: a first wave small enough that you can read everything they write, a second large enough to surface load and edge-case problems, and a third that approximates launch. What the waves buy you is the ability to fix an embarrassing bug before most of your testers ever see it.

Should bugs and feature requests really be separated?

Yes, because they need different responses and different lifetimes. A bug is triaged, fixed and closed; a request is weighed against everything else and may sit for a year. Mixed together, requests bury bugs during a busy week and the team starts treating the whole channel as noise. Separated, each channel keeps a rhythm the team can actually maintain.

Common mistakes

  • Taking bug reports with no required format, which leaves the team unable to reproduce most of them.
  • Never publishing triage status, so testers conclude nobody reads reports and stop writing them.
  • Releasing to every tester at once, which wastes the whole cohort on a bug fifty people would have caught.

Consider instead

Do you have any doubts?

Our team is there for you

0.0k

Servers

0+

Commands

0

Users

0

Languages