Bruno DelorenceBruno
Appearance
Appearance

Choose your reading theme.

Contact

Activation checklist

New

A new account’s setup steps as a card: progress in thin ticks that fill with a spring, a Start that runs each step, locked steps that say why, and a celebration at the end.

activation-checklist/activation-checklist.tsx
Live · interactive

Hello Maren!

Finish each step below to get your account fully up and running.

Your account is active

All 6 steps are done, Maren. Everything is ready for you.

  1. Set up your company

    Legal name, incorporation date and share classes.

    Done
  2. Invite your team

    Bring in co-founders, finance and legal to share the work.

  3. Add shareholders

    Enter them one by one, or import your cap table.

    Invite your team first: a second admin signs off the cap table.
  4. Record a valuation

    See what each share is worth and who owns what.

  5. Create an option pool

    Set aside options from a template, or from your own plan.

  6. Send your first offer

    Grant options with a ready-made letter, signed online.

The live component, numbered part by part. Every measurement is read from it as it is drawn. Point at a row to outline its part, or at a part to find its row.

The choices it offers, each value drawn live and the default marked, with how to pick one.

When to use

  • The first days of a new account, when a handful of setup steps decide whether the product is any use: company details, people, records, a first real action.
  • Setup with an order to it, where one step needs another first and people should see why a step is waiting instead of a disabled button.
  • A home or dashboard slot the checklist can own until it is done, then fold into a one-line summary that can be opened again.
  • Steps that can each start from the list itself: an import, an invite, a form in a side panel, each reporting back when it is finished.

When not to use

  • A single linear form. Use a stepper or a multi-page form; the checklist is for separate tasks done in any order.
  • More than eight or nine steps. Group them into stages, or people stop reading the list.
  • Tasks that never end, such as weekly reviews. Use a to-do list; this one celebrates once and folds away.
  • Guiding someone around the interface. Use a tour or hints anchored to the controls; the checklist only says what is left.

Running a step

  • Start calls runStep with the step’s id: open a side panel, an import, an invite form, and resolve the promise once the step is really done.
  • While it runs, the same button shows a spinner and Working, and the dark Start moves on to the next step that can run.
  • A rejected promise puts the Start back and says the step didn’t finish, so the person can try again.
  • Without runStep, Start just waits a moment and marks the step done: fine for a preview, never for a real account.

When every step is done

The last step bursts confetti from the party popper, runs a wave along the ticks, and folds the list into a summary with doneTitle, doneText and Review steps. It celebrates once: when the account opens with every step in defaultDone, the summary is already there, folded and still. Take the card off the page once the person has seen it a few times.

Each one drawn with the component itself, used well or badly.

The card is read in a few seconds: what is left, and what each step will ask for.

  • Step titles start with a verb, in sentence case with no full stop: Invite your team, Record a valuation.
  • One line under each title on what the step involves or gives back: Enter them one by one, or import your cap table.
  • The subtitle says what finishing gets them, not how many steps there are: the bar already shows that.
  • A lockedHint names the step that comes first and why: Invite your team first: a second admin signs off the cap table.
  • The doneTitle states the outcome: Your account is active, Round closed. Keep celebration to the confetti; no exclamation marks in the summary.

You can add this component with the shadcn CLI or by hand:

Into components/activation-checklist of any React project, with no setup:

Terminal
npx shadcn@latest add https://brunodelorence.com/r/activation-checklist.json

Either way it needs React 19 and a bundler that supports CSS Modules, such as Next.js or Vite. It has a dark colour scheme: it follows your page’s color-scheme, light unless the page sets one, or its colorScheme prop, with nothing to configure. Browsers without light-dark() show it light.

Usage

welcome.tsx
import { ActivationChecklist } from './activation-checklist';export function Welcome({ user, done }) {  return (    <ActivationChecklist      name={user.firstName}      defaultDone={done}      runStep={(id) => openSetup(id)}      onStepComplete={(id, percent) => track('step_done', { id, percent })}      onComplete={() => track('activated')}      autoplay={false}    />  );}

Each state below is a live instance, locked so you can study it.

The pieces it is built from, each with its measurements read live.

Below are variations of this component, each live, with its code.

Funding round

Four steps to close a seed round in blue, none done yet, with signatures waiting on the term sheet and the funds on the signatures.

Compact rows

Compact rows in green on a bar of forty ticks, half the steps done and the valuation next.

All done

Every step done in violet: the list folded into the summary, with Review steps.

Eight steps

A migration from spreadsheets in eight compact steps on sixty-four ticks, two of them waiting on others.

The card an equity-management product shows a new account until it is set up. Hello and a first name, a line on what is left, and progress as fifty thin ticks that light in amber from the left while the percentage rolls. Each step is a row with its icon, title and line: done steps say DONE, the next recommended one has the dark Start, a step that needs another first says NOT STARTED and why on hover or focus, and the rest have an outlined Start. Start runs the step, the row turns done, the dark Start moves on and waiting steps unlock; the last one bursts confetti from the party popper and folds the list into a summary that opens again. Light and dark.

  • Progress is the share of the steps’ weights that are done, so a heavy step can count for more (the company is 20% here). The bar is a row of ticks, each a little under half its share of the width; the number lit is that share of the ticks, rounded.
  • When the share grows, the ticks that light are told how far they are from the last lit one: each waits that many beats (34 ms) before its colour changes and it pops taller on a spring, so the fill runs from the left. A smaller share, after a reset, just fades back.
  • The percentage is a column of 0–9 per digit, slid to its digit with the same spring, so 20 rolls up to 35 instead of jumping.
  • Each step’s status comes from the rest: done, running, locked while a step it `requires` is not done, or free. The first free step in the list is the recommended one and takes the dark Start; when it starts, the dark Start moves to the next free one.
  • Start calls `runStep` (or waits a moment): the same button turns into a spinner and Working, so it keeps the focus, then the row turns Done with a small pop and the focus goes to the next recommended Start. A rejected promise puts the Start back.
  • A locked step’s status is a button that reads its hint as its description: hover, focus or a press shows it in a tooltip to the left, naming the step that must come first. When that step is done, the lock goes and the live region says what unlocked.
  • The last step bursts confetti from the party popper and runs a wave along the ticks; the summary grows in above the list, which folds away a moment later (grid rows from 1fr to 0fr). Review steps opens it again.
  • While on screen and untouched, a demo pointer shows why a step is locked, then presses each recommended Start until the account is active, and opens the steps again. Any real input hands it over; it comes back after 8 s of quiet.
PropTypeDefaultDescription
stepsActivationStep[]EQUITY_STEPSThe steps in their recommended order: id, title, description, icon, and optionally a weight, the step ids it requires and a lockedHint. ROUND_STEPS and MIGRATION_STEPS are exported too.
namestring'Maren'The first name in the greeting.
subtitlestring—The line under the greeting while steps remain.
defaultDonestring[]['company']Step ids done at first.
doneTitlestring'Your account is active'The summary’s title once every step is done.
doneTextstring—The summary’s line; it counts the steps when left out.
ticksnumber50How many ticks the progress bar has.
accent'amber' | 'blue' | 'green' | 'violet''amber'The colour of the ticks, the percentage and the summary, in both schemes.
density'comfortable' | 'compact''comfortable'Compact rows have smaller tiles and type, for a sidebar.
defaultStateActivationChecklistState—Opens locked in a moment, with the demo off: the steps done, one in progress, a locked step’s hint showing, or the list open under the summary.
runStep(id: string) => Promise<void> | void—What Start does. The row shows its spinner until the promise settles; a rejection puts the Start back.
onStepStart(id: string) => void—Called when a step starts.
onStepComplete(id: string, percent: number) => void—Called when a step is done, with the new percentage.
onComplete() => void—Called once every step is done.
autoplaybooleantrueWhile on screen and untouched, a demo pointer starts each step in turn. Any real input stops it.
colorScheme'light' | 'dark' | 'system'—Light or dark colours, or the reader’s; without it, the page’s color-scheme.
classNamestring—Classes for the stage.

Progress

The bar is a progressbar whose value text reads the percentage and how many steps are done; the ticks and rolling digits are hidden from assistive technology. The percentage under them is at least 4.6:1 on the card in every accent and both schemes (WCAG 1.4.3, Contrast). Lit and unlit ticks are each at least 3:1 on the card (WCAG 1.4.11, Non-text contrast); they differ from each other by hue, so the percentage carries the exact value. The summary’s check is at least 3:1 on its accent circle: white by day, near-black by night.

Status in words

  • Done and Not started are words beside their dots, so the green and red never carry the status alone (WCAG 1.4.1, Use of colour).
  • Not started is an aria-disabled button described by its hint, and read as locked; hover, focus or a press shows the hint, and a press also reads it out.
  • The hint stays open while the pointer moves onto it, and Escape hides it from anywhere (WCAG 1.4.13, Content on hover or focus).
  • Each Start is named with its step, Start: Invite your team, so a list of Starts still makes sense out of context (WCAG 2.4.6, Headings and labels).

Focus and announcements

A running Start stays the same focusable button, named Working on and its step; when it finishes, focus moves to the next recommended Start, or to Review steps at the end. A polite live region says when a step starts, finishes, what unlocked and when every step is done (WCAG 4.1.3, Status messages).

Target size

Start is 34 px tall, 32 px on a narrow card and 28 px when compact, Review steps is 34 px, and Not started is at least 24 px tall, under 420 px too: all meet the 24 × 24 px minimum (WCAG 2.5.8, AA).

In this build

  • The card is a section named by its greeting, the steps an ordered list. Progress is a progressbar whose value text gives the percentage and how many steps are done; the ticks and rolling digits are hidden from assistive technology.
  • Each Start is named with its step (“Start: Invite your team”); while running it stays the same focusable button, aria-disabled, named “Working on Invite your team”. When it finishes, the focus moves to the next recommended Start, or to Review steps at the end.
  • A locked step’s Not started is an aria-disabled button described by its tooltip, so the reason is read on focus; hover, focus or a press shows it, and Escape hides it.
  • Review steps is a disclosure (aria-expanded, aria-controls) for the folded list, which is inert while folded. A polite live region says when a step starts, finishes, what unlocked and when every step is done.
  • Under reduced motion the ticks light at once without the spring, nothing pops or folds in motion, no confetti flies, and the demo never plays. The demo pointer is decorative.

The complete source behind this demo. Open source under the MIT license, © 2026 Bruno Delorence: copy it, change it, ship it.

activation-checklist.tsx
// Copyright (c) 2026 Bruno Delorence. MIT License.'use client';import {  useEffect,  useEffectEvent,  useId,  useMemo,  useRef,  useState,  type CSSProperties,} from 'react';import { EQUITY_STEPS, type ActivationStep } from './data';import { DemoPointer, runDemo, type Point } from './demo-pointer';import { Check, Chevron, Icon, Lock, Popper } from './glyphs';import { useAutoplay } from './use-autoplay';import styles from './activation-checklist.module.css';/* * Activation checklist: the card a new account sees until it has done the few things that make * the product useful. * * - A greeting, a line on what is left, and progress as a row of thin ticks that fill from the
activation-checklist.module.css
/* Activation checklist (activation-checklist.tsx): a white card centred on a light grey app   background, near-black by night. A greeting, a bar of thin ticks, then a stack of step rows on   a faint tint, each with its status at the right.   Colours are the tokens below, light-dark(light, dark) where the two differ: the component takes   the color-scheme it inherits from the page, or the one its colorScheme prop sets   (data-color-scheme). The accent (data-accent) sets the ticks, the percentage and the summary. */.root {  --stage: #f3f4f6;  --card: #ffffff;  --card-edge: #eceef1;  --row: #fafafa;  --row-edge: #ebebee;  --tile: #ffffff;  --tile-edge: #e4e4e8;  --icon: #3f3f46;  --ink: #18181b;  --ink-2: #52525b;  --sub: #4a5466;  /* Unlit ticks: 3:1 on the card, so the bar's length shows. The spinner keeps the paler track. */  --tick-off: #92929d;  --track: #e1e1e4;  --btn: #ffffff;
data.ts
// Copyright (c) 2026 Bruno Delorence. MIT License.import type { StepIcon } from './glyphs';/* * The steps the checklist shows by default: what a new account on an equity-management product * does before it can issue shares and options. The example sets are below them. */export type ActivationStep = {  id: string;  title: string;  /** One line under the title. */  description: string;  icon: StepIcon;  /** Its share of the progress; the steps’ weights are summed, so any scale works. Default 1. */  weight?: number;  /** Steps that must be done before this one can start. */  requires?: string[];  /** Why it is locked, shown on hover or focus. Built from `requires` when left out. */  lockedHint?: string;};export const EQUITY_STEPS: ActivationStep[] = [
glyphs.tsx
// Copyright (c) 2026 Bruno Delorence. MIT License./* * The checklist's drawings: line icons for the steps (24 × 24, drawn in the current colour), the * party popper beside the greeting (its own colours, the same on both schemes) and the small * marks in the buttons. */const PATHS = {  building: (    <>      <path d="M5 21V4.6C5 3.7 5.7 3 6.6 3h6.8c.9 0 1.6.7 1.6 1.6V21" />      <path d="M15 9h3.4c.9 0 1.6.7 1.6 1.6V21M3 21h18M9 21v-3.2h2V21" />      <path d="M8.5 7h.01M11.5 7h.01M8.5 10.5h.01M11.5 10.5h.01M8.5 14h.01M11.5 14h.01M17.5 13h.01M17.5 16.5h.01" />    </>  ),  team: (    <>      <circle cx="12" cy="7.2" r="2.2" />      <circle cx="5.9" cy="8.6" r="1.8" />      <circle cx="18.1" cy="8.6" r="1.8" />      <path d="M8.6 19.5v-3.6a3.4 3.4 0 0 1 6.8 0v3.6" />      <path d="M3 18.5v-2.3c0-1.7 1.3-3 3-3 .6 0 1.1.1 1.5.4M21 18.5v-2.3c0-1.7-1.3-3-3-3-.6 0-1.1.1-1.5.4" />    </>
demo-pointer.tsx
// Copyright (c) 2026 Bruno Delorence. MIT License.'use client';import type { CSSProperties, Ref } from 'react';/* * The demo's pointer, and the steps that move it. A demo is a script of awaited steps: wait, or * glide the pointer somewhere. Stopping the demo (the reader takes over, or it scrolls away) ends * the step in progress at once: its promise rejects, which ends the script right there, and the * pointer fades out. * * Each glide is a curved flight played by the Web Animations API, so nothing runs frame by frame. * The points of the flight are handed to whoever wants to move along with it. The arrow and the * hand are HTML boxes * that swap by their visibility: a change of style inside an SVG would lay the SVG out again. */export type Point = { x: number; y: number };/** A glide's path and timing, for an animation that plays along with it. */export type Flight = { points: Point[]; timing: KeyframeAnimationOptions };export type Demo = {
use-autoplay.ts
// Copyright (c) 2026 Bruno Delorence. MIT License.'use client';import { useCallback, useEffect, useRef, useState } from 'react';/* * When a demo may play on its own: while part of it is on screen and the tab is visible, never * under reduced motion, and not while the reader is using it. `take()` hands it to the reader; it * takes back over `idle` ms after their last input. */export function useAutoplay<T extends HTMLElement>(idle = 6000) {  const ref = useRef<T>(null);  const [visible, setVisible] = useState(false);  const [reduced, setReduced] = useState(true);  const [taken, setTaken] = useState(false);  const timer = useRef(0);  useEffect(() => {    const element = ref.current;    if (!element) return;    let onScreen = false;    const update = () => setVisible(onScreen && !document.hidden);    const observer = new IntersectionObserver(