Hockey is supposed to be rough.

Keeping track of it all shouldn’t be.

Take two minutes to experience a shift in hockey scorekeeping.

TallyTracker

Designed by scorekeepers for scorekeepers

TallyTracker is a fully realized proof of concept designed by Joe Kubiniec and developed in collaboration with OpenAI Codex. Product design, written content, and original visual materials © 2026 Joe Kubiniec.

Hypothesis

Small and mid-sized hockey organizations need an affordable way to accurately capture key hockey statistics in-game, in real time.

Problem

Capturing accurate statistics during a live hockey game is extremely difficult. The manual process of transcribing paper results to digital further increases the risk of error.

Solution

Eliminate paper-to-digital. Capture games on a tablet and directly upload completed games to a league database, or generate an Excel file.

Rink-side experience

Still tracking games with pen and paper?Are you still using a wooden stick, too?

Stack of marked paper hockey scoresheets from rink-side scorekeeping

I spent ten months working as a scorekeeper at Buffalo Harbor Center, controlling the game clock while recording goals and penalties on paper. Playing the game-break music and announcing goals over the rink loudspeaker was a blast. The paper-based process was less charming.

Scoresheets arrive cramped, crossed out, and sometimes barely legible. After the game, somebody still has to transcribe that record into a league database. Youth organizations already publish schedules, standings, and player statistics online. The missing piece is an affordable way to capture the game digitally at the source.

Defining the app

From First Whistle to Final Horn

Designed to capture the complete game experience.

01

New Game

Import league rules, team rosters, game structure, and the preferred clock configuration.

League data, game rules, team rosters, clock modes
02

Capture Goals, Penalties, Shots

Record in-game hockey statistics easily and intuitively. Events remain editable, making corrections part of the system instead of an exception.

Goals, assists, penalties, shots on goal
03

With an Assist from TallyTracker

Aware of game state, TallyTracker auto-populates information, tracks penalty time, and maintains the statistics needed for the final record.

Event timestamps, power-play detection, penalty countdowns, announcement scripts
04

Post Game

Complete the record with official sign-off, a printable Boxscore, and upload of game data to league servers.

Official sign-off, export and print, final Boxscore
Next

Future opportunities

Extend the system without complicating today’s scorekeeper.

Roster editing, shot-location tracking, external clock synchronization, and league-specific rulebooks.

The prototype simulates league exchange. Production would require each organization’s APIs, authentication, data validation, and upload contract.

Game clock integration

Game states and clock synch assists scorekeeper load with auto-populate.

When TallyTracker has a game clock to reference, goals and penalties can be time-stamped automatically, penalty time stays synchronized, and the app can recognize power-play conditions. A team roster adds player assignment without making it a requirement.

Game states

No Game ClockThe app remains fully usable. Event times are entered manually and no clock controls are shown.
Synchronized ClockA future integration state: the app reads an external clock but never suggests that it controls it.
Internal Tablet ClockThe practical sweet spot. Start and Stop keep the tablet close to the scoreboard while TallyTracker manages event time and active penalties.

Game Clock Synchronization

Using the tablet’s internal clock is the most common and recommended approach. Like other digital scorekeeping apps, direct synchronization with an arena scoreboard is uncommon and can be expensive to implement and maintain.

Manually starting and stopping TallyTracker’s clock keeps it close to the arena scoreboard and unlocks the app’s full game-state intelligence. When the two drift, the scorekeeper can make a quick correction.

Correcting clock drift

Adjustments in manual timekeeping are a breeze.

Pause the clock, tweak the time, and get back in synch.

Product in motion

Five focused workflows. One functioning prototype.

These demonstrations operate the real prototype. They are not stitched screenshots or a video approximation of intended behavior.

Experience for yourself

Guided walkthrough or functional prototype

Move from New Game through scoring, penalties, power-play intelligence, official sign-off, Boxscore and end of game. Or, launch the stand-alone to explore on your own.

All Star Feature Lineup

TallyTracker brings a rich feature set to league scorekeeping.

01

Configure Game

New Game setup brings league data, individual rosters, player capture, and game-clock rules into one adaptive flow.

02

No White-Out Needed

Goals and penalties remain editable throughout the game. Corrections update every affected display and statistic.

03

Summary Scripts

Readable scripts help the scorekeeper announce every event. Connected audio could even speak the script for them.

04

Officials Sign-Off

Recent Events becomes an official sign-off surface at the end of the game. Each signature is captured and confirmed independently.

05

Printable Game Boxscore

TallyTracker wraps up the game in a printer-friendly Boxscore view.

06

App Themes

TallyTracker supports Blue and Black themes. The case study uses Blue for continuity; the interaction model stays identical.

Blue
Black

Design and development with AI

AI accelerated production. It did not replace ownership.

I came to Codex with the habits built over a career in product teams: understand the problem, capture the requirements, resolve the risky interactions, and give the people building it enough context to make good decisions. This time, AI was the team helping me build it.

I knew detailed specifications would help Codex connect rules across the system, expose contradictions, and take useful initiative. That preparation mattered. Most iteration was spent improving fidelity and behavior, not recovering from a misunderstood product.

I also did more hands-on design than I first expected. Codex could extrapolate, but when visual precision mattered it was faster for me to return to my design tools, show the exact adjustment, and let implementation continue from there.

01

Context before code

Discovery, requirements, sketches, and flows gave the build a stable foundation.

02

Judgment stayed human

I decided when words were enough and when a concrete design would settle the issue faster.

03

The prototype talked back

Running software clarified behaviors static artifacts could not, then informed the next design decision.

From sketches to system

The lifecycle of my experience designing with AI.

The artifacts were not ceremony. They were a shared language between the design intent and the system Codex was building.

Discovery work before the first prototype screen was coded.
01. Number the interfaceEvery area of the framework had a stable visual reference.
02. Connect the specificationRequirements named the image and the exact area they governed.
03. Preserve decisionsWorking Notes kept product choices out of the chat scroll and inside the project record.
04. Return to the designWhen implementation exposed ambiguity, a focused sketch resolved it.

Hands-on design was still required

Knowing when to draw was part of directing the work.

The more exact the visual question became, the less useful another paragraph was. I moved back into the design tools, made the decision visible, and handed that clarity back to Codex.

One month of iteration

Refinement. No reset.

Because discovery had resolved the foundation, iteration mostly improved fidelity, state behavior, and edge cases. Even a late requirement such as official sign-off could be added without destabilizing the product.

  1. 01

    Discover

    Mapped rink-side tasks, failure points, league data, and the realities of youth-hockey scorekeeping.

  2. 02

    Specify

    Converted the concept into structured feature, interaction, state, and display requirements.

  3. 03

    Resolve

    Used conditional flows to settle roster, clock, period, penalty, and empty-state behavior before coding.

  4. 04

    Prototype

    Built the complete lo-fi interaction model and corrected edge cases against a functioning system.

  5. 05

    Refine

    Returned to visual design tools when an exact layout was faster to communicate than another paragraph.

  6. 06

    Present

    Created two visual themes, live feature demonstrations, a guided journey, and an open sandbox.

Joe Kubiniec working at the scorekeeper’s bench beside an ice rink

It's about the user

Designed from the scorekeeper’s bench.

Growing up a hockey fan in Buffalo, New York, an opportunity to work with LECOM Harborcenter and the many youth leagues they support sounded like so much fun! I had no idea it would spark such creativity.

Before I knew it, I was working the scorekeeper’s bench. I controlled the game clock, manually entering goals and penalties on paper scoresheets. Getting to play the game-break music and announce the goals over the rink loudspeaker made the Rick Jeanneret in me smile.

I worked as a scorekeeper for ten months. Hundreds of hours. Behind the glass. With the teams. And with the LECOM staff.

The paper-based system of scorekeeping seems so ordinary: paper scoresheets, barely legible handwriting, strike-throughs, and criss-crossing notes -- and not just mine!

Manual transcription into league databases is as frustrating as it is prone to errors. Semi-pro and professional leagues can afford complicated, integrated scoreboard and tablet-based scorekeeping. Youth leagues usually cannot.

Youth leagues have embraced technology. Their schedules, statistics, and game results already live online. Limited resources prevent many of them from doing much more than they have always done.

It doesn’t have to be that way. Ten months behind the scorekeeper’s bench for youth hockey games showed me there is a better way.

And I call it TallyTracker.