Chapter 06 of 32

Prototyping Model

Imagine your college asks you to build a "canteen pre-order app". You ask the canteen owner what he wants, and he says: "Something simple. Students should order and pay. Make it nice." That is all. If you now write a 40-page requirements document and spend three months coding, there is a very good chance that on demo day he says: "No, no, I wanted students to pick a pickup time, and why is there no token number?"

The problem is not lazy coding. The problem is that the customer did not know exactly what he wanted until he saw something. Most people are much better at reacting to a working screen than at describing a system in words. The Prototyping Model is built around exactly this fact.

The Prototyping Model is a software process model in which a quick, partial, working version of the system (a prototype) is built and shown to users early, so that their feedback can be used to discover and refine the real requirements before (or while) the final system is engineered.

In the Waterfall Model chapter we saw that Waterfall assumes requirements are known and frozen at the start. In Iterative & Incremental Models we saw how software can be delivered in pieces. Prototyping attacks a slightly different problem: unclear requirements. It is a tool for learning what to build.


The Intuition: Trial Rooms and Model Flats

Builders of apartment complexes often make a model flat before the building is finished. Buyers walk through it, notice that the kitchen feels small or the balcony faces the wrong way, and the builder adjusts the design. Nobody actually lives in the model flat; its job is to help people decide.

A software prototype plays the same role. It looks and behaves enough like the real system that users can react to it, but it usually skips the hard, invisible parts: security, performance, error handling, real databases, scalability.

A prototype usually HAS

A prototype usually SKIPS

Screens, menus, navigation flow

Real authentication and security

Sample (fake or hard-coded) data

Real database design, backups

The main user journeys

Edge cases and error handling

Enough logic to "feel" real

Performance, scalability, maintainability


Phases of the Prototyping Model

The classic textbook description (as in Pressman) is a loop of communication, quick design, construction and feedback, followed by full engineering once the requirements are clear.

   +------------------------------+
   | 1. Requirements gathering    |   (initial, incomplete requirements)
   +------------------------------+
                  |
                  v
   +------------------------------+
   | 2. Quick design              |   (focus on what the user SEES)
   +------------------------------+
                  |
                  v
   +------------------------------+
   | 3. Build prototype           |   (fast, cheap, partial)
   +------------------------------+
                  |
                  v
   +------------------------------+
   | 4. User evaluation           |   (users try it, give feedback)
   +------------------------------+
                  |
          satisfied?  -- No -->  5. Refine prototype --+
                  |                                   |
                 Yes        (back to quick design) <--+
                  |
                  v
   +------------------------------+
   | 6. Engineer the real product |   (design, code, test, deploy, maintain
   +------------------------------+    using a proper process)
  1. Requirements gathering. Developers and users meet and agree on the overall objectives. Requirements known for sure are written down; areas that are fuzzy are marked as places where the prototype must help.

  2. Quick design. A rough design focusing on the parts visible to users: input forms, output formats, screen flow. Internal architecture is deliberately ignored.

  3. Build the prototype. Using fast tools: wireframing tools, a UI builder, a scripting language, hard-coded data.

  4. User evaluation. Users use the prototype and say what is wrong, missing or confusing.

  5. Refinement. The prototype is changed according to feedback, and steps 2 to 4 repeat. Each round, the requirements become clearer.

  6. Engineer the product. When users are satisfied, the now-clear requirements are documented (often as an SRS) and the real system is built with full attention to quality.

Why the loop ends: each cycle should reduce the number of surprises. When a round of evaluation produces only small cosmetic comments, the requirements have stabilized and it is time to build properly.


Types of Prototyping

The most important exam distinction is what happens to the prototype after it has done its job.

1. Throwaway (Rapid) Prototyping

The prototype is built quickly only to clarify requirements, and then it is discarded. The real system is built from scratch with proper design. Fred Brooks' famous advice "plan to throw one away" captures the idea: the first version teaches you what the system should be. (Brooks later noted, in the 1995 anniversary edition of The Mythical Man-Month, that with incremental development you need not always throw a whole version away; for a quick prototype built only to learn, though, discarding it is still the right call.)

  • Good for: unclear requirements, especially user-interface requirements.

  • Risk: management sees a "working" demo and wants to ship it. The prototype was never designed for production.

2. Evolutionary Prototyping

The prototype is not thrown away. It is built more carefully from the start, and it is refined again and again until it becomes the final system. Usually the well-understood requirements are built first, and the prototype grows as users discover what else they need.

  • Good for: systems where requirements keep emerging, such as research tools or new products.

  • Risk: repeated patching can make the structure messy unless the team refactors regularly.

3. Incremental Prototyping

The final system is split into parts, and a separate prototype is built for each part. The prototypes are later merged into one product. This links naturally with the incremental delivery ideas from Iterative & Incremental Models.

4. Extreme Prototyping

Used mainly for web applications. It proceeds in three phases:

  1. Build static HTML pages showing every screen.

  2. Make the screens work against a simulated services layer (fake responses).

  3. Implement the real services and connect them.

Comparison Table

Type

Fate of prototype

Build quality

Best when

Throwaway

Discarded

Quick and dirty is fine

Requirements are very unclear

Evolutionary

Grows into final system

Must be reasonably good from day one

Requirements emerge over time

Incremental

Parts merged into final system

Moderate to good

System divides into clear parts

Extreme

Evolves through 3 phases

Increases each phase

Web applications

Other Ways to Classify Prototypes

  • Low-fidelity vs high-fidelity. A paper sketch or wireframe is low-fidelity: cheap, quick, good for layout ideas. A clickable, realistic mock-up is high-fidelity: closer to the real feel, but slower to make.

  • Horizontal vs vertical. A horizontal prototype shows many features but only at the surface (all screens, no real logic). A vertical prototype implements one feature through all layers (screen, logic, database) to test technical feasibility, for example "can our payment flow really respond in under 2 seconds?"


A Tiny Throwaway Prototype

Here is what a throwaway prototype of our canteen app could look like at the very first meeting. It is a short Python script with a hard-coded menu and hard-coded "user input". It has no database, no login, no payment. Its only job is to let the canteen owner react to the flow.

# Throwaway prototype of a canteen pre-order app.
# No database, no login, no payment: just enough to show users the flow.

MENU = {1: ("Masala Dosa", 50), 2: ("Veg Thali", 80), 3: ("Cold Coffee", 40)}

def show_menu():
    print("--- Today's Menu ---")
    for code, (item, price) in MENU.items():
        print(f"{code}. {item:<12} Rs {price}")

def place_order(choices):
    total = 0
    print("--- Your Order ---")
    for code, qty in choices:
        item, price = MENU[code]
        print(f"{item:<12} x{qty}  = Rs {price * qty}")
        total += price * qty
    print(f"Total: Rs {total}")
    print("Pickup token: A-17  (fake token, prototype only)")

show_menu()
place_order([(1, 2), (3, 1)])   # hard-coded "user input" for the demo

Output:

--- Today's Menu ---
1. Masala Dosa  Rs 50
2. Veg Thali    Rs 80
3. Cold Coffee  Rs 40
--- Your Order ---
Masala Dosa  x2  = Rs 100
Cold Coffee  x1  = Rs 40
Total: Rs 140
Pickup token: A-17  (fake token, prototype only)

Shown this, the owner might say: "Add a pickup time slot. Hide items that are sold out. The token should start with the counter number." Each comment is a requirement that nobody wrote down at the first meeting. That is the prototype doing its job.

Notice what the code does not do: it crashes on an invalid menu code, it has no stock or concurrency control (two students could both order the last plate of dosa), and the token is fake. That is perfectly fine for a throwaway prototype and completely unacceptable for the real product, which is exactly why it should be thrown away.


Worked Example: Is Prototyping Worth It?

A team is building an exam-registration portal for a university. Their past experience says that when the UI requirements are misunderstood, the rework after delivery costs about ₹6,00,000. Without a prototype, they estimate a 50% chance of such a misunderstanding. A two-week throwaway prototype costs ₹1,00,000 and is expected to reduce that chance to 10%.

Step 1: Expected rework cost without prototype = 0.50 × 6,00,000 = ₹3,00,000.

Step 2: Expected rework cost with prototype = 0.10 × 6,00,000 = ₹60,000.

Step 3: Expected saving = 3,00,000 − 60,000 = ₹2,40,000.

Step 4: Net benefit = 2,40,000 − 1,00,000 (prototype cost) = ₹1,40,000.

The prototype pays for itself. If the requirements had been very clear (say only a 5% chance of misunderstanding), the expected saving would be tiny and the prototype would not be worth building. This "spend a little to reduce a big uncertainty" reasoning is the seed of the risk-driven thinking we formalize in the next chapter, Spiral Model.


Advantages

  • Users get involved early and see something concrete, so misunderstandings surface before expensive coding.

  • Missing and confusing requirements are discovered early, reducing costly late changes.

  • Better user interfaces, because users shaped them.

  • Higher user satisfaction and buy-in: users feel ownership of the design.

  • Technical risk can be tested with vertical prototypes (new library, new hardware, performance limits).

Disadvantages

  • The "it's almost done" illusion. Users and managers see a working screen and expect the full product next week, not realizing the prototype is held together with tape.

  • Pressure to ship the throwaway prototype, leading to poor-quality, unmaintainable software.

  • Implementation compromises. Developers may pick a convenient but unsuitable language, database or algorithm for the prototype and then forget to replace it.

  • Scope creep. Every demo invites new wishes; without control, the loop never ends.

  • Extra cost when the prototype is thrown away, and poor documentation if the team keeps iterating informally.


When to Use (and Not Use) Prototyping

Use prototyping when...

Avoid or limit it when...

Requirements are unclear or users cannot express them

Requirements are well known and stable (e.g. a payroll rule set fixed by law)

The system has heavy user interaction (apps, portals, dashboards)

The system has little UI (batch jobs, compilers, embedded control logic)

A new technology must be tried before committing

Users are unavailable to evaluate prototypes

Users and developers come from very different domains

The team cannot resist shipping prototype code


Prototyping vs Waterfall

Aspect

Waterfall

Prototyping

Requirements

Fixed at the start

Discovered through feedback

User involvement

Mostly at start and end

Continuous during prototype cycles

First thing users see

Near-final product, late

A rough prototype, early

Main risk handled

None explicitly

Wrong or incomplete requirements

Cost of a requirement change

High (found late)

Low (found early)

Prototyping is often combined with other models rather than used alone: a team may use a throwaway prototype to fix requirements and then follow Waterfall or an incremental model to build the real thing. The Spiral Model (next chapter) uses prototyping inside every loop.


Common Mistakes

  • Treating the prototype as the product. A throwaway prototype has no proper design, testing or security. Shipping it creates technical debt from day one.

  • Saying "prototyping means no documentation". Once requirements stabilize, they should still be written down (often as an SRS) before full development.

  • Confusing throwaway and evolutionary. Throwaway is discarded; evolutionary becomes the final system. The question "what happens to the prototype?" decides it.

  • Polishing the prototype. Spending weeks on colours and animations defeats the purpose. A prototype should be just good enough to get feedback.

  • Thinking prototyping is only for UI. Vertical prototypes are used to test technical feasibility too.


GATE and Interview Questions

Which process model is most suitable when the customer cannot state requirements clearly?

The Prototyping Model. A quick prototype lets the customer react to something concrete, and the real requirements emerge from that feedback.

What is the difference between throwaway and evolutionary prototyping?

A throwaway prototype is built quickly only to clarify requirements and is then discarded; the real system is built from scratch. An evolutionary prototype is built with more care and is refined repeatedly until it becomes the final system.

Why is it dangerous to deliver a throwaway prototype to the customer?

It was built for speed, not quality: it typically lacks proper architecture, error handling, security, performance tuning and documentation, and may use unsuitable technologies. Maintaining it in production is expensive and risky.

What are horizontal and vertical prototypes?

A horizontal prototype covers many features at the user-interface level with little or no real logic. A vertical prototype implements a single feature completely through all layers, usually to check technical feasibility or performance.

A prototype costs ₹50,000 and reduces the probability of a ₹4,00,000 requirements failure from 0.3 to 0.1. Is it worthwhile?

Expected loss without prototype = 0.3 × 4,00,000 = ₹1,20,000. With prototype = 0.1 × 4,00,000 = ₹40,000. Saving = ₹80,000, which is more than the ₹50,000 cost. Net benefit = ₹30,000, so yes.

Name the three phases of extreme prototyping.

(1) Static HTML pages for all screens, (2) screens made functional against a simulated services layer, (3) real services implemented and integrated.


Summary

  • The Prototyping Model builds a quick, partial version of the system to discover and refine requirements through user feedback.

  • Cycle: requirements gathering → quick design → build prototype → user evaluation → refine (repeat) → engineer the real product.

  • Throwaway prototypes are discarded; evolutionary prototypes become the final system; incremental prototypes are merged; extreme prototyping is a three-phase approach for web apps.

  • Prototypes can be low- or high-fidelity, and horizontal (breadth) or vertical (depth).

  • Biggest strengths: early user involvement and fewer requirement surprises. Biggest danger: shipping a prototype that was never meant for production.

  • Best for unclear, UI-heavy requirements; little value when requirements are stable and well understood.

Prototyping reduces one kind of risk: not knowing what the user wants. In the next chapter, Spiral Model, we will see a model that makes every kind of risk the driving force of the whole process.