A prototype in software engineering is a preliminary version of a system built to explore a design, validate an assumption, or demonstrate feasibility. It is intentionally incomplete and typically not intended for production use. The goal of a prototype is to reduce uncertainty before committing to a full implementation.

Prototypes fall into two broad categories.

Throwaway prototypes are built quickly with the explicit intent of discarding them. The code quality is irrelevant; the point is to answer a specific question as fast as possible. Once the question is answered the prototype is discarded and the real implementation begins with the knowledge gained. This is related to the Spike solution concept from Extreme programming.

Evolutionary prototypes are built to be refined iteratively into the final product. The prototype starts as a skeleton and grows through feedback cycles. This approach is risky: prototypes built for speed tend to accumulate technical debt, and “we'll clean it up later” rarely happens. The result is a production system built on a prototype foundation.

In embedded engineering, prototyping often happens at the hardware level: an FPGA or a development board is used to validate a hardware design before committing to an ASIC or custom PCB. The firmware written for the prototype is sometimes throwaway (just enough to validate the hardware) and sometimes evolutionary (the production firmware starting point).

The classic mistake is showing a prototype to stakeholders, having it received as a finished product, and then being pressured to ship it. A prototype that looks polished invites this. The mitigation is to make prototypes obviously provisional — rough UIs, hardcoded data, visible TODO markers — so they are not mistaken for production-ready software.