Instead of expressing “requirements, ” we consider assumptions and declare hypothesis statements. A hypothesis statement is a way of expressing assumptions in a testable form.
Reality often shows that the creators of a product or service are not sure what a user needs or wants or how it should work concerning the user experience. But quite often, organizations or companies proceed with their idea for functionality or user experience without input what the user needs (or what the user thinks about it) and without checking (testing) with the end-user throughout the development process.
Quite frankly, organizations that have been in business for many years (decades) think (with some level of arrogance) to know what the customer wants and how the experience should be – but this arrogance will bounce back with failure: an unhappy end-user will trash the product and its experience if it deemed to be unfit.
A hypothesis statement will require experiments to determine which assumptions are right or wrong.
The first step is to list any assumptions: an assumption is a declaration of what we assume to be true. But it’s not considered a requirement until we have facts and figures to support it. Assumptions comprehend both business and user assumptions. A possible way to start listing assumptions is to start from a problem statement. Problem statements are full of assumptions. When assumptions are listed, it’s crucial to select the most uncertain ones.
The main principle of Lean Startup is to expose the highest risk first to learn. The whole team should do the exercise of listing assumptions and hypotheses with the whole team: everyone involved so that you can create a shared understanding from the start.
A hypothesis statement has the following format:
Note: This is a possible format, and there’s no obligation to follow this blindly, as long you understand the purpose, and you have the different elements.
Outcomes (objectives) and metrics
It is essential to focus on outcomes first: what are we trying to achieve and what objectives? What kind of user needs? Instead of directly thinking about features (solutions), we focus on outcomes. When creating the product, the progress will be measured against the outcomes. To measure, you need to define a set of metrics. An excellent approach to this is Objective-Key-Results.
Features (functionalities, stories, …)
Features exist to serve the needs that have been identified. You create a particular feature (solution, functionality, story). It’s essential to have the outcome first defined and think about possible features.
It is essential to know something about the customer, the end-user you’re creating the product for. Personas are a well-known technique to make the end-user visible.
The clue is to approach the creation and validation of personas the lean way: personas are not the output of great research upfront but are created and evolve as the product evolves. Personas created with lots of work upfront and not updated afterwards are essentially throw-away personas: they become useless as soon as they are outdated, and concern a source of waste.
We prefer to create “ad-hoc” or “proto”-personas: these represent the best guess of who is using the product and why. A proto-persona contains the information (demographics, behaviours and needs) of a specific type or segment of end-user relevant to the product being designed.
Lean UX book
Materials in this post are based upon readings on the Lean UX approach.
Jeff Gothelf’s Lean UX book is about applying the principles of lean (startup) to User eXperience.
Lean UX (Jeff Gothelf)
“Lean UX” is part of the Lean Series: a series of books applying the principles of Eric Ries’ Lean Startup to several domains.
Lean UX applies the principles of both agile, lean, design thinking and lean startup to the process of creating and design any user experience of any product or a service.
“Lean UX” is well-written and has enjoyed attention by many in the UX and lean/agile community. The first edition of the book was published in March, 2013.
Not familiar with agile, lean, lean startup or any of these?
Well, let’s shortly define:
Agile development is a mindset, an approach to product development (and yes, not only software). Agile focuses on delivering what’s valuable for the customer, and makes us work in short time periods. The product is built in small increments, and in an iterative way; meaning we revise, expand and improve the product iteration by iteration.
Moreover, agile stands for a way of working: cross-functional collaboration: all people in 1 team, no distinction between roles. An agile team cultivates and thrives on the mix of everyone’s expertise, open communication, trust, … in other words: real collaborative team work. When needed, an agile organization or company is able to immediately change direction in development (or any other area) at any time, with very low or even no cost.
So, what’s wrong with the way that products (software) are being designed?
Well, in a traditional way of working there exists the waterfall approach: meaning the assumption that upfront work (analysis, specification, design, etc) is required before we can start any construction.
Makes sense, doesn’t it? Let’s be sure and figure out all the details before investing money in construction. The reality proves to be different: most importantly, only when actually using the product or service constructed, you really know and can evaluate its use, its experience. Most of any upfront work done will largely turn out to be waste, because the product or service constructed will require changes to meet the “new” (actual) user needs, meet new market conditions, etc. When using the product (or service), the user finds out what he needs. Hence the plea for an incremental and iterative approach.
The traditional approach to designing a product and its user experience will output many deliverables: wireframes, prototypes, visual designs, style-guides, screen-flows, workflows, etc. Reality shows that many of those ideas and features designed will not make it to the actual final product; and many of those experiences designed (on paper, or even interactively) will require changes when end-users start using the product; or when any constraints arise.
The assumption that the user experience / user interface of a product should be designed upfront (away from construction) in a perfect way is an approach which originates from old habits and a traditional product development thinking. Looking from a lean perspective, this kind of process contains a lot of waste.
The Lean UX book
The Lean UX book shortly explains why Lean UX is needed. Lean UX (likewise agile and lean) itself is a mindset, a philosophy, an approach, an attitude, a way of thinking, a way of working. It defines a cycle, and offers a set of techniques and tactics. For UX people working the traditional way, it will be a considerable change in process and working attitude.
The Lean UX book enumerates the foundations and principles of Lean UX. With design thinking, agile, lean and lean startup in mind, the principles of Lean UX are familiar:
Small, dedicated, co-located cross-functional teams
Shared understanding throughout the process
No gurus, lonely experts; but a whole team approach
Progress is measured by outcomes, not by output (deliverables)
Focus on problems and solutions, instead of a set of features
Remove waste, by minimizing anything in the process that doesn’t directly contribute to value delivery
Work in small batch sizes, small increments. Avoiding large quantities of work-in-progress
Interact with your customer, your end-user to get feedback (and to achieve this, you need to get our of the building, get out of your office)
Externalize the work: show and tell as much as possible
Value making over analysis
Value learning over growth
Permission to fail
Getting out of the deliverables business: less focus on deliverables, more focus on constructing the product (cf. The agile manifesto)
Lean UX cycle
The Lean UX book describes the basic cycle:
Lean UX cycle
THINK: Declaring assumptions and creating a hypothesis statement
How to start from a problem statement, declaring business and user assumptions and writing hypothesis statements.
MAKE: Creating and running an experiment
How to create and run an experiment with end-users. Experiments can take any form: prototypes or non-prototypes.
CHECK: Get feedback and research
How to organize user tests, and how to learn from feedback.
Lean UX and iterative development
In the last section, the Lean UX book describes how to the steps of Lean UX can be integrated in iterations of agile development. The book also describes what kind of organizational transformation and change in mindset are needed to be effective with Lean UX in your project or organization.
Lean UX = applying Lean and Lean Startup principles to User eXperience.
Remove waste from the UxD process
Too much too often product (software) design and development is document-driven. With the agile manifesto and principles in mind, we want to focus on creating great and valuable products (software) and releasing these early and often to get valuable end-user feedback, in order to improve our products (software) iteratively and incrementally.
Forget about the overload of UxD deliverables that are created to communicate “specifications” to “developers”. Re-consider and only create those deliverables that truly serve a purpose. We value “making” over “analysis“; we value “building” over “specification“. Lean helps us to focus on flow and to reduce non-value creation (waste).
What do I mean?
Useful deliverables (depending upon your context):
Branding and styleguide (by preference a living styleguide, to minimise maintenance effort)
Low-cost prototypes used in user testing
Low-cost sketches, mock-ups, designs, etc
Detailed User Interface specifications (for example including annotations of every screen)
Wireframes of every screen, every screen size
Visual designs of every screen
High-fidelity mockups (not reused in development)
Try to minimise the “upfront” creation of large UxD deliverables to be handed over to developers, instead rely on true cross-functional collaboration.
True cross-functional collaboration (including designers, including UX people, including usability engineers, including developers, including product owners, including business stakeholders, marketeers, etc). True agile cross-functional collaboration is the foundation and the catalyst for collaboration and short development / release cycles. Agile re-focuses product (software) development on value creation and working products (software).
In every step of the cycle, and from the very beginning, the whole team is involved. The whole team approach aims to create a shared understanding with everyone, all the time. Knowledge, user feedback can be quickly spread and shared, and the team minimises the need for handovers (in any form: documents + interpretation, pass-through communication, re-discussions, etc).
Apply the scientific method
BUILD > MEASURE > LEARN
MAKE > CHECK > THINK
The scientific method exists for centuries and we are simply applying it to nowadays product (software) development.
“The Scientific Method as an Ongoing Process” by ArchonMagnus – Own work. Licensed under CC BY-SA 4.0 via Wikimedia Commons – https://commons.wikimedia.org/wiki/File:The_Scientific_Method_as_an_Ongoing_Process.svg
In Lean Startup this is known as the build > measure > learn cycle. This is an on-going process, it obviously doesn’t stop with 1 iteration. We also call this make > check > think.
Lean UX cycle basic
The only way to create products (software) which matter for your end-users, which mean a difference, which serve their needs is:
by first focusing on outcomes (objectives) and next on features (solutions)
by getting in touch with your end-users, observe and measure how they use your products
by focusing on creating valuable experiments to expose risks and uncertainty
by improving whatever you’re making based upon that feedback
by building upon collective knowledge and wisdom and let the whole team flourish in creating the best experience
by creating products iteratively and not only incrementally
by minimising the total time going through this process
by creating an environment of continuous learning
Learn more about Lean, Lean UX and product development with experiments in follow-up posts!
Techniques to bring UxD and development closer together, why collaboration matters.
The scientific method and product development with experiments
How to organise user testing
How to incorporate validated learnings
Lean UX book
Materials in this post are based upon readings on the topic of Lean UX.
Lean UX is about apply lean principles to User eXperience.
There are 2 main observations:
Bad UX. Failed products.
Unfortunately, there are still too many (software) products and services built and released on the market, that do not fit the customers’ needs. This is a long lasting pain in software development. Nowadays thanks to modern web & mobile technologies, possibilities are endless. But than again there are still too many useless, badly designed, wrongly understood, misfit products with failed UX.
Search the web for “failed products” and you get a few examples.
Creation of software by writing documents.
The purpose of creating software is to serve the users’ need, to solve their problem, to automate their work, to meet their goal, to be convenient in use. Software is an end, not a goal. The experience has to be right, it must properly function, the experience should be neat and crisp.
Unfortunately, when creating user experiences, many product (software) development teams are organised in a way so that:
UX people “produce” the “UX” and create a document, a deliverable (“the UI/UX spec“). “The spec” is delivered to the developers who will make the wonderful UX real.
Documents do not solve users’ problems; software does.
With the agile manifesto in mind:
Working software over comprehensive documentation
We know and we owe it to ourselves to focus on delivering a working product, to collaborate and to work to the highest standards, and to minimise any unnecessary intermediates (such as “the spec“). So why do still so many teams (agile or non-agile) keep on focussing on “big UX design upfront”?
Applying Lean principles to product creation and UX will help us to focus on creating a right product fit, by creating value, and by minimizing any waste in the process. Likewise agile, likewise lean, Lean UX is a mindset, a process change and a way of thinking how to create the right product in the right way.
The core idea is to maximize customer value while minimizing waste. Simply, lean means creating more value for customers with fewer resources.
A lean organization understands customer value and focuses its key processes to continuously increase it. The ultimate goal is to provide perfect value to the customer through a perfect value creation process that has zero waste.
UX or User eXperience is about the user experience, but also the whole customer experience. It’s more than design aesthetics. It’s the result of the combination of design, interactions, architecture, technology, business goals, etc.
“Cross-functional” collaboration in (agile) product development means that the whole (complete) product “development” team is participating. Scrum talks about a “development” team without distinction of role. As such, “developer” means any competence or skill required to create the product or service, not limited to “programming” (writing code).
Lean UX heavily promotes the whole product development team participating during the complete product development cycle from the very beginning. The entire team approach aims to create a shared understanding with everyone (all team roles) from the start and to minimize any waste originating from working in sub-teams or silos (hand-overs, intermediate deliverables, re-discussing the same topic with people who didn’t participate, etc.).
True agile teams (feature teams) are product-oriented and can implement product features end to end, creating value pieces with every item done. Collaboration with all team members is an excellent source of creativity, new ideas and innovation. This kind of cross-functional collaboration is demanding: people are expected to think outside their box, participate in work outside their main domain, and help create that necessary shared understanding to deliver value within an iteration.
Teams working in a phased approach (the so-called staggered sprints) face several worries – this should not be accepted as standard, and such teams should strive for a better working method. A phased approach is some work done in a sprint before the “development” sprint (or even worse, acceptance or testing after the” development” sprint).
The (single) (proper) Scrum team approach has numerous benefits:
Understanding of concepts and users’ needs amongst all team members
Improved time to deliver (precondition is to deliver chunks of value you are able to implement within a sprint)
Less re-work, less waste
Improved definition of done
Sense of ownership amongst all team members
And so, we urge you to re-consider any extensive upfront work (before “construction”) and try to create shared understandings with the whole team. That shared understanding will lead to a willingness to collaborate within the same sprint truly. You foresee a regular cadence of user tests in the Lean UX approach. The aim is to create a “test everything” culture: we test what’s available, and given the users’ feedback, we improve (we iterate).
Once upon a time, there was a marketing person with great ideas for a new software application.
He hired a business analyst, who described all those ideas in formal specifications fully documented business requirements (including use-cases, business rules, exceptions …). This deliverable was handed over to a User Interface / User Experience expert who created a detailed User Interface (including wireframes, site maps, screen flows, mock-ups,…) and described all the user interactions. Next, a functional analyst translated those requirements to an available specification and tried to figure out how to connect them to existing infrastructure and systems.
Given the functional specification, a technical analyst created a technical specification and application design to capture all the given information in a deliverable that would make sense as input for development. Meanwhile, based on that User interface specification, a visual designer, individually, made stunning pixel-perfect graphic designs for every screen of the application. A copywriter was sometimes assigned to write on-screen text labels and copy based on the wireframes. And even sometime later, a tester was given the assignment to understand the requirements and write test scenarios.
Development was about to get started!
Sometime later, during development, some concerns arose about the application’s User Interface, and a usability engineer reviewed the User Interface specification to give some advice and remarks.
So, what do we observe?
The work goes sequential
Individuals doing their own thing, producing output: deliverables, documents!
Time passes by
Handoffs, with potential gaps for misunderstandings, misalignments, information lost in translation
The goal was to create a new software application – with probably a fantastic idea in my mind and initiated by a great business case. Where is our software?
Focus on outputs, not outcomes. People are appreciated for their output: mainly documents and the quality of those documents.
Those documents are written by an individual or a group of individuals of the same expertise – documents are passed on (with or without explanation). The output of one phase is the input of the next phase. Lack of common understanding (not by the fault of the individuals), each needs to re-interpret the previous work—no real sense of ownership.
It’s a very time-consuming process. From inception to the actual start of development, it can take months – depending upon the size of the project.
Assumptions, lots of assumptions! Hypotheses based on those assumptions. As great as it might be, a requirement spoken by the guy from marketing remains an assumption until proven by the market: feedback from actual end-users: the customer.
There is little to no opportunity to react and correct the design of the new software application when new insights or market conditions come up meanwhile developing.
Probably the whole process is overseen and controlled by a commanding officer.
Where’s our marketing person? Out of sight
A chain is only as strong as its weakest link.
Teams used to a sequential process have become accustomed to handoffs between specialists. Each group passes off their work to the next group. These handoffs include overhead in meetings, documents to review and approve, waiting time, etc. Anything that does not directly contribute to the project’s goal: creating software is waste.
Once upon a time, a marketing person had a great idea for a new software application.
The sponsor gathered a team with expertise in IA/UI/UX, usability, customer engagement, front-end/back-end development and testing. The team formulated the new application’s business goal and desired business outcome with the marketing guy. Together, the team made this set of skills, not an individual, for each required expertise.
The team focused on the outcomes that would address the primary customer need of our application. The idea was conceptualised lightweight: the team formulated some hypotheses: valuable features that they considered a good collection for a ‘minimum viable product’ and a set of metrics to verify those hypotheses. Next, the team draw some UI sketches on paper. The team set out a test by linking the UI sketches to an “interactive” prototype for internal validation. Considering the received feedback, the team refined that small set of features to a user story level with the main acceptance criteria.
The team decided to prototype directly in HTML/CSS as this was the preference of the web developers. The team organised a user test with key customers and external (non-customer) people. These tests and the earlier defined metrics concluded and prioritised several improvements. Collectively, the team came up with the adaptations. With minimum documentation effort (again: main wireframes and a list of agreed-upon decisions), They improved the prototype and discussed a subsequent set of functionality.
Meanwhile, the needed services were encoded and deployed to connect the front-end with the back-end system. The next test showed the application with actual back-end data.
Over time, the team improved the product with customer feedback. They included new insights, dropped a few – previously considered “must-have” – features, and integrated a new online service that appeared to be an excellent fit for the solution.
So, what do we observe?
The focus is on creating working software; that’s what we care for!
Documents do no solve user’s problems, working software does.
The focus is the outcomes; the focus is the vision. The team liberates itself of endless discussion regarding functional features. The attention is directed on user needs, and in that problem space, possible solutions (hypothesises) to address those user needs are presented and challenged.
Feature development is prioritised. There’s no all-inclusive upfront analysis, and there’s no big design application design up-front. There’s no detailed product functionality roadmap. The design emerges, or instead, there’s a good design upfront.
We eat the elephant in small chunks, but we prioritize the chunks.
The team organises itself to collaborate. Insights, proposals, experiences, expertise are collected, and in a healthy synergy, the team shares and co-creation happens – with the customer. The customer is central.
Instead of an open-loop system, the project is organised as a closed-loop system: actual feedback of end-users is incorporated iteration-by-iteration to evolve the application and its features. The “apply-inspect-adapt” cycle is a “probe-sense-adapt” approach. The team plans for experimentation, the team is ready to react when new insights arrive. There’s no anxiety about changes.
What about documentation? When required, additional application designs or an overview of architectural components is delivered. Besides that, the product (software) itself is the documentation. Visual elements are documented in the application itself. The developed front-end is the library of reusable components. The web services themselves are established and are self-explanatory in terms of logic.
Modern software development environments and software craftsmanship practices allow this kind of rapid application design, construction, testing and delivery iteratively and incrementally.