Prototype Model

In this tutorial, we are going to study a very common SDLC model – the Prototype Model. So, let’s begin.

In software development, sometimes the clients are vague about what they want. They have a basic idea about the product they wish to develop. But not the detailed requirements or detailed functionalities of the product. In such scenarios, clients opt for the prototype of the product.

A prototype is a model or sample of a product made for the client’s evaluation and feedback regarding the desired finishing product. After studying the prototype, the client can decide on the features they need in the desired product.

This methodology or SDLC model is called Software Prototype Model.

What is Prototype Model?

The Prototype model is one of the software development life cycle models in which a prototype is built with minimal requirements. This prototype is then tested and modified based on the feedback received from the client until a final prototype with desired functionalities gets created. This final prototype also acts as a base for the final product.

As mentioned earlier, this model is useful when all the detailed requirements are not known to the client before starting the project. It is also useful when the product to be developed is a complex one and similar product does not exist in the market.

In such a scenario, the client can ask the developers to start working on the basic prototype with limited requirements. Once the basic prototype is ready, the client can see and check the prototype to decide what all changes are required.

The client can also use the prototype to do market research and gather end-user or customer feedback.

When the client has decided about the changes that need to be made, the client will give these requirements to the requirements gathering team. These changes then eventually reach the development team.

Developers can then start working on the modifications to the basic prototype. This cycle will be repeated until the client is satisfied with the prototype which reflects the final product.

Phases of Prototype Model

The following are the primary phases involved in the development cycle of any prototype model.

  • Initial Communication – In this phase, business analysts and other individuals responsible for collecting the requirements and discussing the need for the product, meet the stakeholders or clients.
  • Quick Plan – Once basic requirements have been discussed, a quick plan of the initial prototype is made.
  • Modeling Quick Design – User interface part i.e. designing part of the prototype is carried out in this phase.
  • Development of the Prototype – In this phase, the designed prototype is coded and developed.
  • Deployment, Delivery, and Feedback of the Prototype – In this phase, the initial prototype is deployed and is accessible to clients for its use. Clients review or evaluate the prototype and they provide their feedback to the requirements gathering and development teams.
    Above mentioned phases keep repeating until the replica of the final product is deployed.
  • Final Product Design, Implementation, Testing, Deployment, and Maintenance – Once the client finalizes a prototype, on the basis of the prototype, the final product is designed and developed. This developed product is tested by the testing team and if it is ready to go LIVE, the product is deployed and is available for end-user.

Types of Prototype Model

Developers can choose from available prototype model types based on the product’s requirements that have been covered in this section. Let’s look at them.

  • Rapid Throwaway Prototyping – In this method, the prototype is developed rapidly based on the initial requirements and given to the client for review. Once the client provides feedback, final requirements are updated and work on the final product begins. As the name suggests, the developed prototype is discarded, and it will not be part of the final product. It is also known as close-ended prototyping.
  • Evolutionary Prototyping – In this method, a prototype is made, and the client feedback is received. Based on the feedback, the prototype is refined until the client considers it the final product. It follows an incremental development approach and saves time compared to the rapid throwaway prototyping method as in evolutionary prototyping old prototype is reworked rather than developing a new prototype from scratch. It is also known as breadboard prototyping.
  • Incremental Prototyping – In this type of prototype model, final product requirements are break into smaller parts and each part is developed as a separate prototype. In the end, all the parts (prototypes) are merged which becomes a final product.
  • Extreme Prototyping – This type of prototyping model is mainly used for web applications. It is divided into three phases-
    • First, a basic prototype with static pages is created, it consists of HTML pages.
    • Next, using a services layer, data processing is simulated.
    • In the last phase, services are implemented.

Advantages of Prototype Model

Prototype model offers the following benefits-

  • Quick client feedback is received which speeds up the development process. Also, it helps the development team to understand the client’s needs.
  • Developed prototypes can be used later for any similar projects.
  • Any missing functionality and any error can be detected early.
  • It is useful when requirements are not clear from the client’s end, even with limited requirements, the development team can start the development process.

Disadvantages of Prototype Model

Apart from appealing advantages, the prototype model has many disadvantages that are listed below-

  • It is a time-consuming process or method as multiple prototypes might be needed until the client reaches the final requirements. The Client may not have an explicit idea about what they want.
  • This method involves too much client interaction and involvement, which can be done only with a committed client.
  • In the beginning, it is a bit difficult to predict the exact amount of time needed to reach the final product.
  • While coding, developers do not have a broad perspective of what is coming, because of which they might use an underlying architecture that is not suitable for a final product.
  • To produce the quick prototype, developers might make weak decisions during the development process (especially implementation decisions), and compromise on quality which might eventually affect the product.


The prototype model is a trial and error method which has its advantages and disadvantages. It is particularly useful when the client does not have clarity on what all features, they need in the product.

От QA genius