Back to all posts
Process7 min read·October 25, 2026

When Do You Need a Software Proof of Concept?

TB
ThynkBlox Team
Engineering

You need a software proof of concept when an unresolved technical question could change whether, or how, you build a product. Use it to test a specific capability before committing to work that depends on it. Start by defining the evidence you need to make that decision; a working demonstration alone is not enough.

What should a software proof of concept prove?

A proof of concept is a limited experiment that tests whether a proposed technical approach can meet a defined requirement.

The question should be narrow enough to answer with evidence. “Can we build this platform?” leaves too much open. “Can we import the customer's actual file format without losing required fields?” gives the experiment a clear target.

A useful question names:

  • The capability you need.
  • The conditions under which it must work.
  • The limit or constraint that matters.
  • The decision the result will inform.

For example: “Can the proposed document reader extract the required fields from representative scans, while identifying unreadable documents for manual review?”

That question gives failure a useful meaning. If the approach cannot distinguish a readable document from an unreadable one, the proposed workflow needs reconsideration.

When is a proof of concept worth doing?

Use one when the uncertainty is consequential and an experiment offers a practical way to reduce it.

UncertaintyWhat to testDecision it informs
An external system may not support a required actionComplete that action through the available interfaceWhether the integration is viable
Existing data may be unsuitable for migrationImport representative records and check required relationshipsWhether to proceed or prepare the data first
A device may not work under expected conditionsExercise the required behaviour on the intended hardwareWhether to use that device
A processing approach may be too slowRun representative workloads against an agreed limitWhether to retain the approach
A document reader may miss important informationEvaluate representative documents against checked answersWhether to automate, add review, or stop

Ask what you would do differently if the experiment failed. If the answer is “nothing”, reconsider whether you need the experiment.

Also check whether existing documentation, a technical conversation, or a small configuration check can answer the question. Use the least work needed to reach a defensible decision.

How is this different from a prototype or an MVP?

Choose the activity according to the uncertainty you need to resolve.

For this decision, use a proof of concept to test technical feasibility, a prototype to explore how people understand and use a proposed experience, and a minimum viable product, or MVP, to deliver a limited useful product and learn from its use.

A clickable screen cannot establish whether a required integration works. Equally, a successful integration test cannot establish whether customers want the resulting product.

If your main uncertainty concerns navigation or comprehension, start with design before development. If you are ready to scope a usable first release, read how long it takes to build an MVP.

Keep the questions separate, even when the same project needs all three activities.

How do you define a question that can actually fail?

Write the acceptance criteria before building the experiment.

“Looks promising” is not a criterion. Neither is “works on our sample” unless you have defined the sample, expected result, and permitted errors.

For each requirement, record:

  • Input: what the experiment receives.
  • Expected outcome: what a correct result looks like.
  • Acceptance limit: which errors or delays are acceptable.
  • Failure behaviour: what should happen when processing cannot succeed.
  • Evidence: what you will retain to support the decision.

Include conditions that would make you reject the approach. For a file importer, silently dropping records might be disqualifying even if the remaining records import correctly.

Distinguish a pass from an incomplete test. If access to the external system never arrives, the experiment has not proved the integration impossible. It has left the question unanswered.

What counts as a realistic input?

Choose inputs that represent the conditions your product must handle, including inconvenient cases.

For an importer, include missing fields, duplicate records, unexpected characters, and the largest files you expect to support. For a search feature, include ambiguous queries and queries with no useful answer. For an integration, exercise unavailable services and rejected requests as well as successful responses.

Record why you selected each input. Identify anything important you could not test.

Protect information used in the experiment. Prefer synthetic or appropriately de-identified examples where they preserve the properties being tested. If real information is necessary, agree access, handling, and deletion arrangements before using it. See data security in modern applications for related considerations.

A pass should describe its boundaries: which inputs, conditions, and requirements were covered.

What would a well-scoped experiment look like?

Consider a proposed application that imports supplier spreadsheets.

All quantities and time limits in this example are illustrative, not recommended benchmarks.

The founder needs to know whether an existing import library can preserve required product information across the spreadsheet formats customers use.

ItemIllustrative experiment plan
QuestionCan the library read the required fields from the agreed spreadsheet formats?
Inputs20 representative files covering ordinary and problematic layouts
Time limitThree working days
Pass criteriaEvery valid test file preserves every required field
Failure criteriaAny silent record loss, incorrect field mapping, or unsupported required format
Invalid input behaviourReject the file with a clear explanation; do not import partial records silently
EvidenceInput files, checked expected outputs, actual outputs, and a list of limitations
DecisionUse the library, test an alternative, or revise the supported formats

The experiment does not need an account system, a polished dashboard, or a complete catalogue editor. It needs enough code to exercise the import and compare the results with checked answers.

If the result passes, the conclusion is limited: the library meets these import requirements on these inputs. The complete application still needs its own acceptance checks.

How long should a proof of concept run?

Set a time limit based on the question and the decision at stake. There is no useful universal duration for every experiment.

Before starting, agree what is included, who will assess the evidence, and what happens when the time expires.

At that point, choose among:

  • Proceed: the evidence meets the agreed criteria.
  • Stop or change approach: the evidence shows a disqualifying limitation.
  • Run a revised experiment: a specific unanswered question justifies further work.

Extend only with a revised question and stopping point. Avoid continuing merely because the demonstration is nearly finished.

Why might successful experimental code need replacement?

A successful experiment answers its feasibility question. Do not treat that answer as approval of every implementation choice.

Inspect how the result was achieved. The experiment may use fixed settings, manual preparation, limited error handling, or assumptions that were acceptable for testing. A released product may need permissions, recovery, monitoring, maintenance documentation, and support for conditions outside the sample.

For example, an import experiment might assume that the operator has already checked the file. The product must decide what to do when an ordinary user uploads an unchecked file.

Keep suitable components when they meet the product's requirements. Replace shortcuts that do not. Budget for that assessment and subsequent work before treating the experiment as a head start on delivery.

For more on making those trade-offs explicit, read technical debt explained for founders.

What common mistakes should you avoid?

Testing the easiest examples only. Include difficult inputs that matter to the proposed product.

Changing the criteria after seeing the result. Record any revised requirement and explain why the business can accept it.

Adding features to improve the demonstration. Build only what helps answer the technical question.

Treating one successful run as broad approval. Report exactly what was tested and what remains uncertain.

Confusing feasibility with demand. Keep evidence that something can work separate from evidence that someone wants it.

Ignoring an unsuccessful result. Use the finding to change the plan before committing to dependent work.

What should founders ask before approving the experiment?

Use this checklist:

  • What exact technical question are we testing?
  • Why does its answer matter to the build decision?
  • What representative inputs will we use?
  • What would make the approach fail?
  • What is the time limit?
  • What evidence will we receive?
  • What happens after a pass, failure, or incomplete result?
  • What work remains before anything can be released?

Approve the experiment when those answers are clear enough to judge its outcome.

Frequently asked questions

Does every software project need a proof of concept?

No. Use one for a consequential technical uncertainty. Familiar requirements supported by adequate existing evidence may be ready for ordinary design and development.

Can one proof of concept test several risks?

It can, but give each risk its own criteria and result. Avoid declaring the whole experiment successful when a critical requirement remains unresolved.

Should the experiment include a polished interface?

Include an interface only where it is necessary to test the question. Assess visual design and usability separately when those are also open questions.

Is a failed proof of concept wasted money?

Judge it by whether it answered the agreed question well enough to inform a decision. A clear failure can justify changing direction before you commit to the full build.


*Have a technical uncertainty blocking your build decision? Start a conversation about the question and the evidence needed to resolve it.*

Ready to build?

Let's turn these ideas into your next product.

Start your project