Skip to content
PokerEnginePro
Tournaments

From Sit & Go to the Sunday major.
Balanced by the rules. Paid to the chip.

Sit & Go lines to scheduled MTTs, satellites and tickets, balanced by the rules and paid to the chip. The scheduler opens the events, the clock runs on the server, the balancer moves the right player — and every pool ends at zero.
Request a demoSee the verified runs

2,171

Sit & Gos in one unattended hour

61,242 hands, every payout exact to the chip, books reconciled clean

61,242

hands dealt and stored

every hand in hand history, all-in run-outs included

651,300

paid out of 651,300

300 a Sit & Go to its two places; every pool account at zero

27

players in a satellite-fed MTT

unattended across three nodes; the scheduler made both events, payouts exact to the chip

Formats

Every format a schedule needs.
Opened by the scheduler, on time.

Templates say what a tournament is; schedules say when it runs. The scheduler does the rest — it keeps Sit & Go lines open, lists each scheduled event ahead of time and opens registration when you said it would.

01

Sit & Go lines

Sit & Gos that replenish themselves: a new one opens as the last one fills.

02

Scheduled MTTs

Once, every N minutes, or daily and weekly in a named time zone, with daylight saving handled.

03

Announced ahead, opened on time

Each scheduled event is listed a day ahead by default and opens registration when the operator says, until the schedule's end date.

04

A tournament lobby players understand

A tournament lobby and a page per event with the blind clock, registration, tickets, standings and payouts; table moves follow the player automatically.

Four ways to repeat

Daily and weekly events keep their wall-clock time in a named time zone — the 20:00 main event is still at 20:00 after the clocks change.

  • Once

    One tournament, at its start.

  • Every

    From the start, then every N minutes.

  • Daily

    Every day at the start's time, in the schedule's time zone.

  • Weekly

    On the chosen days at the start's time, in the schedule's time zone.

Tournaments.cs
/// <summary>
/// A recurring scheduled tournament: instances of <see cref="TemplateId"/> from
/// <see cref="Start"/> on, as <see cref="Kind"/> says. Daily and weekly starts keep their wall-clock time in
/// <see cref="TimeZone"/> (an IANA or Windows zone id), so a daily 20:00 is still at 20:00 after the clocks change.
/// Each instance is created <see cref="AnnounceAhead"/> before it starts (24 hours if not set) and opens for
/// registration <see cref="RegistrationOpensBefore"/> before it starts — or as soon as it is created, if not set.
/// </summary>
public sealed record TournamentSchedule(
    string Id,
    string TemplateId,
    RecurrenceKind Kind,
    DateTimeOffset Start,
    TimeSpan Every = default,
    IReadOnlyList<DayOfWeek>? Days = null,
    string TimeZone = "UTC",
    TimeSpan RegistrationOpensBefore = default,
    TimeSpan AnnounceAhead = default,
    DateTimeOffset? Until = null,
    bool Enabled = true);
A schedule, as the platform's contracts define it (contracts/Poker.Contracts/Tournaments.cs, lines 127–145).

The clock

Levels, breaks and antes.
On the server's clock.

Levels, breaks and big-blind antes on a server-side clock. A tournament table deals at the tournament's level, announces the next one before it changes, and seats and moves players only on the tournament's orders.

  • Regular

    Levels
    10 min
    Start
    100 big blinds
    Breaks
    Every hour

  • Turbo

    Levels
    5 min
    Start
    100 big blinds
    Breaks
    Every hour

  • Hyper

    Levels
    3 min
    Start
    25 big blinds
    Breaks
    None

Big-blind antes from the third level. A custom structure is the operator's own.

BlindClock.cs · SpeedPresets.Build
var (minutes, firstStep, breakEvery) = speed switch
{
    TournamentSpeed.Regular => (10, 0, 6),     // 100 big blinds deep, a break every hour
    TournamentSpeed.Turbo => (5, 0, 12),       // 100 deep, half the time, a break every hour
    TournamentSpeed.Hyper => (3, 4, 0),        // 25 deep, no breaks
    _ => throw new ArgumentOutOfRangeException(nameof(speed), speed, "Custom structures are the operator's own."),
};
The three presets, built from the starting stack (platform/Poker.Platform.Grains/Tournaments/BlindClock.cs, lines 161–167).

Late registration, rebuys, re‑entry, add-ons

Late registration

Registration stays open into the first levels of play — as many as the template says.

Rebuys

The same entry buys chips again, up to a limit, until a set level — and, if the operator wants, only at or below the starting stack.

Re‑entry

A busted player registers again as a new entry, up to a maximum number of entries in all.

Add-ons

Extra chips once per entry, at the end of the rebuy period.

Balancing

Broken and balanced by the rules.
The right player moves.

Tables broken highest-numbered first, the player due the big blind moved, absent players handled, simultaneous busts ordered by starting stack.
  • When the field fits on one table fewer, the highest-numbered table breaks and its players fill the empty seats.
  • Tables two or more players apart are balanced by moving the player next to post the big blind, from the fullest table to the emptiest.
  • Absent players are dealt in and post; they are checked or folded without the clock running for them.
  • Players who bust in the same hand finish in order of their starting stacks.

5 · 4 · 3 · 2

tables broken, highest-numbered first

each as soon as the field fitted one table fewer; table 1 the final table

~2 hands

longest imbalance between tables

two players moved, each the one next to post the big blind; no table ever over six

Breaking and balancing tournament tablesFirst: twenty-four players on five six-max tables, five, five, five, five and four. The field now fits on four tables, so table 5, the highest-numbered, breaks and its four players fill the empty seats at tables 1 to 4. Second: two players bust at table 1, leaving it with four against six at the others. Tables two apart are balanced by moving one player — the one next to post the big blind at the fullest table — to the emptiest.1 · the field fits on onetable fewerT1T2T3T4T5table 5 breaks first · its playersfill the empty seats2 · two apart: the next bigblind movesT1T2T3T4the player due thebig blind movesplayermovesempty
Six-max tables. The same rules ran the verified 27-player event below.

Finishing positions, ties included

Equal starting stacks busted in the same hand tie and share the prizes of the places they cover, remainders one chip at a time; a ticket is never split.

One field, many servers

A tournament's tables are actors the cluster places on any node, so one field plays across every server in the room.

Prizes

Guarantees, overlay, satellites.
Every pool ends at zero.

Chips at a tournament table are not money — no hand touches the ledger. The money moves at the edges: entries into the pool, prizes out of it, all in the same double-entry ledger as everything else.
  1. 1

    Guarantees, overlay and payouts

    Payout structures, guaranteed prize pools and overlay, reconciled to the chip.

  2. 2

    Tournament money, to the chip

    Entries, rebuys and add-ons are paid before they count, once per key; prizes are paid in one transaction that must empty the pool.

  3. 3

    Satellites and tickets

    Satellites pay tickets — a wallet asset with an expiry — into the target event.

A tournament's prize poolEntries, rebuys and add-ons pay into the tournament's prize pool, with the fee to the house's tournament fees apart from rake. A satellite ticket can pay an entry instead. If the guarantee is not met, the house pays the overlay into the pool. The pool pays the places in cash in one transaction that must empty it, or, for a satellite, pays tickets into the target event. A withdrawal or a cancellation refunds every part to where it came from.Entriesbuy-in, rebuyand add-onHouse feesapart fromrakefeeTicketpays an entryHousetops up theguaranteeredeemoverlayPrize poolends at zeroplaces paidsatellitePrizescash, in onetransactionTicketswallet assetwith expirywithdraw or cancel: every partrefunded where it came from

Tickets

A seat you can hold in your wallet.

A ticket enters any later instance of the event it was won for — and nothing else, once. A withdrawal or a cancellation gives it back. Past its expiry, the nightly pass returns its value to the player as cash, or to the house, as the operator decides.

Tournaments.cs
/// <summary>
/// A satellite pays tickets into the target tournament template instead of cash: as many places as
/// the pool buys tickets of <see cref="TicketValue"/>; what is left over is paid in cash to the next place.
/// A ticket enters tournaments of the target template only, and lasts <see cref="TicketValidDays"/> days from the
/// satellite's end — 0 for as long as it goes unused.
/// </summary>
public sealed record SatelliteRule(string TargetTemplateId, long TicketValue, int TicketValidDays = 0);
The satellite rule on a tournament template (contracts/Poker.Contracts/Tournaments.cs, lines 72–78).

Operator control

Your event, your call.
Refunded to the chip.

Pause, resume, cancel with full refunds, move a player, break a table.
  • Pause
  • Resume
  • Cancel with refunds
  • Move a player
  • Break a table
  • A cancellation refunds every entry, rebuy and add-on to the balance it came from — tickets included.
  • Large withdrawals, payouts by exception, chargeback write-offs, crypto returns, vendor changes — approved by the family's specialist — rule-pack reviews and market assignment, high-risk KYC approvals, screening clears, AML, integrity and responsible-gambling releases, confiscations, ledger adjustments, stake changes at real-money tables, reinstatements and tournament cancellations all need a second person.
  • Every command and every sensitive read — refusals included — with who, their roles, before, after, reason and address.

For the big days

Hand-for-hand bubble play

Synchronised hand-for-hand play on the money bubble.

Bounty and progressive knockout

Bounties and PKO formats, paid at the elimination.

ICM final-table deals

Chip-chop and ICM deals at the final table.

10,000-player fields

Tournament child grains spread one field across the cluster.

Verified

Run unattended. Checked to the chip.

Two runs on PostgreSQL across a three-node cluster, with the production stores and bots for players. After the registrations, the test only read — and every node had to finish without logging a single error.

Run 1

A 27-player MTT fed by a satellite

A hyper-speed satellite, then a regular-speed main event with a guarantee the field did not quite meet — both made by the scheduler from their schedules.

players in a satellite-fed MTT
27
unattended across three nodes; the scheduler made both events, payouts exact to the chip
satellite tickets won and spent
2
6 × 40 = 240: two tickets of 110 into the main event and 20 in cash; the winners' wallets not charged
tables broken, highest-numbered first
5 · 4 · 3 · 2
each as soon as the field fitted one table fewer; table 1 the final table
longest imbalance between tables
~2 hands
two players moved, each the one next to post the big blind; no table ever over six
guarantee paid to the last chip
3,000
2,700 paid in plus 300 overlay, to six places; the pool account at zero
ledger entries reconciled clean
107
65 accounts, after the satellite and the main event

Run 2

A Sit & Go line for an hour

Six-max hyper Sit & Gos with three kept open by the scheduler, and a new player arriving every quarter-second into the fullest one.

Sit & Gos in one unattended hour
2,171
61,242 hands, every payout exact to the chip, books reconciled clean
entries in one hour
13,028
a player every quarter-second, none refused as full; three Sit & Gos kept open
hands dealt and stored
61,242
every hand in hand history, all-in run-outs included
paid out of 651,300
651,300
300 a Sit & Go to its two places; every pool account at zero
ledger entries reconciled clean
43,450
15,232 accounts; the wallets down by the fees and nothing else
errors logged by any node
0
2,171 tables placed across three nodes: 742, 678 and 751

Measured on 28 September 2026 in the tournament verification suite, which runs on every build.

See a field break to one table.
Then see the books close at zero.

A live walkthrough of the scheduler, the clock, the balancer and the ledger behind them — with the verified runs behind every number on this page.

Request a demoLicensing options