George Ledger: $1 Federal Reserve Note Collection Tracker

An offline-first mobile catalog for U.S. $1 Federal Reserve Notes, enhanced with Codex to help collectors track ownership, identify missing notes, explore statistics, and generate reports.

Comment

Inspiration

I have been a collector for many years, with interests including banknotes, coins, awards, and other collectible objects.

Collectors often use spreadsheets, paper lists, general note-taking applications, or large online catalogs. These tools can store information, but they rarely match the actual workflow of a collector: browsing a structured catalog, recording owned items, tracking multiple physical specimens, identifying gaps, adding comments, and preparing collection reports.

I wanted to start with one clearly defined collecting area and build it properly. I chose U.S. $1 Federal Reserve Notes because they form a structured but non-trivial catalog with multiple Federal Reserve districts, series, print locations, star notes, grades, and physical specimens.

What it does

George Ledger is an offline-first Android catalog and collection tracker for U.S. $1 Federal Reserve Notes.

The application allows collectors to:

  • browse the catalog by Federal Reserve district or by banknote series;
  • switch between newest-first and oldest-first series ordering;
  • mark catalog positions as owned;
  • record the condition and comments for collected notes;
  • maintain multiple physical banknote specimens for the same catalog position;
  • record specimen-specific characteristics;
  • view collection statistics and completion rates;
  • distinguish catalog positions from the actual number of physical banknotes;
  • identify missing catalog positions;
  • generate detailed PDF reports, including a missing-only report;
  • back up and restore collection data;
  • use the application in English or Ukrainian.

The collection database is stored locally in SQLite. The core functionality works without registration, a cloud account, or a permanent internet connection.

How I built it

George Ledger is built with React Native, Expo, TypeScript, Expo Router, and SQLite.

The application already existed before OpenAI Build Week. During Build Week, I used Codex with GPT-5.6 to make a substantial extension rather than create an unrelated prototype.

I divided the work into separate feature branches and used Codex to audit the existing repository before each major change. This helped identify all affected layers, including the database schema, repositories, services, user interface, localization, statistics, PDF reporting, backup compatibility, and automated checks.

The main Build Week additions included:

  • full Ukrainian localization with persistent language selection;
  • navigation by Federal Reserve district or by series;
  • configurable series ordering;
  • missing-only PDF reports;
  • a new database model for individual physical banknote specimens;
  • specimen repositories, services, and management screens;
  • separate statistics for catalog positions and physical banknotes;
  • hierarchical collection reports;
  • backup format version 2 with specimen data and application settings;
  • Android layout, safe-area, compatibility, testing, and release-hardening improvements.

Codex assisted with repository analysis, implementation planning, code generation, migration logic, regression checks, and review of cross-cutting changes.

I remained responsible for the product concept, catalog structure, collector terminology, business rules, acceptance criteria, code review, and testing on physical Android devices.

The application itself does not require an OpenAI API connection. Codex and GPT-5.6 were used as development tools.

Challenges I ran into

The most difficult challenge was separating two concepts that initially appeared similar: an owned catalog position and an individual physical banknote.

A collector may own several specimens of the same catalog position. At the same time, existing users already had ownership and grade data that had to remain valid. Adding specimen-level tracking therefore required a compatible database migration, carefully defined counting rules, updated statistics, and a new backup format.

Another challenge was the number of connected features affected by each change. Navigation, localization, ownership, specimens, reports, statistics, backups, and Android layouts could not be treated as isolated components.

The application also had to remain useful offline and preserve existing collection data during upgrades.

Accomplishments that I'm proud of

I am proud that George Ledger evolved from a catalog-position tracker into a more realistic collection-management application.

It can now distinguish between:

  • positions defined by the catalog;
  • positions represented in the collection;
  • individual physical banknotes owned by the collector.

I am also proud that the Build Week work was implemented as a set of traceable feature branches and commits rather than as a disposable demonstration.

The result is a working Android application for a real collecting workflow, with localized interfaces, structured statistics, compatible backups, and printable reports.

Another important accomplishment is architectural: the specimen model and collection services are reusable beyond a single catalog implementation.

What I learned

I learned that Codex is most effective when it receives clear domain rules, explicit acceptance criteria, and tasks divided into verifiable stages.

GPT-5.6 was especially useful for analyzing changes that crossed several technical layers. It helped identify dependencies that could easily be missed when changing the database, interface, statistics, reporting, and backup logic at the same time.

However, AI assistance does not replace domain knowledge. Decisions about catalog semantics, collector terminology, data compatibility, and user experience still required human judgment.

I also learned that starting with a narrow collecting domain is a practical way to design a reusable architecture. Real requirements appear much faster when the application must support an actual collection rather than an abstract universal catalog.

What's next for George Ledger: $1 Federal Reserve Note Collection Tracker

The next steps for George Ledger are to expand the catalog model with additional banknote characteristics, improve filtering and collection-gap analysis, add direct searches for selected catalog positions on eBay and specialized numismatic marketplaces, and continue refining the specimen workflow based on collector feedback.

I also plan to evaluate which parts of the architecture can be extracted into a reusable collection-management core for future specialized catalog applications. Each application would preserve the catalog structure, terminology, and workflow required by its own collecting domain.

Built With

Share this project:

Updates