Quick prototypes, and keeping them off the roadmap

Three terns flying over breaking surf while a line of pelicans floats on the water beyond the wave

I like quick prototypes more than most managers I know, and I have also watched more of them go wrong than most managers I know. I think both are true for the same reason. A prototype is the cheapest way to answer a real question, and the cheapest way to accidentally start a product.

Why I like them

A prototype answers a question. Will this approach be fast enough. Can this integration be done. Will anyone use this. A few days of code settle those in a way a design document cannot, because the document is a prediction and the prototype is a result.

I also think prototypes are good for teams. They let an engineer try something without the weight of production standards, which is where many of the best ideas come from, and they give a team something to look at together, which turns opinions into observations.

How they go wrong

The prototype works. Someone with influence sees it. The question gets answered yes, and the obvious next step is to ship it. So the shortcuts that made it fast to build become the foundation of something that now has to last, with no tests, no error handling, and a data model that was right for a demo.

I do not think this happens because anyone is careless. It happens because a working prototype looks like a product to everyone except the person who built it, and that person is usually outnumbered.

The rules I think keep them honest

Name the question first. A prototype without a written question is a project without a scope. If the team cannot say what they will know at the end that they do not know now, it should not start.

Time-box it. Days, not weeks. A prototype that is still going after two weeks is a product with a worse name.

Throwaway by default. I think the code should be assumed discarded, and anything that survives should be rewritten into the real codebase on purpose. Saying this at the start is what makes it possible to say at the end.

Demo the learning, not the code. The thing being shown is the answer to the question, and the code is evidence.

Decide what happens next before the demo. If the answer is yes, what is the real project, who owns it, and when does it get planned. That decision belongs on the roadmap through the normal door, and I think making it in the demo meeting is how prototypes become products.

Where this stops being true

Sometimes the prototype is the only path. A deadline that cannot move, a market moment, a case where a rough thing now is worth more than a good thing later. I think that is a legitimate choice, and the honest version is to say so. We are shipping the prototype, we know what it is, and here is the plan to pay for that. The failure is not shipping a prototype. It is shipping one without admitting it.

Photo source: https://photos.robertstowe.com/cumberland-island