Sideline · game day, for the person holding the clipboard

The two hours around a contest, built for the bench — not for the athletic director’s office

A school athletics program has two very different jobs. One runs a season: eligibility as a program, rosters, consent, facilities, schedules. The other runs a contest: keep the book, break down the film, make sure the officials who show up are certified to be there. Sideline is the second job. Three engines carry it — a scoring reduction that proves its own totals, a film-tag fold that builds a cut-up without touching a video byte, and a certification gate that refuses an assignment and refuses a payment. All three are registered routes at the current build.

Two things this page will state before you scroll, because they change whether you should keep reading. No money moves on this product — official pay runs on the platform’s disbursement rail with no provider provisioned, so every pay call returns queued not sent with a null transaction id, and the settlement endpoint answers 503. The film-breakdown API is registered and its browser screen is not in the app router — we measured that rather than assuming it, and a coach drives film breakdown through the API today.

Book a conversation What it does today

Reconciledthe box score proves its totals equal the line-score sums — no point lost, no point invented

Statelessno contest is held on our side — the same log always yields the same box score

Census-neutralopaque game, team, and play references — no athlete or roster reference on the scoring wire

No moneyno provider is provisioned — every disbursement returns queued not sent, settlement answers 503

The scoring reduction — why the board and the book agree

The box score proves itself against its own line score before it is returned

A scorekeeper’s real problem is not entering plays. It is the argument in the third quarter when the board says one number and the book says another, and nobody can say which drifted or when. That argument exists because most scoring tools keep a running total and a period breakdown as two separate numbers, updated by two separate code paths, and never compare them.

This engine is a pure reduction over an append-only log. Every play you enter goes through a record gate first: a sequence number out of order, a period out of range, a team that is not in the setup, or a malformed setup is refused with an honest 400 that names the engine’s own verdict. Nothing is quietly dropped and nothing is quietly reordered to make the log fit. The accepted log is then folded four ways — into home and away totals with a per-period line score, into a scoring summary that lists each scoring play with the running score after it, into a tally of non-scoring plays grouped by side and tag, and into a reconciliation check that asserts the totals equal the sums of the line score. That last fold is the one that matters: if the reduction ever disagreed with itself, the response would say so rather than pick a winner.

Because the reduction is pure and deterministic, the same log produces the same box score byte for byte. A disputed score is settled by replaying the log, not by trusting a stored row that somebody may have edited. That is also why the route persists nothing: there is no contest record on our side to drift from the log you hold. The trade is stated plainly in the objections below — you keep the log.

Every surface, with its route The objections

What it does today

Five surfaces, each named by the route that carries it

Nothing on this page is described from a file name. Each card below names the route path as it is registered in the running API, and the label under it says where that registration is. One card describes a route whose whole job is to refuse, and it is labelled that way. One card describes a route that is registered and has no browser screen, and it is labelled that way too.

Live box score — a supplied event log folded into a reconciled score

POST /v1/public/athletics/scoreboard

A scorekeeper on the bench appends plays to a log: period, side, play tag, points. The route replays that log through an append-only record gate, folds it into home and away totals with a per-period line score, lists the scoring plays with the running score, groups the non-scoring plays by side and tag, and then proves the totals equal the line-score sums — so no point can be lost or invented between the log and the board. An out-of-order sequence number, an out-of-range period, or an unknown team is an honest 400 naming the engine’s verdict. Nothing is silently dropped and nothing is silently reordered. The route is anonymous and takes no tenant: there is no sign-in between a scorekeeper and the board.

Registered · app.ts:3513

Film breakdown — clip tags folded into a play index, and a cut-up a player can watch

POST /v1/schools/:schoolId/athletics/film-tags/compute

A coach tags clips by play and time code. The compute route replays the supplied tag log through an append-only, fail-closed record gate, then folds the validated log into a play index and a per-clip tag list. The playlist route turns an ordered tag selection into a sequential clip list — video id, start, end, label — for a player to seek and play in order. There is no server transcode and no concatenation: no new video bytes are minted, which is why a cut-up is instant rather than a render queue. The route confirms a supplied clip belongs to this school before it will accept a tag referencing it; a clip in another school is a fail-closed 404, never a silent cross-tenant tag.

Registered · app.ts:5891 · no browser screen in the app router

Publishing a cut-up beyond the roster — the route refuses

POST /v1/schools/:schoolId/athletics/film-tags/publish

Sharing a cut-up outside the team — to an opponent, to a recruiting service, to a public page — runs through the same publication-consent chokepoint every other student-media surface on this platform runs through. That chokepoint is not provisioned for this surface, so the publish route answers 503 and stores nothing. The roster-and-team-only tagging and viewing path above is the wired, working path. This is stated here because a coach planning a season needs to know which of the two they are buying.

Registered · answers 503, stores nothing

Officials — certification checked before assignment, and re-checked at pay

POST /v1/schools/:schoolId/athletics/officials/check-certification

An assignor checks whether an official holds a current, verified certification matching the role, then assigns. Certification is fail-closed: an uncertified official is denied assignment and is never paid, and no money intent is recorded for them at all. Certification is re-checked at the pay instant, not only at assignment, so a certification that lapsed between Tuesday and Friday stops the payment rather than the paperwork. Pay is an exact non-negative integer number of cents in a closed currency set — it is never widened to a float. Officials are opaque contractor references, never the student census; this surface reads no student table.

Registered · app.ts:5885 · admin tier, fail-closed

Academic eligibility — computed from the posted grade record, read by the coach’s office

GET /v1/schools/:schoolId/athletics/eligibility

Eligibility is computed from the real posted grade record. It does not accept a GPA a coach types in and it does not accept a self-reported grade. The read is tenant-scoped, walled against a sales representative, and gated behind the athletics module: a school without that module sees a surface byte-identical to having none. The grade-derived detail underneath a verdict is consent-gated through the directory-information chokepoint — a suppressed student is redacted, not leaked, on the way out.

Registered · app.ts:5150 · module-gated, consent-gated

What it refuses today — in the present tense, not as a promise

Four refusals, each performed by a route rather than described in a paragraph

Money. Official pay is real money, and it moves on the platform’s canonical disbursement rail. No disbursement provider is provisioned for this product, so a pay call returns a queued-not-sent result with a null transaction id and paid set to false, and the live settlement endpoint answers 503. The certification gate and the cents arithmetic around it are real and you can run them against your own slate. No card is charged anywhere on this product and there is no checkout on this page.

Publishing a cut-up beyond the roster. The publication-consent chokepoint that governs student media on this platform is not provisioned for the film surface, so the publish route answers 503 and stores nothing. Tagging and viewing inside the team is the wired path. A program that needs opponent exchange or a public highlight page is buying something this product does not do.

Storage. Neither the scoreboard nor the film-tag log has a durable server-side store. The caller supplies the working log on every call and the response is a computation over it. This is a design position — it is what makes the reduction reproducible and leaves us holding no contest record — and it is also a constraint you carry. A durable tag log is a named piece of work with nothing behind it in the build today.

Models. No AI engine is provisioned for this product. The box score is arithmetic over the log you supply. A film tag is the tag a coach typed, not a play a model detected. There is no face matching on this surface and no biometric data is collected in this product. Mail. This product sends no mail; nothing here delivers a message. The address on this page is a mailbox a person reads.

Who it is for, and what the first week looks like

Head coaches, scorekeepers, and officials assignors — four days to a decision made against your own record

The evaluation is not a demo. It is one scored contest, one tagged film with a cut-up, and one officials slate checked against real certifications — three artefacts you produce yourself, in the week you would have played anyway.

Day one — keep one contest on the board

You keep one game on the scoreboard route while your existing paper book runs alongside it. At the end you compare. The engine proves its own totals against its line score, so the comparison is against a number that has already reconciled with itself. This costs you nothing but the game you were already scoring, and it is the only honest way to find out whether the play tags you use match the tags the engine takes.

Day two — tag one film

You tag one existing game film by play and time code, fold the log through the compute route, and pull a play index out of it. Then you select ten tags and build the cut-up. Because there is no transcode, the cut-up exists the moment you ask for it. You are calling the API directly at this point, or driving it from your own script: the browser screen for film tagging is not in the app router, and this page will not pretend otherwise.

Day three — run the officials check against a real assignment

Your assignor runs the certification check against the officials already booked for next week. The answer is a typed verdict, not a colour. Any official whose certification has lapsed or does not match the role comes back denied, and you find that out on a Wednesday rather than at the coin toss.

The rest of the week — decide against your own record

By the end of the week you have a scored contest, a tagged film with a cut-up, and an officials slate checked against real certifications. Those three artefacts are the evaluation. There is no trial to convert and no card on file — there is no checkout on this product at all — so what happens next is a conversation about what you found.

The objections, answered without hedging

The six things a coach says first

You store nothing. So what happens to my season?

Nothing about a contest is held on our side. The scoreboard route persists nothing, and the film-tag log has no durable server-side store — the caller supplies the working log on every call and the response is a computation over it. That is a real constraint and it cuts both ways. What you get for it: there is no contest record of ours to lose, to corrupt, or to hand to a third party, and the same log always produces the same box score byte for byte, so a disputed score is settled by replaying the log rather than by trusting a database row. What you give up: you hold the log. If a durable tag log is what would make this usable for your program, say so in the conversation — it is a named build item with no store behind it today, and we would rather write that down than sell you a store that does not exist.

The film screen is missing. Is this actually built?

The film-breakdown API is registered and it works: compute, playlist, and a publish route that refuses. What is absent is the browser screen — the film-tagging pages have zero references in the web application’s router, which we measured rather than assumed. So a coach today drives film breakdown through the API or through their own tooling. If your program needs a screen, that is the single largest piece of work between this product and your bench, and naming it here is more useful to you than a screenshot of something that does not route.

Our scorekeeper is a parent volunteer with a phone. Is there a login to fight with?

No. The scoreboard route is anonymous: no sign-in, no tenant, no key. It is metered per address by a token bucket that fails closed, so it cannot be used to hammer the service, and it carries no student data at all — a game is an opaque reference, a team is an opaque reference, a play is an opaque tag, and scoring is attributed at the team level only. A parent volunteer keeping the book is exactly the case that route was shaped for.

Can I pay my officials through this?

Not on this product. Official pay runs through the platform’s canonical disbursement rail, and no disbursement provider is provisioned: every pay call comes back queued not sent, with a null transaction id and paid set to false. The settlement endpoint answers 503. That is the present state of the money rail, stated in the present tense: the arithmetic and the certification gate are real and you can run them, and no money moves. No card is charged anywhere on this product.

Does any of this use AI on my athletes?

No AI engine is provisioned for this product. The box score is a deterministic reduction over the log you supply. A film tag is the tag you typed, not a detected play. There is no face matching on this surface and no biometric data is collected in this product. If we ever provision a model here it will be described the same way everything else on this page is described — by naming the route and what it does.

How is this different from the athletic director’s system?

Different two hours. The athletic director’s system runs a season: eligibility as a program, rosters, consent administration, schedules, facilities. Sideline runs a contest: the book, the film, the officials slate. They share a substrate — the same athletics module gate, the same eligibility engine, the same consent chokepoint — so a school running both is running one platform, not two integrations. A school running only Sideline is running the bench.

The data this product touches, and how a minor’s data is gated

The scoring wire carries no student at all; every other surface is gated before it carries one

The scoring wire carries no student. The engine behind the box score is census-neutral by construction: a game is an opaque reference, a sport is an opaque reference, a team is an opaque reference, and a play is an opaque tag. Scoring is attributed at the team level only. There is no athlete, student, player, or roster reference in the engine or on that wire, which is why the route can be anonymous and public without a consent question arising at all. A team label supplied by a school is a display label the school chose, never a student’s name.

Film clips are tenant-checked, and their bytes are somebody else’s job. Before the film route will accept a tag that references a clip, it confirms the clip belongs to your school; a clip in another school is a fail-closed 404, never a silent cross-tenant tag. The route reads the clip record only to confirm tenancy and existence. It never reads the storage key, never presigns a URL, and never serves a byte. Every clip a viewer actually watches is served by the platform’s existing consent-gated video path, which owns that consent decision by itself — this product adds no consent code of its own and bypasses none.

Eligibility detail is consent-gated and redacted. The eligibility read is tenant-scoped, walled against a sales representative, and gated behind the athletics module. The grade-derived detail underneath a verdict passes through the directory-information consent chokepoint, so a student whose family has suppressed directory information is redacted rather than leaked. Officials are not students. The officials surface handles opaque contractor references, reads no student table, and writes no student row; a minor is never a subject on it.

A school without the athletics module sees nothing. The school-scoped surfaces sit behind a module entitlement. A school that does not hold it gets a response byte-identical to a school where these surfaces do not exist. A module gate on this platform is an absent surface, not a greyed-out button. Student data is owned by the school. It is not sold, and it is not shared with outside companies.

How it fits the family

One athletics substrate, four front doors — and Sideline owns the narrowest one on purpose

The athletics surfaces on this platform share a substrate: the same module entitlement, the same eligibility engine reading the same posted grade record, the same consent chokepoint on student media, and the same scheduling spine that library, clubs, and athletics all consume rather than fork. What differs is who is standing in front of them.

athletic.software is the athletic director’s office: the season, the rosters, the consent administration, the facilities. schoolsports.network is the public digital home for a school’s teams — the side the community reads. schedule.software is the scheduling spine those surfaces consume. Sideline is the bench: the book, the film, the officials slate, for the two hours around a contest. A school running Sideline and the director’s system is running one platform, not two integrations, because they are the same substrate with different doors. A school running only Sideline is running the bench, and that is a supported way to run it.

The wider school platform sits at homeroom.software, which ties publishing, recognition, and administration together. Sideline does not need it to work; a program that already has it does not get a second copy of anything.

athletic.software schoolsports.network schedule.software homeroom.software

Pricing state, and the next concrete step

No price is published here and there is no checkout on this product

The pricing state, in the present tense: no price is published on this page, no checkout exists on this product, and no card is charged anywhere on it. What a school athletics program pays is a conversation with Chris, and it is a better conversation after you have run the three artefacts described above than before, because then it is a conversation about something you measured.

The next concrete step is one email and one contest. Write to the address below with your sport and roughly when your next home date is. We will send you the exact request shape for the scoring route so a scorekeeper can keep the book on it that night, alongside whatever you use now, and the shape for the film compute and playlist calls so a coach can tag one existing film and pull a cut-up out of it. Nothing is provisioned on your side to do that: the scoring route is anonymous, and the school-scoped surfaces need only the athletics module entitlement your district already controls.

Two build items are on the table in that conversation, and we would rather name them than have you discover them: the film-tagging browser screen, which is registered as an API and absent from the web application’s router; and a durable tag log, which has no store behind it in the build today. If either is what stands between this and your bench, say so — that is the useful outcome of the call.

To book: email [email protected].

FAQ

Common questions

What does it cost?

No price is published on this page and there is no checkout on this product. Pricing for a school athletics program is a conversation with Chris, and it happens after you have run the three artefacts in your first week.

Do you need a contract with our district before we can try the scoreboard?

The scoreboard route is anonymous and carries no tenant, so it needs nothing from your district to run. The film, officials, and eligibility surfaces are school-scoped and sit behind the athletics module, which a district administrator entitles.

Is any student named anywhere in the box score?

No. The scoring engine is census-neutral by construction: opaque game, sport, and team references and an opaque play tag, with scoring attributed at the team level only. There is no athlete, student, player, or roster reference in the engine or on that wire.

Where do the video bytes live?

Not here. The film route confirms a clip belongs to your school and never reads its storage key, never presigns, and never serves a byte. Every clip byte a viewer sees is served by the platform’s existing consent-gated public video path, which owns that consent decision on its own.

What happens on a school that does not have the athletics module?

The school-scoped surfaces are dark: the response is byte-identical to a school that has no such surface at all. A module gate on this platform is not a hidden menu item, it is an absent surface.

Who is on the other end of the email address?

A person. This product sends no mail of its own — there is no mailbox provisioned on sideline.software and nothing here delivers a message. The address below is a mailbox that is read.