In the traditional SDLC, software is created on a well planned pattern. There will be planning, consultation, creation, testing, documentation and launching. This pattern is seen in most development software. Since it’s planned right from the start, it should be efficient as planned. When the plan is properly executed, everything will work as it is written.

However, it is important to note that this type of development is all focused on the developers and not the consumers. Although it has its advantages, the structured creation of a program makes it harder to create variations before the program is launched.

To answer that need, another model for developing software is created. Called the Prototype model, the development of the program is not based on strict planning, but it is based on the response of the users instead. The prototyping is a concept that bases its development by creating prototypes after prototypes until the “perfect” software is created.

As a type of SDLC, the Prototype Model slowly builds from a simple concept of what a program is. Little by little the software is updated and tested in a real time environment. Users will be able to test and improve the software as they are created. This goes in a different pattern if you compare it to the regular SDLC pattern, and the feedback is only in the later stage. If there are any changes, it has to go back to the drawing board, wasting more time.

There are different types of a prototype model of SDLC. Each of them has their own advantage and disadvantage but ultimately, the prototype model is geared to be changed constantly until it reaches its intended audience and function.

Prototype Models Types

There are four types of Prototype Models based on their development planning: the Patch-Up Prototype, Nonoperational Prototype, First-of-a-Series Prototype and Selected Features Prototype.

Patch Up Prototype

This type of Prototype Model encourages cooperation of different developers. Each developer will work on a specific part of the program. After everyone has done their part, the program will be integrated with each other resulting in a whole new program. Since everyone is working on a different field, Patch Up Prototype is a fast development model. If each developer is highly skilled, there is no need to overlap in a specific function of work. This type of software development model only needs a strong project manager who can monitor the development of the program. The manager will control the work flow and ensure there is no overlapping of functions among different developers.

Non-Operational Prototype

A non-operational prototype model is used when only a certain part of the program should be updated. Although it’s not a fully operational program, the specific part of the program will work or could be tested as planned. The main software or prototype is not affected at all as the dummy program is applied with the application. Each developer who is assigned with different stages will have to work with the dummy prototype. This prototype is usually implemented when certain problems in a specific part of the program arises. Since the software could be in a prototype mode for a very long time, changing and maintenance of specific parts is very important. Slowly it has become a smart way of creating software by introducing small functions of the software.

First of a Series Prototype

Known as a beta version, this Prototype Model could be very efficient if properly launched. In all beta versions, the software is launched and even introduced to the public for testing. It’s fully functional software but the aim of being in beta version is to as for feedbacks, suggestions or even practicing the firewall and security of the software. It could be very successful if the First of a Series Prototype is properly done. But if the program is half heartedly done, only aiming for additional concept, it will be susceptible to different hacks, ultimately backfiring and destroying the prototype.

Selected Features Prototype

This is another form of releasing a software in beta version. However, instead of giving the public the full version of the software in beta, only selected features or limited access to some important tools in the program is introduced. Selected Features Prototype is applied to software that are part of a bigger suite of programs. Those released are independent of the suite but the full version should integrate with other software. This is usually done to test the independent feature of the software.

Prototype Model Disadvantages

Implementing the prototype model for creating software has disadvantages. Since its being built out of concept, most of the models presented in the early stage are not complete. Usually they lack flaws that developers still need to work on them again and again. Since the prototype changes from time to time, it’s a nightmare to create a document for this software. There are many things that are removed, changed and added in a single update of the prototype and documenting each of them has been proven difficult.

There is also a great temptation for most developers to create a prototype and stick to it even though it has flaws. Since prototypes are not yet complete software programs, there is always a possibility of a designer flaw. When flawed software is implemented, it could mean losses of important resources.

Lastly, integration could be very difficult for a prototype model. This often happens when other programs are already stable. The prototype software is released and integrated to the company’s suite of software. But if there’s something wrong the prototype, changes are required not only with the software. It’s also possible that the stable software should be changed in order for them to be integrated properly.

Prototype Model Advantages

Creating software using the prototype model also has its benefits. One of the key advantages a prototype modeled software has is the time frame of development. Instead of concentrating on documentation, more effort is placed in creating the actual software. This way, the actual software could be released in advance. The work on prototype models could also be spread to others since there are practically no stages of work in this model. Everyone has to work on the same thing and at the same time, reducing man hours in creating a software. The work will even be faster and efficient if developers will collaborate more regarding the status of a specific function and develop the necessary adjustments in time for the integration.

Another advantage of having a prototype modeled software is that the software is created using lots of user feedbacks. In every prototype created, users could give their honest opinion about the software. If something is unfavorable, it can be changed. Slowly the program is created with the customer in mind.

“Over Design” could also be avoided using this model. “Over Design” happens when a software has so many things to offer that it sacrifices the original use of the software. This also goes back in giving only what the customer wants.

Generally, a prototype model has great advantage over other SDLC models since it doesn’t rely on what is suppose to happen in written documentation. Instead it goes directly to the users and asking them what they really want from a software. Slowly the product is developed by professionals, catering to the needs of the users.