Most products start as a sentence. “What if dealers could see a battery’s whole history?” The distance from that sentence to something people can use is mostly decisions, not code. Some of them have to be made on the first day. Others are better left until there is evidence. Telling the two apart is most of the craft.

Our approach fits in four words on our home page: Understand, Design, Build, Refine. This is what each of them means in practice while an idea is on its way to a first release.

Understand: the problem before the product

The first job is to replace the idea with a description of a problem. Who has it, what are they trying to get done, and what is in their way today? If those answers are vague, every later decision is a guess.

Talk about the work, not the software

Asked what they need, people describe the tools they imagine. It is more useful to hear how they work now: the spreadsheet, the phone call, the paper form, the step they dread every week. The product that ends up helping them usually looks different from the one they would have asked for.

Write the constraints down

Every product lives inside constraints, and the expensive ones are those discovered late: regulations, existing systems, the devices people really carry, the budget, the date that cannot move.

For the E-Bike Battery Passport, the EU Batteries Regulation shaped the data model before any screen existed. A published passport can never be edited in place, only replaced by a new version, and every event in a battery’s life is kept for good. Finding that out after the first release would have meant rebuilding its foundations.

Find the assumption that could sink it

Every idea rests on a few assumptions, and one of them is usually riskier than the rest. People will enter this data themselves. Suppliers will share their records. Workshops will scan a code rather than type a serial number. If that assumption is wrong, nothing built on top of it matters.

Test it first, and as cheaply as you can: a conversation, a spreadsheet, a manual version of the process run by hand for a week. It is far better to learn that the riskiest assumption is wrong before the first release than because of it.

The output of this stage is short: a description of the problem, the people who have it, the constraints, and one question the first release has to answer.

Design: the shortest useful path

Design starts with flows, not screens. What is the shortest path from arriving to done, for the task that matters most? Each step on that path needs something to make it work. Together, those things are the first release. Everything else waits.

Design every state, not just the happy one

A screen is not one picture. It is empty before anyone has used it, loading while it waits, partly filled, failed, and full. Real people meet the empty and the failed versions first. Designing those early is much cheaper than retrofitting them once the complaints arrive.

Prototype before you build

A clickable prototype costs a fraction of the product and answers many of the same questions. Put it in front of five people who do the work, give them a task and stay quiet. Where they hesitate, the design is unclear; where they go somewhere unexpected, it is telling you how they think. Changing a prototype takes an afternoon. Changing a released product takes a release, and sometimes a migration.

The point is not a polished demo. A rough prototype that tests the right flow is worth more than a beautiful one that tests nothing.

Fix the words early

Vocabulary is design. The names on buttons, headings and statuses become the way people talk about the product, and changing them later means retraining everyone who learned them.

Before the battery passport’s business portal was translated into Dutch, we wrote a glossary, so that each term would be written once and the same way on every page. It records, for example, that the product is an “accu” in running text, the word people in workshops use, and a “batterij” only where the regulation’s own term is meant. A glossary is a small document that saves a large amount of inconsistency.

Decide what to settle early

Not everything can wait. Some decisions are cheap to make at the start and very expensive to change once people depend on them. Others are the reverse: cheap to add later, and wasteful to guess at now.

Settle earlyCan safely wait
How records are identified, and whether an identifier can ever changeThe visual polish of secondary screens
What is public, what is private, and who may see whatPersonal settings and preferences
What must never be edited or deletedExtra export formats
Whether the system will need to work offline one dayThe offline app itself
The core vocabularyEvery integration after the first

The pattern is that the left column shapes data and trust, which everything else is built on. The right column adds to that foundation without disturbing it.

Deferring a feature is not deferring a decision

The battery passport’s first release was online only. Its API was still built from the start so that offline work could be added later: every change carries its own identifier and can safely be sent twice. The offline app came later. The decision that made it possible did not.

Build: in thin, complete slices

Building one layer at a time (all of the database, then all of the screens) means nothing works until everything does. We prefer thin slices that each run from the screen to the database and back: one task, working end to end, in a state that could be released.

A slice teaches you what a layer cannot. It shows where the design was unclear, where the data model is awkward, and how long things really take. It also means that if the date arrives before the plan is finished, what exists is a smaller product rather than half of a large one.

Choose the first slice for what it will teach, not for how easy it is. The task with the most uncertainty in it (an unfamiliar integration, a tricky permission rule, the step people rely on most) is the one to prove first, while there is still time to change course if it fights back.

Automate the rules that matter

Some rules must never be broken: a record that cannot be changed, or data that one customer must never see of another’s. Those belong in the system itself, enforced where the data lives and covered by tests that fail loudly. A rule enforced only by being careful will eventually meet a tired afternoon.

Build the unglamorous parts properly

Sign-in, password resets, notification emails, error pages, the page that says an account has no data yet. Nobody demos them, and every user meets them, usually at a moment when they are already unsure.

They also fail in ways that have nothing to do with your code. Our product’s sign-in emails were once landing in junk folders at one large email provider. The product was fine. One of the signals against us was that the domain the emails came from had no website at its root, which looks odd to a spam filter. Part of the answer was to put a site there. Finding it meant treating a sign-in email as part of the product, and checking where it actually lands rather than assuming it arrives.

Make it observable before it is public

Before real people arrive, the product should be able to tell you how it is doing. Errors should be recorded somewhere a person will see them, and the service should be able to answer whether it is healthy. When something goes wrong in the first week, and something will, the difference between guessing and knowing is decided here.

Keep releasing boring

A release should be a non-event: a small change, deployed the same way as every change before it, with a known way back. The less that changes at once, the easier it is to see what caused a problem. We deploy often, and on the products we run, a person decides when a build goes live, rather than a merge making that decision by accident.

Refine: before and after release

Refinement is not decoration added at the end. It is a separate pass, with fresh eyes, over what the slices produced. Before release, that means:

  • Using it on real devices. Phones, slow connections, small screens, and a keyboard alone.
  • Checking accessibility. Contrast, focus order, labels, text alternatives and reduced motion.
  • Reading every word. Labels, errors, empty states and emails, out loud.
  • Trying to break it. A wrong entry in every field, the back button at every step, two tabs at once.

Decide what you will look at

Before launch, write down what you will look at to judge the release, and what each signal would tell you. Our own product’s success criteria were written as things we could watch happen, such as a workshop adding a repair record in under two minutes. Deciding this after launch invites reading the numbers in whatever way feels best.

The same idea works one level down. Every feature in Nearwell’s specification says when it is done: what someone can do or see when it works, and which failures matter. Import was done when a Google Contacts file and an iPhone contacts file both came in with names, emails, phones and companies, the user saw a preview before anything was saved, and bad rows were listed rather than silently dropped. Checking each line before calling it built kept a three-day first version honest.

After release, refinement becomes a loop. Watch how the product is used, compare it with the question you set out to answer, and change the thing that matters most. The first release is where a product starts meeting reality, and most of what makes it good is decided in the months that follow.

A short checklist for a first release

Before we call a first release ready, we want to answer yes to each of these:

  1. Can we say, in one sentence, what question this release answers?
  2. Is there a written list of what it deliberately leaves out?
  3. Does the most important task work end to end, on the devices people use?
  4. Are the rules that must never be broken enforced by the system?
  5. Does every screen handle its empty, loading and failed states?
  6. Will we know when something goes wrong, before someone tells us?
  7. Can we see whether the release is doing what it was for?

If any answer is no, that is the next thing to work on, not the next feature. None of the questions asks whether the release is impressive. A first release that is small, dependable and clear about its purpose will teach you more than a large one that is none of those things.

The idea was the easy part

An idea is a starting point, not a plan. What turns it into a product is a series of choices about what to understand, what to design, what to build first and what to leave for later. Most of those choices are small. Made early and made well, they are the difference between a first release that teaches you something and one that simply takes a long time.