Skip to content
Concept project Fintech20259-week scope

Ledgerly

Rebuilding onboarding around the first useful moment

A concept study in fintech activation design — replacing a nine-step administrative setup with a path that reaches a real reconciliation in three, and deleting the checklist that was measuring the wrong thing.

Ledgerly first run — a sample ledger reconciling on load
Project type
Activation & onboarding redesign
Industry
Fintech
Timeline
9-week scope · 2025
Platform
Web applicationResponsive, mobile-first setup
Services
SaaS DesignProduct DesignFrontend Engineering
Technologies
FigmaNuxt 3TypeScriptTailwind CSS
The challenge

What made this hard

Ledgerly is a scenario built around the most common misdiagnosis in activation work. A team sees low completion on an onboarding checklist and concludes the checklist needs better copy and progress indicators. Looking at the funnel first tells a different story, and it is a story about sequence rather than presentation.

  1. The brief was to fix the wrong artifact

    Improving the checklist would have improved a number that does not matter. In the scenario, users who complete setup convert at almost the same rate as users who abandon it — which is the signal that completion is not predictive of anything.

  2. Nine administrative steps before anything useful

    Creating an organisation, inviting a teammate, connecting a bank feed, waiting for a sync, configuring a chart of accounts, connecting the accounting integration, mapping accounts, setting a rule, running a batch. Only the last one is the product.

  3. The wait is invisible and unexplained

    A bank feed sync takes minutes and shows a spinner. Several users in the scenario assume the product is still installing itself and close the tab — a failure that looks like churn and is actually a missing status message.

  4. Trust has to be earned before data is handed over

    Connecting a bank feed is the highest-anxiety moment in the flow, and the current design asks for it before the user has seen the product do anything at all.

  5. Setup is not one job

    The person signing up and the person who will configure the chart of accounts are frequently different people. A single linear wizard assumes one person with all the answers, and stalls the moment that is false.

Scenario & premises

The situation we designed against

The premises below define the scenario. The central one — that there is a single identifiable moment where the product becomes comprehensible, and that everything before it is overhead — is the assumption the whole redesign rests on, so it is stated plainly rather than buried.

The first useful moment is the first completed reconciliation
Not the signup, not the bank connection, not the checklist. The moment a user sees a real match against their own data that they did not have to make by hand.
Checklist completion does not predict conversion
We set completion deliberately high — around two thirds — so that the checklist cannot be blamed. A well-completed checklist that predicts nothing is a measurement problem, not a motivation problem.
Reaching first value takes about 47 minutes
Most of it administrative, and a meaningful part of it waiting on a sync with no explanation of what is happening.
Abandonment is often a misunderstanding
We assume a share of users who leave during the sync believe setup is still running. They have not rejected the product; they think it has not started.
The signup and the configuration are different jobs
Often different people, sometimes days apart. Any flow that requires all answers in one sitting fails on this.
Sample data is acceptable if it is labelled
We assume users will accept a demonstration on sample data before connecting a real account, provided it is unmistakably labelled and takes one action to replace.
Who it is for

The people we designed for

Aisling Byrne

Aisling Byrne

Owner, eleven-person design studio

Does the books herself on a Friday afternoon because nobody else will. She is evaluating Ledgerly in a browser tab beside four others, and will give it about ten minutes before deciding it is another thing to set up.

“I do not want a tour. I want to see it do the thing once, with my numbers, and then I will decide.”

Goals

  • Find out quickly whether this will actually save her Friday afternoons
  • Avoid connecting bank credentials to something she has not evaluated
  • Not have to understand accounting vocabulary to get started

Frustrations

  • Asked to invite a teammate before she knows if the product works
  • A chart-of-accounts step she does not have an opinion about yet
  • A spinner with no indication of how long it will run
Tomás Ferreira

Tomás Ferreira

Finance operations, 60-person scale-up

Inherits the account after someone else signed up. He is the person who actually configures the chart of accounts and the reconciliation rules, and he arrives days after the trial started.

“Someone else clicked through this. I need to know what they agreed to before I trust any of it.”

Goals

  • Pick up a half-configured account without starting over
  • Map accounts properly rather than accept a guessed default
  • Understand what the previous person already decided

Frustrations

  • A linear wizard that assumes one person answers everything at once
  • No record of which decisions were defaults and which were chosen
  • Setup state that cannot be revisited without resetting it
Journey map

Where the current experience loses them

01

Signup

02

Invite teammates

03

Connect bank feed

04

Wait for sync

05

Configure accounts

06

First reconciliation

Doing

Enters email and password, names the organisation.

Feeling

Positive

Doing

Asked to invite colleagues before seeing the product.

Feeling

Frustrated

Friction

She has nothing to invite them to yet, and skipping feels like doing it wrong.

Opportunity

Move invites to the moment collaboration is first needed.

Doing

Asked for bank credentials on the third screen.

Feeling

Frustrated

Friction

Highest-anxiety action in the flow, requested before any value is shown.

Opportunity

Demonstrate on labelled sample data first, connect afterwards.

Doing

Watches a spinner for several minutes with no status.

Feeling

Frustrated

Friction

No indication of duration or progress. Reads as a stalled installation.

Opportunity

Make the wait explicit and fill it with something useful.

Doing

Asked to set up a chart of accounts and map them.

Feeling

Frustrated

Friction

A decision she has no basis for making yet, and often not her job.

Opportunity

Infer a starting map, defer the review until the first batch runs.

Doing

Finally sees a real match complete.

Feeling

Positive

Opportunity

This is the moment. Everything before it is cost — move it here.

Scroll the map horizontally to see every stage.

Checking the brief before accepting it

Ledgerly's brief is to redesign the onboarding checklist. The most useful thing this project does is spend a week deciding not to.

The funnel in the scenario tells a specific story. Checklist completion is around two thirds, which is respectable. But users who complete the checklist convert at almost the same rate as users who abandon it. That single comparison is the whole diagnosis: if finishing a sequence does not predict the outcome, then improving how many people finish it cannot help. The checklist is doing its job faithfully. Its job is the problem.

This is worth dwelling on because the alternative project — better copy, a progress ring, a celebratory animation on completion — is a real project that teams ship every quarter, and it produces a measurable improvement in a metric that does not connect to anything.

Finding the moment

The redesign needs a target, and the target is the first moment the product becomes comprehensible.

For Ledgerly that is a completed reconciliation: a real match, on data the user recognises, that they did not have to make by hand. Not the signup, which is just admission. Not the bank connection, which is cost. Not the checklist, which is a description of cost.

Reaching that moment takes nine steps and around 47 minutes, and eight of the nine steps are administration. Once the target is named, the design work is mostly subtraction with one question asked repeatedly: does this have to happen before the first reconciliation? Teammate invites do not. The chart of accounts does not. The accounting integration does not. Six of the nine move.

They do not disappear — that is the part worth being precise about. They are asked later, in the product, at the point each one is first needed. An invite prompt when a match needs a second opinion is a different request from the same prompt on screen two, even though the form is identical.

Sample data is a real risk

The decision most likely to backfire is demonstrating on sample data.

The logic is sound: the highest-anxiety action in the product is handing over bank credentials, and the current flow asks for it before showing anything. Move the demonstration first and the user decides with evidence.

But users in this scenario explicitly say they do not want a tour, and a sample ledger is one bad execution away from being a tour. If the sample data is too clean, it demonstrates a product that does not exist — every transaction matching neatly, no ambiguity, no partial matches. The user's real ledger will not look like that, and the gap between the demo and the first real batch is where trust is lost rather than built.

So the sample is deliberately messy. It includes a partial match, one transaction the product cannot classify, and a duplicate. It demonstrates the product handling difficulty, which is the only demonstration worth making.

What we gave up

A clean activation metric. Deleting the checklist removes the number the team reports weekly, and nothing replaces it as a single figure. Time to first reconciliation is the honest measure and it is harder to instrument, noisier, and much less satisfying on a slide.

A sense of completion. Some users like a checklist, and progressive setup means there is no moment where a badge says setup is done. The account is permanently, honestly, partially configured. We think that is more truthful than a completed list that hides the same gaps, but it does feel worse.

Determinism. An inferred account map that is subtly wrong is more dangerous than an empty form, because it can be accepted without being read. Marking every inferred row helps the careful user and the second person picking the account up. It does nothing for the person who clicks straight through, and that person exists.

Strategy & structure

What we decided before drawing anything

  1. The first useful moment is the deadline

    Every step in the activation path is measured against one question — does this have to happen before the user sees a reconciliation complete? Almost nothing does.

  2. Ask for a thing at the moment it is needed

    Teammate invites when there is something to collaborate on. Account mapping when the first batch needs it. A question asked in context is a different question from the same one asked in a wizard.

  3. Earn the credentials

    The highest-anxiety action in the flow happens after the product has demonstrated what it does, not before.

  4. Never make waiting invisible

    Every wait states what is happening, roughly how long it will take, and what the user can do meanwhile. A spinner with no duration is indistinguishable from a failure.

  5. Setup is resumable and inspectable

    A second person arriving days later can see what was decided, what was defaulted, and what is still open — without resetting anything.

  6. Progress is a state of the product, not a checklist

    What remains to be configured is shown where it is relevant, in the product. A separate panel tracking a sequence is an admission the sequence is not self-evident.

Information architecture

How the product was reorganised

Entry

Three fields, then straight into the product. No wizard, no tour.

  • Signup

    Email, password, country — nothing that can be inferred or deferred

  • Workspace

    Created automatically and renameable later

Demonstration

A labelled sample ledger that reconciles immediately, so the product explains itself by working.

  • Sample batch

    Runs on load, unmistakably marked as sample data

  • Replace with real data

    One action, available from the first screen onward

Connection

Requested after the demonstration, with the wait made explicit.

  • Provider search

    Institution picker with a stated data-access scope

  • Sync status

    Named stages and an estimated duration, never a bare spinner

Configuration

Progressive. Each item surfaces at the point the product first needs it.

  • Account map

    Inferred from the first batch, presented for review rather than authored

  • Rules

    Offered after a repeated manual match, not before

  • Teammates

    Offered when a match needs a second opinion

Setup state

For the second person. What was decided, what was defaulted, what is open.

  • Decision log

    Distinguishes chosen values from defaults

  • Open items

    Surfaced in place, not as a separate checklist

User flows

Before and after, step for step

Reaching the first reconciliation

The core flow. Six of the nine original steps still exist — they happen after this path completes, at the point each one is first needed.

9 to3steps, −6

Before

  1. Sign up
  2. Create organisation
  3. Invite a teammate
  4. Connect bank feed
  5. Wait for sync
  6. Configure chart of accounts
  7. Connect accounting integration
  8. Map accounts
  9. Run first batch

After

  1. Sign up
  2. Run the sample batch
  3. Connect and re-run on real data

Connecting a bank feed

The same underlying steps, with the wait made legible. The change is entirely in what the interface says while nothing is happening.

3 to4steps

Before

  1. Choose institution
  2. Enter credentials
  3. Spinner

After

  1. Choose institution
  2. Read the data-access scope
  3. Enter credentials
  4. Watch named sync stages with an estimate

Setting up the chart of accounts

Changed from an authoring task to a review task. Reviewing a wrong guess is far easier than producing a right answer from nothing.

4 to2steps, −2

Before

  1. Open settings
  2. Read documentation
  3. Create each account
  4. Map each account

After

  1. Review the inferred map after the first batch
  2. Correct what is wrong
Interface decisions

The choices that shaped the product

Each of these could reasonably have gone the other way. What follows is the argument for the direction taken, and what it gave up.

  1. Demonstrate on labelled sample data before asking for credentials

    Bank credentials are the highest-anxiety request in the product, and the current flow makes it before the user has seen anything work. That is asking for maximum trust at the moment of minimum evidence.

    What we did

    A sample ledger reconciles on first load, unmistakably marked as sample data, with a single action to replace it with a real connection.

    Why

    It moves the demonstration before the ask. The user learns what a reconciliation is, what the product does to it, and what they would be getting — and only then decides whether to connect an account.

    What it cost

    Sample data risks reading as a canned demo, which is exactly the "tour" users say they do not want. The mitigation is that it is fully interactive and one click from being replaced — but if the sample looks too tidy, it undermines the credibility it exists to build.

  2. Delete the onboarding checklist

    The checklist is well-completed and predicts nothing. Keeping it means continuing to optimise a metric that does not connect to the outcome, and it occupies the persistent panel that could show something useful.

    What we did

    Removed entirely. What remains to be configured surfaces in place, at the point in the product where it is relevant.

    Why

    A checklist is an admission that the sequence is not self-evident. Fixing the sequence removes the need for the meta-layer describing it.

    What it cost

    Real losses. Some users genuinely like a visible sense of progress, and the team loses a clean funnel metric that was easy to report on. Nothing replaces it as a single number, and stakeholders who track it weekly will feel that keenly.

  3. Infer the account map, then ask for review

    Configuring a chart of accounts is a decision most trial users have no basis for making, and frequently not their job at all. It is where the linear wizard stalls.

    What we did

    Infer a starting map from the first batch of transactions, then present it for correction after the batch runs.

    Why

    Reviewing a wrong guess is a much smaller cognitive task than producing a right answer from an empty form, and the transactions themselves are the best available evidence for what the map should be.

    What it cost

    An inferred map that is subtly wrong is more dangerous than an empty one, because it may be accepted without scrutiny. Every inferred row is marked as inferred and the decision log records it as a default rather than a choice — which helps the second person, and does nothing for the first person who clicks through.

  4. Make the sync wait explicit

    A multi-minute spinner with no status is indistinguishable from a broken installation, and in the scenario it is a meaningful share of the abandonment.

    What we did

    Named stages, an estimated duration, and a clear statement that the user can leave and come back. The sample ledger stays interactive throughout.

    Why

    Almost all of the pain here is uncertainty rather than duration. Naming the stages converts an unexplained delay into a process, and processes are tolerable.

    What it cost

    Stated estimates are sometimes wrong, and an estimate that overruns is worse than none. The range is deliberately wide and pessimistic, which makes the common case feel slow on paper and fast in practice.

  5. Make setup resumable by a different person

    A linear wizard assumes one person with all the answers in one sitting. In the scenario the person who signs up and the person who configures are frequently different, and often days apart.

    What we did

    No step blocks another. A decision log records what was chosen versus what was defaulted, and open items surface where they are relevant rather than in a queue.

    Why

    It matches how the work actually gets divided, and it gives the second person the one thing they need most — knowing what the first person actually agreed to, as distinct from what the product assumed.

    What it cost

    Without a forced sequence, an account can sit half-configured indefinitely, and there is no single moment where setup is "done". We judged a permanently open, honest state better than a completed checklist that hides the same gaps.

Design system

The system underneath the screens

A calm, low-anxiety system for a product handling other people's money. The decisions worth pointing at are a deliberately narrow palette that reserves saturation for money movement, form fields that state their data-access scope inline, and a wait component that is a first-class part of the system rather than a spinner someone dropped in.

Colour

  • Ink#111014Primary surface, dark theme
  • Ledger#7C3AEDPrimary action. Passes contrast in both themes, so it is not restepped.
  • Reconciled#15943FA completed match. The only place green appears.
  • Neutral#71717ASecondary text, and the reference series in charts
  • Unmatched#B45309Needs attention — never used for anything that is merely incomplete

Typography

  • FigureBalances and totals, always tabular2rem · 600
  • HeadingSection and step headings1.375rem · 600
  • BodyRunning text and field labels1rem · 400
  • AmountTransaction amounts in dense ledger rows0.9375rem · 500
  • CaptionScope notices, inferred-value markers and timestamps0.8125rem · 400

Tokens

--tabular-figures
always
Every numeral in the product. A misaligned column of money reads as an error.
--wait-estimate
required
No indeterminate spinner may ship without a stated duration range.
--scope-notice
inline
Data-access scope sits beside the field requesting it, never in a link.
--inferred-marker
dotted underline
Distinguishes a value the product guessed from one a person chose.
--radius-control
12px
Softer than the operations tools. Deliberate — anxiety reduction.
--destructive-confirm
typed
Anything touching a real account requires typing, not a click.

Components

6 components · 28 variants

  • SetupCard5A progressive configuration unit. Resumable, and never blocking another.
  • SyncStatus6Named stages with an estimate. Replaces every indeterminate spinner.
  • LedgerRow8Matched, unmatched, partial and inferred states at three densities.
  • ScopeNotice3States what data is accessed, inline with the field that requests it.
  • SampleBanner2Marks sample data unmistakably, with the replace action attached.
  • DecisionLog4Chosen versus defaulted, for whoever picks the account up next.

Rendered specimens

Forms & inputs
Buttons & actions
Cards
Navigation
The solution

What shipped

  • Sample-first activation

    A labelled, fully interactive sample ledger that reconciles immediately, replaced by real data in one action.

  • Progressive configuration

    Six setup tasks moved out of the wizard and surfaced at the point each one is first needed.

  • Explicit waits

    Named sync stages with a duration estimate, replacing every indeterminate spinner in the activation path.

  • Inferred account mapping

    A starting map derived from the first batch, presented for review with every guessed row marked as inferred.

  • Resumable setup with a decision log

    No step blocks another, and a second person can see what was chosen versus what the product assumed.

  • Inline data-access scope

    What each connection can read, stated beside the field requesting it rather than behind a policy link.

Design outcomes

What the work changed

These describe the design itself. Because this is a concept project with no users, there are no adoption, retention or revenue figures on this page — those would have to be invented, and an invented number is worth less than none.

9 → 3
Steps before the first reconciliation

Six administrative steps deferred until after the user has seen the product do its job once.

6
Setup tasks moved after first value

Teammate invites, chart of accounts, reconciliation rules and three settings, each requested at the point it is first needed.

1
Screens in the activation path

A single progressive surface replacing a five-screen wizard and a persistent checklist panel.

0
Checklists

Removed entirely. It measured completion of a sequence that did not predict anything.

47 → 6 min
Modelled time to first reconciliation

A walkthrough estimate of the redesigned path against the current one, counting only unavoidable waits.

3
Fields required before signup completes

Email, password and country. Everything else is asked when the product needs it.

Next case study

Fleetwise

A fleet dashboard people stop exporting to spreadsheets

Logistics
Read it

Your product

Have a problem shaped like one of these?

Ledgerly is a concept. If you are working on something with the same kind of complexity, tell us what is not working and we will tell you how we would approach it.

Or email us directly at hello@uxatom.com