Skip to content
BamzIQPortal
Sign inJoin
Circuitry resolving into linked human figures and then into branching, leaf-like growth: a room's signal becoming something people made together.

What exists today

The whole list, including the parts that are missing.

Nothing on this page is a roadmap item wearing the present tense. Each claim names what produced it, and the last section names what BamzIQ does not do.

Join with a PINSign in to host
  • 17 question types
  • Live, self-paced, or a course
  • Six roles, five surfaces
  • axe in CI, both themes

Question types

17 types, and only 9 of them keep score.

Counted from the live registry the game engine reads, not from a brochure. 7 are unscored audience instruments and one is a content slide, which is why a webinar with no right answers anywhere in it is fully expressible.

Scored

  • Quiz
  • True or false
  • Select all that apply
  • Type the answer
  • Slider
  • Numeric answer
  • Put in order
  • Match the pairs
  • Tap the image

Unscored, and content

  • Poll
  • Word cloud
  • Brainstorm
  • Open-ended
  • Rating scale
  • NPS scale
  • Slide
  • Drop a pin

Every type runs in all three modes: live on a PIN, self-paced inside a window, or as a session inside an event. Answer order can be shuffled. Partial credit reaches the score through the engine rather than being applied afterwards.

5,000in one room

Measured on one node against the real server over real sockets: 5,000 of 5,000 players joined with zero failures, every one received the question inside a 34ms window, and every answer was counted with the exact expected split. The same room was killed outright with a SIGKILL and came back with all 5,000 players in under two seconds.

Events

A container above the single game.

The largest thing most tools in this category know about is one game. Everything longitudinal (one code, one standing, one report) needs something above it.

An ordered stack of lit bars descending like a staircase, with one of them burning gold: a sequence with a current item in it.

Run of show

An ordered agenda with each session’s presenter, room and scheduled start. A session is a hosted game, a self-paced assignment, or a break.

How we know: The organiser console, with a live operator view of the same list.

A single thread of gold light running through a row of identical dark arches, lighting only the one it is passing through.

One code for the whole event

A single code on the lanyard that resolves to whichever session is live and hops as the day moves on.

How we know: The attendee door answers a waiting event with a holding screen and a 200, not an error.

Many separate pools of cool light rising and merging into one tall column of gold.

Cross-session tournament

One standing across every session in an event: the format conference organisers actually run, and the thing they name first.

How we know: Per-session scores are keyed to an event participant rather than to a nickname.

Two tokens side by side: one a hollow ring of cool light, the other solid metal with a blank gold seal struck into its face.

Identity and registration

Optional per event: email, employee ID, ticket reference or a custom field. Upload the attendee spreadsheet and joins are matched against it.

How we know: An identity is labelled claimed or verified; only signing in through a directory marks it verified.

A stream of identical lit forms breaking into unlinked particles before they reach a sealed dark vault, so nothing that goes in still carries its shape.

Anonymous sessions

A per-session switch that makes responses unattributable even to the organiser, which is a claim worth making only because it is enforced where the data is written.

How we know: A storage decision: no name is written, rows are shuffled before insert, no standing row and no participant record is created, and aggregates are withheld below five respondents.

Dozens of fine threads entering from one side and converging into a single wide ribbon of gold light.

Event reporting

Attendance, engagement and sentiment for the event rather than twelve reports for twelve sessions.

How we know: One report over the run of show, with per-attendee engagement and pulse trends across sessions.

A PIN authorises playing, and nothing else.

Controlling a room needs a signed grant bound to that one room, and the answer key is never sent to a player: asserted against the bytes on the wire, on the live path and on the self-paced one.

Surfaces

Six roles, and the server has always known the difference.

The roles were enforced server-side long before they had screens. The join frame carries a role, and the engine decides from it who may control the room, who may see the answer key, and who counts as a competitor.

A darkened cinema-scale hall, a projector beam cutting through haze onto a blank lit screen above empty seats.

Host screen

The projected screen: the join code as the largest thing in the room, the question, the tiles, the reveal, the leaderboard.

How we know: Type sized in viewport height rather than rem, from a legibility floor of a 15cm cap height at 30 metres.

A hand holding a phone in a dark auditorium, its screen the brightest thing in the frame.

Presenter remote

A phone-shaped control screen with advance, skip, pause, extend, private speaker notes, and the answer key the projected screen must never show.

How we know: Controller roles require a signed grant bound to one room; a PIN alone can only play.

A lit mixing desk at the back of an empty hall, headphones resting on the faders and the stage rig beyond.

Co-host desk

Full control from the back of the hall, plus the moderation queue: the AV operator’s seat while the speaker talks.

How we know: Includes speaker handoff between presenters without ending the room, and the emergency controls.

A wall-mounted screen glowing over a few empty chairs in a quiet overflow room.

Cast screen

Read-only and chrome-free, for a second projector or an overflow room.

How we know: A spectator is structurally denied the control channel and excluded from the leaderboard, which is why it needs no credential.

A backstage green room: one armchair, a lit lamp, a glass of water and a mirror with the bulbs off.

Green room

The pre-flight check: connection quality, screen size, a test question.

How we know: Needs no account and no live session by design: a presenter checks their machine the morning before, when there is nothing to join.

A broadcast camera on a tripod framing a lit lectern, a bank of monitors below it.

Streaming overlay

Composite live results over a speaker feed on any platform that takes a browser source. No marketplace listing, no per-platform integration.

How we know: A transparent-background browser source for OBS or vMix, with the plate contrast measured rather than eyeballed.

A queue of glowing blocks stacked against a closed gate, the channel beyond it dark and completely empty.

The audience

Q&A that survives two thousand phones.

Moderated, rate-limited per person, upvoted and capped. It ships ungated; the market leader charges for it two tiers up and only in one mode.

  • A pending question is held on a channel players are not on. It is not hidden in the client; it is not sent to the client.
  • Asserted on both the live event path and the reconnect-and-replay path, against the bytes on the wire.
  • Triage rather than a list: assign a question to a named panellist, mark it answered, park it, merge duplicates.
  • Aggregate-only reactions on the big screen, the cheapest webinar affordance there is, and one the event bus already throttles for.

Getting content in

Import what you already have.

The empty-library problem has two halves: questions that exist in a spreadsheet somebody made in 2019, and questions that do not exist yet. This is the first half.

A flat grid of empty cells lifting off a dark surface, its cells detaching into a neat stack of lit cards.

Spreadsheet import

CSV and tab-separated files, with column mapping and a per-row account of anything that could not be read.

A fanned stack of blank dark panels with one lit panel being slotted in between two of them.

Slide import

A deck becomes BamzIQ slides that can be edited here with questions inserted between them. We import rather than sync, so nothing fails on the day because a token expired.

How we know: Parsed locally from the file's own bytes; this one never reaches a network.

A probe reaching out and stopping dead against a taut membrane, the lattice of nodes behind it untouched and unlit.

Fetching a URL is guarded

When AI generation is pointed at a web page, the server that fetches it cannot be talked into fetching something on your own network instead.

How we know: DNS is resolved before the request and re-checked on every redirect hop, with IPv6 expanded numerically.

A dark, unlit machine with a single cable entering it from outside the frame, carrying gold light inward.

Bring your own model

AI runs on your provider key, or it does not run.

There is no BamzIQ model and no BamzIQ key. You connect Anthropic, OpenAI or OpenRouter yourself, and there is no markup because there is nothing to mark up.

  • Generate questions from a topic, a document or a URL, draft explanations, and review a quiz you already have.
  • Read a finished room back: what it believes, from the question text, the accuracy and the option distribution. Never a class list.
  • Inert until you connect a provider. Nothing on this page needs it, and nothing degrades without it.
  • Keys are encrypted at rest and never returned to the browser.
  • Each feature is opted into separately, and every toggle writes an append-only consent record.

Reports

What the room chose, not just how many were wrong.

Counting wrong answers is a number. Naming what people were wrong about is a lesson plan, and that needs the chosen answer stored as a fact rather than inferred afterwards.

Four bars of light rising from the dark: three of them short and cool, one much taller and gold.

Per-option distributions

Everyone converging on one wrong option is a shared belief worth naming. Spread evenly across the wrong options is guessing, or a question that needs rewording.

Two recesses cut into a dark plate: the left one holds a crimson marker struck through, the right one is empty and unlit.

Wrong is not silent

Somebody who answered incorrectly and somebody who never answered are different rows. Without that, the quietest person in the room tops the needs-help list.

How we know: Stored as its own column at play time and verified end to end, through to the table cell.

An open channel with no gate anywhere along it, carrying an unbroken ribbon of light out past the edge of the frame at full width.

Full report, CSV, every plan

Reporting is not the thing being sold here; room capacity is. A report is also a historical record: the quiz title is stored at play time, so renaming a quiz cannot rewrite last term’s session.

How we know: No row limit past which the export degrades into raw data.

After the session

A missed question comes back on a schedule.

Six Leitner boxes on a doubling ladder: 1, 2, 4, 8, 16, 32 days. Fed by self-paced work and not by live games, where the only identifier is a nickname typed on the day. The deck a learner works through is at /study.

  1. A question is missed

    Answering wrongly on an assignment puts that question into that learner's own practice deck. Nothing else enqueues one.

  2. It is asked again a day later

    The first box is one day out, and a card reviewed today is never due again today. Asserted for every box and both outcomes.

  3. Right moves it one step out

    Two days, then four, eight, sixteen, thirty-two. A learner who knows it meets it roughly half as often each time.

  4. Wrong sends it back to a day

    Straight to the first box. The ladder tracks what somebody still cannot do rather than how long the card has been in the deck.

Running it

Single sign-on, local hosting, and a room that comes back.

Two tokens side by side: one an empty ring of cool light, the other solid metal carrying a struck gold seal.

Single sign-on by configuration

On any deployment, at no tier. The market leader keeps SSO behind an enterprise tier and a sales call.

How we know: OpenID Connect with PKCE, nonce, state, JWKS signature verification and a domain allowlist, verified against a real provider. Five forgery attempts each fail exactly the test covering them.

A warm gold hub on a dark floor with a handful of cool-lit panels held close around it, and nothing at all connecting it to anything beyond.

LAN hosting

Host a room from a laptop over the local network with no internet at all. The phones join the laptop rather than the world.

Scattered shards drifting back and locking into an ordered, brightly lit grid.

Crash recovery

Each changed game is snapshotted to the database every two seconds and read back on boot, so a planned deploy loses nothing and a crash loses at most that window.

How we know: A scripted SIGKILL against a live server with real sockets and a real database, and a triggered production redeploy mid-question: 8 of 8 checks.

A panel split into a pale half and a dark half, with the same small geometric marks equally crisp on each and a beam of light measuring across both.

Accessibility tested in CI

WCAG 2.2 AA is the standard we test against. No conformance level is claimed, because a claim is a document and this is a check that fails the build. Colour is never the only signal: answer tiles carry a distinct silhouette, and the palette is checked for separation under simulated protanopia, deuteranopia and tritanopia.

How we know: axe-core over every signed-out page in both light and dark, at zero violations, on every build.

If a figure cannot be traced to something that was run, it is not on this page.

The list of things that were measured and then deliberately not claimed is published in the same section as the numbers that were kept.

Measured, not claimed

Where each number on this site comes from.

5,000 participants in one room
Load harness against the real server: 5,000 of 5,000 joined, zero failures, every answer counted with the expected split.
A 5,000-player room survives being killed
Scripted SIGKILL of a running server with live sockets and a real database; the room came back with every player in under two seconds.
A room survives a real deploy
An actual production redeploy triggered mid-question. 8 of 8 checks.
Fair scoring across a 25× latency gap
Chaos suite over real sockets: two equally fast thinkers score the same.
The answer key never reaches a player
Asserted against the bytes on the wire, on the live path and the self-paced one.
A pending audience question never reaches a player
Asserted on the event path and the resume path.
17 question types
Counted from the live registry the game engine reads.
Single sign-on cannot be forged
Five mutations (trusting the header's algorithm, skipping audience, nonce, signature or expiry) each fail exactly the test that covers them.
Brand colours cannot be made illegible
Contrast is checked at the API before a colour is stored.
Accessibility
axe-core in CI over every signed-out page in both themes, zero violations.

Measured, and deliberately not claimed

10,000 participants in one room. Every correctness check passes at that size; arrival does not. Joins fall to about 38 a second, so a full lobby takes four and a half minutes, and a realistic conference arrival degrades toward a burst that froze the event loop for 48 seconds and in one attempt of two never formed the room. A room that stops for 48 seconds is an outage, not a slow room. The ceiling was assessed and deferred by decision, not left unknown.

Also not measured, and therefore not claimed: any of the above under real network loss, with several concurrent rooms on one node, or on more than one node.

Not built

What BamzIQ does not do.

Some of these are decisions with reasons, some are simply absent. The page does not pretend to know which you will care about.

  • LMS integration and rosteringNo LTI, no grade passback, no roster sync.
  • SCIM provisioning and domain claimAccounts are provisioned on first sign-in instead.
  • Published marketplace listings for the meeting apps, and any Webex appThe Teams, Zoom and Google Meet embeds are built. Teams runs today once the app package is uploaded to your own org catalogue. Zoom and Google Meet are not published: each store review runs under your organisation's own developer account. There is no Webex app at all, and the host screen works shared in any call regardless.
  • Slack, calendar and ticketing integrationsAttendee lists are imported from a spreadsheet; sessions do not land in calendars.
  • A public content libraryDeliberately absent. Built for a single workspace it is an empty shelf, and an empty shelf is worse than no shelf.
  • Live slide sync from a cloud driveDeliberately not built. We import the deck instead, so nothing fails on the day because a token expired.
  • Spaced repetition from live gamesThe practice deck is fed by self-paced work only. A live player is identified by a nickname typed on the day and a ticket that dies with the browser tab, and keying weeks of somebody's revision to either would hand one learner another's deck.
  • Multi-node hosting, and a configurable retention windowOne node holds one room; the directory that would let a second node reclaim a game is not built. Deletion is manual: see the privacy page.

No SOC 2, ISO or GDPR compliance certification is claimed, and none exists. Neither is an uptime figure or a customer count. What is collected and how to have it removed is set out in full.

Nothing here is a roadmap item

See it in a real room.

Joining takes a PIN and nothing else. Hosting takes an account, and the free plan runs a real room with commercial use permitted and no session time limit.

Join with a PINSign in to host