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.

- 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
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.
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.
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.
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.
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.
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.
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.
The people we designed for
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
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
Where the current experience loses them
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.
What we decided before drawing anything
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.
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.
Earn the credentials
The highest-anxiety action in the flow happens after the product has demonstrated what it does, not before.
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.
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.
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.
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
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
- Sign up
- Create organisation
- Invite a teammate
- Connect bank feed
- Wait for sync
- Configure chart of accounts
- Connect accounting integration
- Map accounts
- Run first batch
After
- Sign up
- Run the sample batch
- 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
- Choose institution
- Enter credentials
- Spinner
After
- Choose institution
- Read the data-access scope
- Enter credentials
- 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
- Open settings
- Read documentation
- Create each account
- Map each account
After
- Review the inferred map after the first batch
- Correct what is wrong
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.
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.
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.
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.
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.
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.
Key screens






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
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.
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
- 6
- Setup tasks moved after first value
- 1
- Screens in the activation path
- 0
- Checklists
- 47 → 6 min
- Modelled time to first reconciliation
- 3
- Fields required before signup completes
Six administrative steps deferred until after the user has seen the product do its job once.
Teammate invites, chart of accounts, reconciliation rules and three settings, each requested at the point it is first needed.
A single progressive surface replacing a five-screen wizard and a persistent checklist panel.
Removed entirely. It measured completion of a sequence that did not predict anything.
A walkthrough estimate of the redesigned path against the current one, counting only unavoidable waits.
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
LogisticsYour 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