Prototype vs MVP: How to Validate an Interactive Product Before Overengineering It
A common early-stage product mistake is treating development output as product validation.
The team creates screens, components, integrations, API endpoints, and increasingly complex application logic.
The backlog is moving.
The product is growing.
But the core assumption may still be untested.
Before building a full MVP, a startup should be able to answer a simpler question:
What exactly are we trying to validate?
For some products, a clickable UI prototype is enough.
For others — especially products involving real-time 3D, WebAR, WebXR, data visualization, or spatial interaction — the experience cannot be validated through static screens alone.
The team may need a functional interactive prototype.
Prototype and MVP solve different problems
A prototype is an experiment.
Its purpose is to explore the concept, test the main interaction, and expose incorrect assumptions early.
An MVP is a usable product.
Its purpose is to deliver real value in production conditions and test market demand.
A prototype helps validate:
- interaction logic;
- product comprehension;
- technical feasibility;
- the main user flow;
- visual communication;
- investor or stakeholder response.
An MVP helps validate:
- real usage;
- retention;
- willingness to pay;
- production performance;
- operational requirements;
- market demand.
The distinction becomes important because prototypes and MVPs require different engineering decisions.
A prototype should be focused and fast.
An MVP needs a more reliable technical foundation.
Building the second before learning from the first can lead to unnecessary architecture, unused features, and expensive rework.
Define the hypothesis before choosing the stack
Teams often begin technical discussions too early.
Should we use React?
Should the 3D layer be built with Three.js?
Do we need WebXR support?
Should the backend be serverless?
These may be relevant questions, but they are not the first questions.
The first questions should be:
- What user problem are we testing?
- What interaction represents the core value?
- What evidence would confirm or reject the hypothesis?
- Which part needs to be functional?
- Which part can be simulated?
Suppose the idea is a real-time furniture configurator.
The core hypothesis may not be:
Can we render a chair in a browser?
That is already technically possible.
A more useful hypothesis may be:
Does real-time customization help users understand the product and make a purchasing decision more confidently?
The prototype should therefore focus on the interaction that tests this question:
- selecting a model;
- changing materials;
- changing dimensions or components;
- displaying the result immediately;
- possibly updating the price.
Authentication, account management, advanced analytics, and a complete CMS may not be necessary yet.
Functional prototypes for real-time 3D products
Static mockups are useful for interface structure, but they cannot validate every type of experience.
When a product depends on direct manipulation, spatial understanding, or real-time feedback, the prototype may need to include actual working logic.
For a browser-based 3D prototype, that could include:
- one optimized 3D model;
- a limited set of configurable materials;
- basic camera controls;
- a small number of user actions;
- simplified pricing or business logic;
- performance testing on selected devices.
The goal is not to reproduce the final system.
The goal is to implement the smallest technically meaningful experience that can answer the main product question.
Avoid prototype code becoming accidental production architecture
There are two common extremes.
Extreme 1: Overengineering
The team designs a highly scalable architecture before validating whether users want the experience.
This can lead to:
- unnecessary abstractions;
- complex state management;
- premature microservices;
- a large CMS;
- expensive DevOps infrastructure;
- months of work before useful feedback.
Extreme 2: Throwaway development without boundaries
The team builds a demo with no attention to performance, content structure, or future requirements.
The prototype succeeds, but the team then tries to scale the same codebase even though it was never designed for production.
A better approach is to define the role of the prototype clearly.
Decide in advance:
- which code may be reused;
- which parts are deliberately temporary;
- what performance level is required;
- what data will be simulated;
- what must be real;
- what would need to change for the MVP.
This avoids confusing speed with carelessness.
Technical questions for interactive prototypes
For a WebGL or Three.js prototype, several technical decisions can affect the quality of the validation.
Model complexity
A detailed model may look impressive but perform poorly on common devices.
Use an appropriate polygon count, compressed textures, and only the assets needed for the test.
Loading time
If the experience takes too long to load, user feedback may reflect frustration with performance rather than the value of the concept.
Device coverage
Testing only on a high-end development machine gives an incomplete result.
Define the target browser and device range early.
Interaction design
Orbit controls may be enough for a product viewer, but not for every product.
The interaction should reflect the real user task rather than a generic 3D demo.
Data architecture
Even when using simulated data, structure it in a way that resembles the expected real system. This makes later integrations easier to evaluate.
WebXR requirements
If VR or AR is central to the concept, test it early.
Adding XR support after the entire interaction model has been designed for a desktop screen can require substantial changes.
Example: a business system represented as a 3D city
In one AESTAR project, we built a virtual business dashboard in the form of an interactive 3D city.
Each building represents a software module. Its visual characteristics communicate information about its role and current state.
Users can:
- navigate the city;
- explore individual modules;
- view dynamically updated API data;
- understand connections between system components;
- access the experience in a browser or VR.
The technical challenge was not simply rendering a city.
The product challenge was finding an interaction model that made a complex software system easier to explore.
This distinction matters.
Three.js, WebGL, or WebXR are tools. The product value comes from how those tools support the user’s task.
What should be validated before the MVP?
Before moving from prototype to MVP, a team should have clearer answers to several questions.
1. Do users understand the main value?
The experience should not require a long explanation from the founder.
2. Can users complete the core interaction?
The main user flow should be understandable and technically reliable.
3. Does the interactive layer improve the experience?
3D or XR should solve a meaningful problem, not exist only as visual decoration.
4. What performance is acceptable?
Define measurable expectations for loading, frame rate, and supported devices.
5. Which prototype components can be reused?
Separate validated concepts from temporary implementation decisions.
6. What does the MVP need that the prototype does not?
This may include authentication, persistence, analytics, CMS functionality, security, scalability, and production monitoring.
A practical process
A focused workflow can look like this:
- Define the user problem.
- Write the core hypothesis.
- Identify the smallest meaningful interaction.
- Build a functional prototype.
- Test it with target users or stakeholders.
- Document technical and product findings.
- Define the MVP based on evidence.
- Design the production architecture.
This process does not eliminate uncertainty.
It helps the team spend money on the right uncertainty.
Final thought
The goal of an early prototype is not to prove that the development team can build something impressive.
The goal is to learn whether the product experience deserves to be built at scale.
A startup does not always need more features.
Sometimes it needs a smaller, sharper experiment.
AESTAR builds interactive prototypes, browser-based 3D applications, WebAR and WebXR products, configurators, and immersive digital platforms.
