Web app • Design engineering • Personal project • 2026

21.1: a running dashboard I designed and built

Role

Product, design and build

Team

Solo, with Claude Code as my pair

Timeline

2 days for v1, November 2026

Status

Live and in use until race day, 21 Feb 2027

A personal running dashboard for my first half marathon that turns my Garmin data into a few numbers in plain language. I designed it and built it end to end with Claude Code, from the data to the deploy.

The problem

I started running seriously in August 2026, training for the Media Maratón de Alicante. After every run I’d open Strava or Garmin Connect, and both gave me more numbers than I could use. They told me what happened, but not what it meant for my training or my race.

I wanted the opposite: fewer stats, in plain language, compared with my own past runs instead of general averages. And everything pointed at one goal: 21.1 km in under two hours, ideally 1:50.

Launch screen, Latest run and the new-run moment

The launch screen, the Latest run screen and the new-run moment with personal bests.

Why I built it myself

I’m a product designer, and I want to work closer to code as a design engineer. Prototypes alone weren’t going to get me there. I needed one real project that took me through the whole chain: data, database, AI, deploys and Git.

A tool I’d use three times a week, for a race I’m actually running, kept the stakes real.

Goals and constraints

  • The data has to be right. I make training decisions from these numbers, so nothing could be assumed or quietly rounded.

  • Phone first. I open it straight after a run, so it’s a web app that installs on the home screen, not a native app.

  • Private. It’s my health data, so the whole app sits behind a lock.

  • Calm, not busy. Every number on screen has to earn its place.

Deciding what v1 is

v1 covers the latest run, comparisons with my own runs, a race panel, run history, Garmin sync, a private login and AI-written insights. Music during runs moved to v2.

I pulled AI insights into v1 on purpose. Explaining the numbers in plain language was the core idea, so leaving it out would have meant shipping just another stats screen.

How I worked

  • Claude Code in VS Code as my pair programmer. A CLAUDE.md file set the rules: short, plain-language explanations, ask before touching any external account, and teach me the real workflow.

  • A real Git workflow. Every feature got its own branch and pull request, 27 in total. I did the commits, pushes, PRs and merges myself, because learning that loop was part of the point.

  • Design in code, not Figma. I explored the screens on a design canvas, saved the chosen mockups into the repo as references, and built the screens to match them.

Workflow stack

  • Claude Code: my pair programmer, writing and explaining code under the rules in CLAUDE.md.

  • VS Code: where I read the code, ran the app locally and worked with Claude Code.

  • GitHub: branches and pull requests for every feature, 27 in total.

  • Supabase: the Postgres database for runs, laps, plans and insights.

  • Vercel: hosting and deploys, with every merge going live.

In the app: the Garmin API for run data, and the Claude API for the plain-language insights and reading my coach’s weekly plan.

Trust the watch, label what’s calculated

The app uses Garmin’s own values wherever they exist, and every database column has a note saying where its value comes from. Splits are the watch’s own laps, read from the raw FIT file. A check script compares my last runs across three sources (Garmin’s summary, the FIT file and my database) and flags any difference.

That check earned its keep early on. My first version worked out per-km splits itself, and they didn’t match Garmin Connect. So I switched to the watch’s own laps, short final lap included. Now what I see is exactly what the watch recorded.

Heart rate zones I can compare

Garmin works out zone times with whatever settings the watch had that day. So when my settings changed, last month’s “Zone 2” stopped meaning the same as today’s.

The app recalculates zone times for every run from the raw heart rate readings, with one set of settings. When a run has no raw readings, it says so rather than quietly mixing the two methods.

The AI explains, the code calculates

The “What this means for you” insights are split in two. Code works out every fact: pace, zones, first half against second half, my last five runs of the same type, race targets and days left. Claude only turns those facts into plain language.

A number guard checks every number in the AI’s text. If one isn’t in the facts, the AI gets one retry, and if it fails again, nothing is saved. Each insight is tagged “AI generated”, and the app records which model wrote it and what it cost.

My coach’s plan, in the app

My nephew coaches me, and he sends my weekly plan as a WhatsApp message in Spanish. I paste it into the app, Claude turns it into sessions, and I check them side by side with the original before saving. His paces are in km/h, so code converts them, not the AI.

Each run then links to its session, so I can see what was planned against what my watch recorded.

Privacy as a design detail

The whole app sits behind a password that’s checked on the server. The share card, a story-sized image of a run, leaves out the first and last 300 m of the route so it never shows where I live, and the image contains no coordinates.

Share card for a run

The share card: one run, story-sized, with the route trimmed so it never shows where I live.

Design system: Stone & ink

  • Monochrome, so colour means something. Heart rate zones are the only colour in the app, running from cool to warm. Each zone also has a label, so colour is never the only cue.

  • Tokens for everything: colour, radius, type, spacing and motion, in a light and a dark theme.

  • A race timing look: monospace labels, hairline borders, a ruler and a course track, like a race clock or a timing sheet.

  • Moments, not just screens: a launch screen counting the days to Alicante, a new-run moment with personal bests, and 21.1 as the home-screen icon.

  • Accessibility built in: text on photos is at least 4.5:1 contrast, tap areas are 44px, and all motion turns off with reduced motion.

How the look evolved

  1. Old navy. A first pass at the run, race and history screens in navy and ice.

  2. Stone & ink. I went monochrome so only the heart rate zones carry colour, then added dark mode, more space between sections, and cut the elevation profile.

  3. Three directions for the Latest run screen: a weather photo with glass cards, a calm and immersive version, and a race timing look.

  4. Race timing won, and I rolled it out to the Race, Plan and History screens.

Race timing won because it gave the app an identity of its own, borrowed from the world I’m training for, rather than looking like one more wellness app. For personal bests I combined two of the options I explored: a list of only the records a run sets, each showing how much it beat the old best by.

Four versions of the Latest run screen

Stone & ink in light and dark, the photo and glass direction, and race timing, the one that won.

Run, Race, Plan and History screens

Race timing across the app: Run, Race, Plan and History.

What was hard

  • Numbers that almost matched. “Almost” isn’t good enough when you plan training from it. Getting pace, laps and calories to match Garmin exactly meant reading the raw FIT file and checking against two sources.

  • Zones that quietly changed meaning. It took a while to see that Garmin’s zone times depend on that day’s settings. Fixing it meant recalculating from raw readings and labelling the result.

  • An AI that was too helpful. Left alone, it would round, estimate or invent a number to make a sentence read better. The fix was structural: code owns the facts, and anything outside them is rejected.

  • Making a website feel like an app. Home-screen install, the status bar, safe areas and a photo reaching behind the iPhone clock. Small details, each with its own platform rule to learn.

Outcome

A live app I use after every run: Run, Race, Plan and History screens, automatic Garmin sync, AI insights, personal bests, share cards and dark mode. My coach’s plan, my watch and my race goal now live in one place, instead of WhatsApp, Garmin and my head.

v1 took two days: 27 pull requests, 60 commits and 12 database migrations. The real test is race day, 21 February 2027.

What I learned

  • Data is a design material. The most important design decisions weren’t visual. They were about where each number comes from, and how honestly the app labels it.

  • The workflow is the skill. Branches, pull requests, migrations, environment variables and deploys stopped being scary words once I’d done each one myself, again and again.

  • Designing in code changes what you design. Empty weeks, missing heart rate data and reduced motion all came up because real data made me face them. A static mockup would have let me skip them.

  • AI is a great pair, with guardrails. Claude Code moved fast, and the CLAUDE.md rules kept it working the way I wanted. In the product, the AI is most useful when it explains things and never gets to decide the facts.

Next

Music during runs is planned for v2, and the elevation profile comes back once it earns its place. It’s built, just hidden.

Rodrigo Araya Sandoval · Product Designer

I make complicated things feel simple.

I’m a product designer in Helsinki. I work closely with sales, strategy and product to shape what gets built: from stakeholder interviews and research to early prototypes and the final details. Recent work includes booking and healthcare products at BeeHealthy and retail planning tools at Relex.

Most of this work is confidential client work, so the portfolio is password protected. Have the password? Enter it below.

Don’t have it yet? Send me a short note about who you are and I’ll get back to you with access.