Prototyping Model in SDLC [Phases, Pros & Cons]

Posted in

Prototyping Model in SDLC [Phases, Pros & Cons]

Sameeksha Medewar
Last updated on November 5, 2022

    Before we start discussing the prototyping model in SDLC, let us first understand what a prototype is. In general, a prototype is an early release, sample, or model of a product developed with the aim of testing the concept or process. In software development, a prototype is an elementary working model of the main software product created with the intent of demonstration purpose of as a part of the software development process .

    In SDLC, the prototyping model is one of the methodologies based on creating prototypes. The development team creates the prototype of the developing product to showcase its functional behavior to clients and end users. However, it is important to note that the prototype does not involve the exact logic the same as the final product would hold.

    Let us know more about the prototyping model in SDLC in detail, along with its types, pros, and cons, in this article.

    What is the Prototyping Model?

    A prototyping model is an approach to software development that entails creating the prototype of the product under development. This prototype or workable copy is then tested and reworked until it converts into an acceptable prototype.

    End users and clients review the prototype and provide feedback. Based on feedback, the development team improves the prototype, and the process continues until the prototype that meets end users’ requirements is developed. The acceptable prototype serves as a foundation or base for the development of the original or final software product.

    This model is ideal for projects with no clearly defined and detailed requirements at the onset of development. In addition, this model is an iterative and trial-and-error method that takes place between developers and clients or end users.

    In a nutshell, we can say that the prototyping model is an SDLC approach to software development by creating a workable copy of the software product that has to be developed.

    Phases in Prototyping Model

    Let us now throw light on the different phases of this model below.

    1. Requirements Gathering and Analysis

    This phase involves collecting the requirements of the software product that has to be developed. The project team interviews end users or customers in order to identify their requirements or expectations of the software product.

    Here, only the requirements related to the user interface are understood. Other complex requirements of the software product, such as performance, security, etc., can be overlooked.

    2. Quick Design

    After collecting requirements, there comes the time for creating a quick design of the software product, which is generally referred to as a preliminary design. However, it does not involve creating the complex design of the system. Instead, the development team creates a simple design of the software product that provides end users with a brief idea of what exactly the final product would be. This preliminary design assists developers in creating the prototype of the product.

    3. Build a Prototype

    With reference to the preliminary or quick design, the development team builds the first prototype of the software product. It is generally a scaled-down and working model that represents the functional behavior of the final product. It represents what characteristics or features the final product is going to hold.

    4. User Evaluation

    The development team presents the first prototype in front of clients and end users for evaluation. They understand and analyze the prototype and point out its strength and weakness. Also, they provide feedback or suggestions about what the final product should include and what not, based on their analysis. Finally, the development team collects remarks from all end users and clients.

    5. Refining Prototype

    In this phase, the development team analyzes the collected feedback from customers and clients. Based on that, they refine or modify the first prototype and create a new prototype that is in compliance with end users’ expectations.

    The same process takes place. Again, clients and customers review the second prototype, provide their feedback, and the development creates a new prototype based on that feedback. The user evaluation and refining prototype phases work in a loop until the final acceptable prototype that meets all the requirements of end users is created.

    6. Implement and Maintain

    In this phase, the implementation of the actual software product takes place. The development team leverages the final prototype accepted by end users to build the actual software product.

    After the implementation, the software product undergoes thorough testing. Finally, the software product is deployed into the production environment. Later, it undergoes regular maintenance to prevent potential failures and reduce downtime.

    Types of Prototyping Model

    There are four types of prototyping models, as follows:

    1. Rapid Throwaway Prototyping

    As its name implies, rapid throwaway prototyping is quickly developed depending on the preliminary requirements of end users. This prototype highlights how the preliminary requirements appear visually. It is not always necessary that the first prototype developed should be a part of the final accepted prototype.

    After the creation of the first prototype, customers review it and provide feedback. The development team again creates a new prototype and sends it for review. The process continues until they create the final acceptable prototype.

    This type of mode comes in handy for finding out ideas and getting quick feedback from end users.

    2. Evolutionary Prototyping

    This type of model entails the incremental refinement of the prototype developed initially based on customers’ feedback until the customers accept it. It is considered a better approach than rapid throwaway because it eliminates the need to create a prototype from scratch in every iteration of the process.

    Instead, this model leverages the first prototype and improves it in every iteration of the process as per the customers’ feedback. So, this model is time-saving as well as requires less effort.

    This model is useful in the following scenarios:

    • The project leverages a new technology of which the development team has little to no knowledge.
    • While developing complex projects that necessitate the checking of every functionality once.
    • When the requirements are not clearly understood in the initial phases of development.

    3. Incremental Prototyping

    This type of model splits the final product into various prototypes, where each prototype is created separately. After the development team creates all prototypes, they merge them together to create a single system.

    It is the most effective approach as it requires less development time. The time length between the project initiation and the final delivery is significantly lower than all other prototyping models. Also, it reduces the complexity of the development process by dividing a large task into multiple sub-tasks.

    4. Extreme Prototyping

    Extreme prototyping is ideal for developing web applications. It entails the following three sequential phases:

    • The first phase entails the presentation of the basic prototype with the existing static pages in the HTML format.
    • In the second phase, there is a use of the prototype service layer to create function screens with a simulated data process.
    • The final phase involves the implementation of all services and their association with the final prototype.

    Advantages and Disadvantages of Prototyping Model

    Now, lets us have a glance at the benefits and drawbacks of the prototyping model.


    • This SDLC model makes it possible for end users to see a working model in the very initial phases of software development.
    • It ensures a high level of customer satisfaction and convenience.
    • This model is adaptable to new requirements as it provides the scope for the refinement of the prototype.
    • It helps in pointing out missing functionalities easily.
    • User feedback on the prototype developed in each iteration helps in achieving a high-quality and better software solution.
    • This model allows the identification of errors and bugs at early stages, thereby saving a lot of cost and time to fix them in later phases.
    • Developers can reuse prototypes for other complex projects in the future.
    • It does not require any skilled individuals to develop prototypes.


    • This model is costly in terms of money as well as time.
    • The cost required to develop the prototype is a complete waste as it would not be used later unless and until it relates to any future projects.
    • As the requirements change frequently, there is no detailed documentation.
    • It becomes tricky for developers to accommodate all the changes provided by customers or clients.
    • There is no fixed number of iterations known beforehand required to develop the final acceptable prototype.
    • There are chances that customers may end up losing their interest in the final product if they don’t like the prototype.


    Let us wrap up our discussion on the prototyping model. It is an approach to software development that involves the creation of a prototype that goes through various iterations of user evaluation and refinement to achieve an acceptable prototype. The final acceptable prototype forms the basis for the development of the final software product. However, it is a time-consuming process that requires intense effort.

    We hope that this blog post has helped you to have a better grasp of the prototyping model.

    People are also reading:


    There are four types of prototyping: 1. Rapid (Throwaway) prototyping 2. Evolutionary prototyping 3. Incremental prototyping 4. Extreme prototyping.

    The prototype model is mostly used in software development when the customers do not have well-defined requirements at the beginning of development.

    The different phases of the prototyping model include: 1. Requirements gathering and analysis 2. Quick Design 3 Build a prototype 4. User evaluation 5. Refining prototype 6. Implement and maintain.

    Yes, the prototyping model is an iterative as well as a trial-and-error process.

    Leave a Comment on this Post