Skip to content
All projects

Case study · Founder

Tiny Tarrasque.
A character sheet that keeps up with the table.

Friends alpha: October 2026
Role
Founder: product, design & engineering
Platforms
Android, iOS & web from one codebase
Stack
TypeScript, React Native, Expo, Zustand, Jest
Status
Friends alpha Oct 2026 · Public beta Dec 2026
Character creator, step 1 of 7: choose your origin
A 7-step character creator
Live character sheet with combat stats and weapon attacks
The live sheet, built for the table
Attack roll result with arithmetic breakdown
Tap any bonus to roll
Spellcasting dashboard with spell slots and cantrips
Spells, slots and rests

The problem

Built for the desk, used at the table.

Most character sheet apps are designed for someone at a desk. At a real table the phone lies next to your dice for four hours: it has to stay awake, work offline, show the number you need at a glance, and never, ever lose a character.

And every group plays differently, with house rules, new books and homebrew. Hard-coding one rulebook into an app doesn't scale. So I built the rules as data and the engine to run them.

What it does

What it does at the table.

Guided character creator

Origin, class, background, abilities and gear in seven steps, with the rules explained where you need them.

A sheet that does the maths

Change anything and every derived number updates instantly: armour class, attacks, saves, spell DCs.

Dice built in

Tap a bonus to roll it, with advantage or disadvantage and a breakdown of exactly how the total was reached.

Spells, slots and rests

Track slots and concentration, and let short and long rests restore the right things automatically.

Architecture

Four decisions that keep later features small.

The engine doesn't know which game it's running. Everything specific to a game comes in as data.

  1. 01Rule packsfifth-edition SRD 5.2.1 as validated JSON
  2. 02Rules enginecharacter as a dependency graph
  3. 03Character storeversioned format + migrations
  4. 04App UIReact Native, offline-first

A rules engine that knows no game

The engine evaluates a character as a directed acyclic graph of typed value expressions (constants, references, per-level tables, dice, sums and min/max). Game terms are banned from the engine package, with a grep check to catch any that slip in. That keeps the engine small and lets new rules arrive as data instead of code changes.

Rules live in data files

The fifth-edition SRD 5.2.1 lives in validated JSON rule packs. Adding a class means adding data, and homebrew will later drop in as one more pack you can switch off.

Never lose a character

Every save uses one versioned character format that passes through a migrations module, and old saves are protected by fixture tests. Imports are treated as untrusted: size caps, schema checks, and data that can never execute code.

Designed for a phone on the table

Offline by default, with keep-awake and big readable results. There are hard budgets too: a cold start under 2 s on a mid-range Android phone, a recompute under 16 ms, and three taps or fewer for any common action.

How it's built

One person, a team of agents, and the process that keeps them honest.

from first commit to a playable app
6 weeks
commits
110+
test files
85
public beta target
15 Dec

Context as code

A root CLAUDE.md plus one per workspace encode the non-negotiables: no game terms in the engine, SRD-only content, and loading old saves must never break.

Specialised sub-agents

A rules-engine developer and a mobile developer agent, each scoped to its own package and conventions.

Checks before anything ships

A verify step (a TypeScript build plus 85 test files) must pass, CI runs on every PR, and a ship-check runs before any PR opens. One branch, one PR per task.

Memory and planning

Architecture decision records and a STATUS hand-off capped at 15 lines, so every session starts with the right context. Roadmaps and trade-offs get worked through with Claude in shared docs; the decisions, and the cut list, stay mine.

Roadmap & business

Each phase ends with a real player test.

Each milestone has a usability gate tested with a real player. For the beta, a stranger installs the app from the store listing, builds a character and plays levels 1–5 without help. If a gate fails, the next phase starts by fixing it, and dates only move by cutting scope.

  1. Oct 2026

    Friends alpha

    Fighter and Wizard, over-the-air updates, and weekly releases driven by what testers struggle with.

  2. Dec 2026

    Public beta

    All 12 classes, homebrew import v1, crash reporting, and builds in the app stores.

  3. Mar 2027

    v1.0

    Accounts, cloud sync and automatic backup. Sync is the first reason to pay.

  4. 2027 →

    Grow

    Party and GM view, AI backstories inside the subscription, then a rule-pack SDK for publishers.

What this shows

If you're hiring a CTO or founding engineer.

Tiny Tarrasque is a small product with serious foundations. It's how I'd approach a startup's first product: find the real problem, make the few decisions that keep everything else cheap, and ship in small steps that real people test.

Want to test it at your table?

The friends alpha starts in October, Android first. Drop me a line and I'll send you a build.