Prototype
A preliminary model or early sample of a product, concept, or system, built to test a concept, gather feedback, or validate a process before full-scale development.
c. 1950s
3
Definitions
Software Engineering Context
In software engineering, a prototype is an early, often incomplete, version of a software application. Its primary purpose is to explore and validate design choices, test technical feasibility, and gather user requirements before committing to full-scale development.
Key Concepts:
- Throwaway Prototyping: A model created rapidly to explore an idea, gather feedback, and then be discarded. The lessons learned are applied to the real system. This is also known as rapid prototyping.
- Evolutionary Prototyping: A robustly built prototype that is incrementally refined and enhanced through development cycles until it becomes the final product. This approach requires good initial architecture.
- Incremental Prototyping: The final product is built as separate prototypes, which are eventually merged to form the complete system.
Example:
A team might build a simple, functional prototype of a new reporting dashboard using dummy data to show stakeholders how it would work and to get their feedback on the layout and features before writing production-level code.
UI/UX Design Context
In User Interface (UI) and User Experience (UX) design, a prototype is an interactive simulation or model of a product's interface. It allows designers and stakeholders to test the user flow and interactions before development begins. Synonyms in this context often include mockup or interactive wireframe.
Fidelity Levels:
- Low-Fidelity (Lo-Fi): Basic, often hand-drawn sketches or simple digital wireframes (e.g., Balsamiq). They focus on structure, layout, and user flow, not visual aesthetics. Paper prototypes are a common example.
- High-Fidelity (Hi-Fi): Highly detailed, visually polished, and interactive models that closely resemble the final product (e.g., created in Figma, Sketch, or Adobe XD). They are used for detailed usability testing and stakeholder presentations.
Usage:
Designers use prototypes to conduct usability tests, allowing them to observe how real users interact with the proposed design and identify pain points early. For example, a clickable prototype of a mobile app can reveal confusing navigation before a single line of code is written.
General Product Development Context
In general product development, including hardware and physical goods, a prototype is a preliminary model, sample, or release of a product built to test a concept or process. It serves as a tangible representation of an idea, used to evaluate form, function, and manufacturability.
Examples:
- Hardware: An engineering team might use 3D printing to create a physical prototype of a new phone casing to test its ergonomics and fit.
- Automotive: Car manufacturers build concept cars as prototypes to showcase new designs and technologies to the public and gauge interest.
- Business: A new service can be prototyped through a pilot program, where it's offered to a small group of customers to test its viability and operational flow.
Origin & History
Etymology
The term originates from the Greek word 'prōtotypon', which means 'primitive form'. It is a combination of 'prōtos' (meaning 'first') and 'typos' (meaning 'impression' or 'mold'). It entered the English language in the mid-16th century.
Historical Context
The concept of creating a preliminary model is ancient, but its application in modern technology and software has a more recent history. In traditional engineering, physical models have always been used to test designs. However, in software engineering, the idea gained formal recognition in the 1970s and 1980s as the 'prototyping model' of software development. It was proposed as a direct response to the perceived weaknesses of the rigid, sequential Waterfall model. Prototyping allowed for iterative development and incorporated user feedback much earlier in the lifecycle, reducing the risk of building the wrong product. Fred Brooks, in his seminal 1975 book 'The Mythical Man-Month', advocated for building a system to 'throw away', stating, 'the question is not whether to build a pilot system and throw it away. You will do that. The only question is whether to plan in advance to build a throwaway, or to promise to deliver the throwaway to customers.' This captured the essence of throwaway prototyping. With the rise of UI/UX as a distinct discipline in the 1990s and 2000s, the focus shifted towards interactive, often non-functional, **prototypes**. The development of specialized tools like Figma, Sketch, and Adobe XD has made it possible to create highly realistic **mockups** that simulate the final user experience without writing code. This practice is now a standard part of the design process in most tech companies. Furthermore, the principles of Agile development, formalized in 2001, inherently embrace prototyping. The emphasis on delivering working software in short iterations means that each increment can be viewed as a **prototype** for the next stage of development, ensuring continuous feedback and alignment with user needs.
Usage Examples
In our sprint planning, we decided to build a quick prototype to test the new checkout flow with users before committing development resources.
The design team presented an interactive mockup, a high-fidelity prototype that allowed stakeholders to click through the entire user journey.
Before investing in expensive tooling, the hardware engineers created a 3D-printed prototype to verify the product's ergonomics and assembly.
Our pilot program for the new delivery service is essentially a live prototype to work out the operational kinks.
Frequently Asked Questions
What is the primary difference between a prototype and a final product?
A prototype is a preliminary model used for testing, feedback, and validation, and is often incomplete or uses simulated data. A final product is a fully developed, tested, and production-ready version intended for market release.
In UI/UX design, what is the difference between a low-fidelity and a high-fidelity prototype?
A low-fidelity prototype (e.g., paper sketch, wireframe) focuses on structure, flow, and basic concepts with minimal detail. A high-fidelity prototype is a highly detailed, interactive model that closely resembles the final product's visual design and user interaction.
Can a prototype evolve into the final product?
Yes, this is known as an 'evolutionary prototype.' It is built with good engineering practices and is iteratively refined based on feedback until it becomes the final, released product. This contrasts with a 'throwaway prototype,' which is built quickly for learning and is discarded.