Building is not the end goal: it is the means of delivering value and learning whether we can do so reliably.

A solution is not always a technology product

When we talk about development, we often think of coding or manufacturing. However, a solution can be a service, a process, a physical product, or a combination. A consulting business develops a methodology and a customer service experience; a restaurant develops recipes and a service system; a platform develops software and support operations.

IDEO's human-centered design uses prototypes and testing to learn before committing to final solutions. This fits our first process: building and experimentation inform each other.

To distinguish what is actually built or provided, see types of products, services, and solutions. Classification helps identify components, actors, and delivery conditions before choosing tools.

Human-centered design is important, but not the only perspective: design approaches and how to combine them show when to include co-design, accessibility, service design, systems thinking, and technical constraints.

1. Translate the value proposition into a concrete experience

Describe what the customer is trying to accomplish and what happens from the first contact to receiving the result. How do they discover the offering, buy, use it, request help, and evaluate the experience? A simple map of that journey can reveal dependencies invisible in a feature list.

To map those interactions and friction points, use the customer journey guide. This is especially useful when the outcome depends as much on contact, fulfillment, and support as on the product itself.

In a reservation application, the value is not “having a calendar”: it is avoiding mistakes and making coordination easier. In a lunch service, it is not just “cooking”: it is delivering appropriate food, on time, and under safe conditions.

Define the minimum conditions the solution must meet to produce that result. Do not confuse an extensive feature list with demonstrated value.

If it is difficult to state the outcome that minimum scope must protect, revisit the value proposition and differentiation. That promise guides design decisions but still needs evidence that it can be delivered.

Before choosing screens, materials, or procedures, compare solution alternatives that could produce the same outcome. A manual approach, an existing tool, and custom development may involve very different costs and risks.

That core value needs testable conditions: how to define requirements and acceptance criteria explains what must happen, under which constraints, and what evidence will make it acceptable.

2. Choose the appropriate level of fidelity

A sketch helps you discuss an interface; a physical sample can reveal material problems; a service simulation lets you observe timing; a functional prototype lets you test interactions. They do not all answer the same questions.

Fidelity is the degree to which a representation resembles the actual solution. Increasing it usually costs more. If we do not yet know whether the problem matters, a complex prototype may be a premature investment. If we need to test strength, safety, or integration, a visual mockup probably will not be enough.

The right question is: What do we need to learn or demonstrate, and what is the least expensive representation that makes it possible?

The guide to prototype types helps match a learning question to fidelity and the limits of each representation; a sketch and a functional test do not yield equivalent evidence.

3. Define a minimal scope with a purpose

The idea of a minimum viable product is misunderstood when it becomes an excuse to deliver something carelessly made. A minimal scope must allow a useful test of value while respecting basic safety, quality, and compliance requirements.

For a service, this may mean serving a small area through manual processes. For a physical product, producing a controlled batch. For a platform, enabling the essential workflow without secondary features. In each case, the scope depends on the hypothesis and the obligations of the context.

A small version that does not let you evaluate anything important is not a good test either.

If the first version must deliver value and generate evidence without building everything, use the guide to defining a useful MVP and minimum scope. The minimum depends on the question we need to answer and on mandatory conditions.

4. Design for delivery, not just demonstration

Real constraints emerge during development: costs, material availability, maintainability, response times, training, accessibility, and safety. It is useful to consider these conditions from the outset, even if full implementation takes place in stages.

An application needs to protect information and work under real conditions of use. A physical product needs suitable materials and manufacturing. A service requires clear instructions, human capacity, and ways to recover from errors.

Not every decision needs to be optimized from day one, but decisions that are irreversible or expensive to correct deserve early attention.

To assess costs, materials, capacity, technology, and obligations without hiding trade-offs, see how to design around real constraints. A convincing demonstration is not enough when the solution cannot be produced or delivered responsibly.

Delivery capability also requires explicit quality criteria: working once is not the same as meeting relevant safety, reliability, accessibility, or consistency conditions.

5. Test the solution under representative conditions

Usability testing asks whether people can use the solution; technical testing checks behavior and limits; operational testing checks whether we can deliver it repeatedly. A solution may pass one of these tests and fail another.

Record errors, effort, time, quality, and consequences. Observe people who did not design the solution: creators know shortcuts that new users do not. In commercial pilots, also measure actual costs and the post-purchase experience.

To preserve learning between iterations, use the method for recording test results and evidence. Keep usability, technical, and operational findings distinct, and record negative outcomes without rewriting the hypothesis after seeing them.

Distinguish between problems with design, execution, and the business model. If customers value the offering but the cost per delivery is too high, improving the interface is not enough: we may need to revisit pricing, logistics, or scope.

To move from general questions to scenarios, cases, expected results, and reproducible evidence, use how to plan and run solution tests. Each type of test supports different claims.

6. Decide what to fix and what to leave out

Findings often generate more requests than we can address. Prioritize problems that prevent delivery of the core value, significant risks, and improvements supported by evidence. Do not add features simply because a competitor has them.

Keep a decision log: what was observed, what change is proposed, what it will cost, and how we will know whether it worked. A solution evolves more effectively when the team understands why each component exists.

When tests produce defects, requests, and different observations, organize findings and prioritize improvements. Distinguish severity, urgency, evidence, and effort before turning every comment into work.

To know what changed, why, and who actually received it, see how to manage versions, changes, and releases. An approved fix or merge is not by itself a version available in production.

7. Prepare the transition to operations

Before expanding use, check who will provide support, how incidents will be resolved, how supplies will be replenished, how quality will be maintained, and which indicators will show whether delivery works. Document enough to avoid relying exclusively on one person's memory.

Before expanding commitments, compare this preparation against evidence-based readiness and Go/No-Go checks. A working demonstration alone does not establish that support, cash, safety, and capacity are ready for operations.

The transition can be gradual. A paid pilot already combines development with marketing and sales, but its learning objective may still differ from that of a stable operation.

An example: a restaurant reservation service

Instead of building a complete platform from the outset, you first test a simple workflow with a few restaurants. You discover that the main problem is not recording reservations but confirming last-minute changes. You adjust the solution and test again. Only then do you decide what to automate, what to keep manual, and what support capabilities you will need as you add customers.

What you should have by the end

A solution that delivers its core value, evidence of use and delivery capability, known outstanding risks, and a plan to operate and improve. You do not need to have addressed every future need: you need to be ready for the next level of commitment.

Key sources: IDEO [F1], Strategyzer [F3–F4], SBA [F5].

Bibliography and references

Numerical examples are illustrative and do not represent market data. Legal requirements depend on the jurisdiction and industry.