---
title: "Proof of Concept Software: What It Proves"
source: https://refact.co/insights/digital-product/proof-of-concept-software
author: "Parnia Sebti"
date: "2026-11-19"
---

# Proof of Concept Software: What It Proves

A working demo convinces people more than anything else a software project produces, and it tells them less than almost anything else. It runs once, on data someone picked, in an environment built to let it pass. Gartner’s 2024 survey found that only 48% of AI projects reached production, and the ones that did took about eight months to get from prototype to live. Most of those projects had a demo that worked.

Proof of concept software is a small, time-boxed build that tests whether one technical idea can work before a team commits to the full product. This guide is for the people who approve what happens next: product owners, operators and business leads deciding whether to fund a build. It covers what a PoC can prove, what it leaves untested, and how to scope one so the result settles a decision instead of starting an argument.

## Proof of Concept Software Answers One Question

A developer closes a laptop and says the feature is buildable. Everyone at the table nods, but they heard different sentences. The developer means the code ran. The business lead hears that the product is viable. Nobody wrote down which claim was under test, so nobody can say what the demo actually settled.

A proof of concept exists to close that gap. Researchers Petrillo and Antognolli define it as a short, limited-scope experiment that tests a hypothesis, reduces risk and informs a decision. In [their paper on PoCs as architectural decision tools](https://arxiv.org/html/2604.05835), they also point out that most teams run PoCs ad hoc, without a planning phase or a defined decision at the end. Their fix is simple: plan the test, run it, then make the call it was built for.

The research software team at Princeton describes it the same way in its [glossary of software development terms](https://princeton-cdh.github.io/docs/terms-definitions/). A PoC is a small, incomplete implementation that tests whether an approach is feasible before you commit serious development resources. The word that matters is “before.” Once the build budget is approved, a PoC has nothing left to decide.

### What a typical build contains

A well-scoped PoC is short on parts, and every part serves the question rather than the demo:

-   **One core function:** the single piece of logic under test, with nothing built around it.
-   **Representative data:** real records with real mess in them, not a full database and not hand-typed samples.
-   **Rough screens or a script:** just enough to trigger the function, unstyled on purpose.
-   **A written threshold:** the number that decides pass or fail, agreed before work starts.

The threshold does most of the work. Without a failure condition, a PoC turns into a demo that is very hard to call unsuccessful. With one, the result reads as a verdict: the claim held under these conditions, or it didn’t.

![Technology readiness level scale showing where proof of concept software sits at TRL 3 to 4](https://refact.wpengine.com/wp-content/uploads/2026/11/image_placeholder_1-4.avif)

On the nine-tier Technology Readiness Level scale, a successful proof of concept sits at Level 3—marking early research validation rather than ready-to-deploy software. · Source: www.twi-global.com

NASA’s [Technology Readiness Level definitions](https://esto.nasa.gov/trl/) are a useful way to place this. Software proof-of-concept work sits around TRL 3 to 4, where a critical function is validated in a lab setting, well before anything runs in an operational environment. That framing keeps everyone honest about distance. A passing PoC has climbed a few rungs. It has not reached the top.

### What it does not prove

A PoC tests feasibility. It does not test demand, usability, scale, cost under real load or whether anyone will pay. One developer summed up a failed product on X in a sentence: “The code was fine. I just built it before talking to a single person who’d use it.” If the uncertainty is about customers, no amount of code will settle it.

> A proof of concept answers whether something can be built under specific conditions. It never answers whether anyone should buy it, or whether it will hold up in production.

## PoC, Prototype, MVP and Pilot Remove Different Risks

These four labels get swapped in kickoff meetings, and enterprise AI reporting blurs “pilot” and “PoC” so often that the statistics become hard to read. The cleanest way to separate them is by the risk each one removes.

| Build | Question it answers | Who sees it | What it cannot tell you |
| --- | --- | --- | --- |
| **Proof of concept** | Can this technical approach work under realistic conditions? | Engineers and the people making the build decision | Whether users want it or how it behaves at scale |
| **Prototype** | How should the product look and flow? | Designers, stakeholders, test users | Whether the underlying system can be built |
| **MVP** | Will real customers use it and pay for it? | Real end users | How the full product performs at volume |
| **Pilot** | Does it work in the real operation, with real staff? | A limited group of live users | Whether results hold across every site or team |

[Asana’s breakdown of PoC, prototype and MVP](https://asana.com/resources/proof-of-concept) draws the same line: a PoC demonstrates feasibility, a prototype explores how the product works and looks, and an MVP gets tested against actual users. We cover the first two in more depth in our guide to [proof of concept vs prototype](https://refact.co/insights/digital-product/proof-of-concept-vs-prototype), and the design side in [MVP vs prototype](https://refact.co/mvp-vs-prototype).

![Diagram comparing proof of concept software, prototype and MVP stages](https://refact.wpengine.com/wp-content/uploads/2026/11/image_placeholder_2-9.avif)

A structured breakdown shows how proof of concept, prototype, pilot, and MVP builds address fundamentally different validation goals and project risks. · Source: www.nesta.org.uk

### The same idea at three depths

A marketplace team needs to know whether a payment provider can split one order’s payout between two sellers. That is a proof of concept, and it takes days.

A clinic owner wants to see whether a patient can book an appointment in three taps. That is a prototype: no backend, just the flow, put in front of five patients. Teams that test flows like this early tend to learn more than teams that wait for polish, a point [Uxia’s guide to prototyping and testing](https://www.uxia.app/blog/prototyping-and-testing) makes well.

A booking tool wants to know whether 50 paying clinics stay past month three. That is an MVP, and it takes months because retention takes months. These [minimum viable product examples](https://refact.co/insights/digital-product/minimum-viable-product-examples) show what each format proved and what it missed.

The sequence is not mandatory. If feasibility is already settled, skip the PoC. If the open question is demand or user experience, start with interviews or a prototype instead.

## When a Proof of Concept Is Worth Paying For

Every PoC should hang off a decision: build it this way, build it another way, or stop. If no decision is waiting on the result, the test has no job.

Say you are building scheduling software for a group of physiotherapy clinics, and the whole product depends on appointments syncing into an older practice-management system. Two weeks, one integration and a sample of real patient records answers that question. A full booking app with calendars and reminders would cost far more and still leave the same question open. The test earns its budget because the answer changes what gets funded next.

| Situation | Start with a PoC? | What the test checks |
| --- | --- | --- |
| Core feature depends on an unfamiliar API or data source | Yes | Whether the integration returns usable data at the volume you need |
| Product needs AI accuracy above a set bar | Yes | Accuracy on real inputs against a pass or fail target, plus cost per request |
| Legacy system must connect to a new front end | Yes | Data mapping, permissions and response time on the existing system |
| Users have not confirmed they want the product | No, start with interviews | Demand, which code cannot answer |
| Layout and user flow are undecided | No, build a prototype | Clicks and flows, not code |
| Team has built this kind of system many times | Usually no, go to a small MVP | Only genuinely new constraints |

Three questions filter it quickly. Is there one risky assumption that could sink the product? Can it be tested in about a month? Will the answer change what gets built next? Three yeses mean the test is worth running. If the assumption is about a model’s accuracy or data quality, our piece on [scoping an AI proof of concept](https://refact.co/insights/digital-product/ai-proof-of-concept) covers the extra checks AI work needs.

Often the hardest part is naming the assumption at all. When a consultant came to us wanting an AI assistant that would help project managers with “everything,” the first job was narrowing that idea down. Through our blueprint process on [building the Workform AI MVP](https://refact.co/work/workform), the scope shrank to one focused product: an assistant that understands projects by connecting data scattered across Slack, email, Asana and meetings. That reframing told the team which risk mattered most, which is the work [digital product discovery](https://refact.co/insights/digital-product/digital-product-discovery) exists to do before any code gets written.

## How to Scope a Proof of Concept That Can Actually Fail

A PoC that cannot fail cannot tell you anything. The setup decides whether the result means something, so do this part before anyone opens an editor.

**1\. Write the decision, then the riskiest assumption, as one sentence each.** “If the supplier API returns stock levels within two seconds at 500 requests a minute, we build on it. If not, we cache nightly.” That is testable. “The integration should be fine” is not. Teams often list five assumptions and test none of them properly.

**2\. Set the pass and fail thresholds first.** For example, 95% of test orders matched to the right product. Choosing the bar after you see the results is how a demo gets graded on a curve. If the PoC is meant to support a business case, tie it to a number someone already tracks, such as claim processing time or order cycle time.

**3\. Check that the environment can answer the question.** This step gets skipped most often. If the question is about failover, a single-server setup cannot answer it. If it is about latency under load, a five-minute run on a quiet staging account cannot answer it either.

**4\. Use representative data and conditions.** Production records have blanks, duplicates, odd encodings and inputs nobody planned for. Google’s Spanner PoC playbook is a useful benchmark for what “representative” means: realistic workloads and data, tests at typical load, at surge and at scale-down, latency measured in percentiles rather than averages, warm-up periods of 30 minutes or more, and benchmark runs of an hour or longer. Those numbers are database-specific, but the principle transfers. Small is fine. Unrepresentative is not.

**5\. Time-box it and cap the budget in writing.** Two to four weeks is a common range for a single technical question, though no reliable benchmark exists. A test with no end date eventually becomes a project. If an outside team runs the work, a [software development agreement template](https://cotowaddington.com/software-development-agreement-template/) helps you put scope, code ownership and stop conditions on paper before anyone starts.

**6\. Decide the code’s fate up front.** Delete, archive or promote. More on this below, because it is where the most expensive surprises come from.

**7\. Log the conditions, not just the outcome.** Record inputs, environment, workload, latency, error rate and output quality. An unrepeatable result is not evidence.

### What the close-out report contains

Keep it short. The question you tested. The threshold you set. The result you measured. What was not tested. The decision it triggers. That fourth line is the one most reports leave out, and it is the one the next team needs most.

## Untested Is Not Passed: What a PoC Environment Leaves Out

Practitioner advice on PoCs is consistent: skip authentication, logging and performance work unless they are the thing being tested. That is good advice for speed. It becomes a problem when the skipped parts get quietly counted as done.

Cloud vendors are explicit about this. Google Cloud’s setup guidance separates a basic PoC foundation from a production foundation that adds logging, monitoring and Security Command Center, with advanced production setups adding networking controls and key management. Google’s VMware Engine documentation notes that a single-node setup is fine for a PoC, but high availability and resource scheduling won’t work, and the default storage policy means a node failure can cause data loss. Microsoft’s Cloud Adoption Framework warns that preview services may lack uptime SLAs and should be kept to PoC scenarios.

The rule that follows is simple. Anything the PoC environment could not exercise is untested. It did not pass.

![Latency percentile graph showing tail latency a proof of concept software demo can miss](https://refact.wpengine.com/wp-content/uploads/2026/11/image_placeholder_3-7.avif)

While average and median response times remain deceptively flat near baseline, the 95th and 99th percentiles swing wildly past twenty seconds—revealing the severe slowdowns standard averages conceal. · Source: medium.com

### Three things demos hide

**Real-world conditions.** McDonald’s ran an AI drive-through test with IBM at more than 100 U.S. locations and ended it in 2024, after widely reported trouble with accents and background noise. A controlled demo never meets a car full of people ordering over an idling engine.

**Unit economics.** One developer on X described an AI app whose cost model looked fine on paper at $1 to $2.50 per user per month. Under live API billing, a single message cost about $0.17, and hidden reasoning tokens made up 75% to 95% of the bill. Cutting automatic features and switching to a cheaper model reduced costs roughly 23 times. It is one self-reported account, but the pattern is common: cost is invisible until real usage hits real billing.

**The wrong scorecard.** Klarna’s AI assistant handled 2.3 million conversations in its first month, about two-thirds of all chats. By May 2025, its CEO acknowledged that cost had been weighted too heavily and quality suffered, and the company guaranteed customers access to human support again. The AI still handles most inquiries. The lesson is about measurement: track resolution quality and repeat contacts, not just volume and speed.

Data quality is the fourth trap, and it gets worse with AI. A feature that answers twenty handpicked questions well can fall apart on real abbreviations and scanned PDFs, which is why [AI training datasets need fit](https://refact.co/insights/ai-automation/ai-training-datasets) more than volume.

## The Throwaway Code That Becomes the Product

The convention says PoC code gets thrown away. Practice says otherwise. “Almost every PoC that I’ve seen, where the concept and implementation was approved, it became the product,” one developer wrote on Reddit. On Hacker News, another described stakeholders who “saw it work and blissfully ignored the metric tons of tech debt.” A one-day PoC was still drawing support questions five years later, described as something that “does one thing very well and everything else badly.”

The pressure is easy to understand. The demo worked, a deadline is coming and other people have started building on top of it. Rewriting feels like going backwards.

Rewrites are not automatically safer, though. One team on Reddit discarded its PoC as planned, ran out of time on the rebuild and shipped half-finished code anyway. That leaves no universal right answer, and the research doesn’t pretend there is one. What separates the good outcomes from the bad ones is whether the team decided what kind of artifact it was building before it started.

Government guidance has said this for a long time. The [DOJ systems development lifecycle guide](https://www.justice.gov/archive/jmd/irm/lifecycle/ch13.htm) treats prototypes as lab-evaluated builds that don’t need every property of the final system and are kept only long enough to establish technical feasibility. Long enough, not indefinitely.

### Choosing between promote and rebuild

The deciding factor is whether the code can be understood. In the SPIRA project, an academic case study, engineers had to read a tightly coupled machine-learning PoC line by line just to work out what it was meant to do. The system went from what the authors called a “Big Ball of Mud” to a modular monolith and then to microservices, and testability was hard to recover after the fact.

If the PoC might continue, bring in someone who will own production early, and treat testability as part of the PoC rather than polish. If it gets promoted, invest in tests, documentation and structure once the value is proven. One practitioner’s rule for prototypes that start gaining users: add tests, a README, contribution rules and a named maintainer. Our guide to [MVP architecture decisions](https://refact.co/insights/digital-product/mvp-architecture-founders-guide) covers which choices are hard to undo once real users arrive.

### AI coding tools make this sharper

AI coding agents can now produce a functional prototype in minutes, and practitioners on X are openly enthusiastic about using them as living specs that stakeholders can click through. The same discussions keep landing on one caveat: these tools prove possibility, not scalability, security or maintainability. When nobody on the team can read the generated code, the gap between “it runs” and “we can run it” gets wider, not narrower. One widely shared AI-built editor went viral and then became unstable under load. A cheap demo makes the decision about what to keep more important.

## Why So Many Proofs of Concept Stall Before Production

You will see PoC failure rates quoted anywhere from 30% to 95%. Most of that spread comes from what each study measured, and nearly all the figures come from AI projects rather than software in general. No reliable failure rate exists for software PoCs as a whole.

The measures closest to “entered production” cluster around half:

-   **Gartner (2024):** 48% of AI projects reached production, after about eight months on average.
-   **S&P Global (2025, 1,006 respondents):** organizations scrapped an average of 46% of AI PoCs before production.
-   **U.S. Department of Defense:** 450 prototype awards between fiscal 2016 and 2023, with 51% of completed prototypes transitioning to production, according to GAO figures cited in [Augustova’s analysis of stalled AI pilots](https://www.augustova.co.uk/guides/why-ai-pilots-never-reach-production).

Stricter endpoints produce much lower numbers. IDC and Lenovo found that for every 33 AI PoCs, four reached wide-scale deployment. A 2025 IDC survey found organizations moved only about 34% of generative AI projects from pilot to production in the prior 12 months, according to [IDC’s pilot-to-production paper](https://www.tatacommunications.com/hubfs/library/cloud/documents/from-pilot-to-production-idc-sovereign-ai-cloud-spotlight-paper.pdf). An [IDC white paper on enterprise GenAI](https://www.supermicro.com/thought-leadership/IDC-White-Paper-Enterprise-GenAI-PoC-to-Production.pdf) tracked roughly 10 to 20 PoCs per organization run in 2024 and found that by early 2025 about half were in production, a quarter had failed and a quarter were still stuck in testing.

That last group is the costly one. A PoC that runs for months without a decision burns staff time and produces no answer at all.

### Production is not value

Reaching production is not the finish line either. McKinsey’s 2025 State of AI survey found 88% of organizations use AI somewhere, but only 39% report any effect on enterprise-level profit. MIT’s NANDA study put “successful implementation” of task-specific generative AI tools at 5%, though its authors call the findings preliminary, and the “95% of AI projects fail” headline built on it is misleading shorthand. These studies measure different stages. Read each one for what it measured, and don’t take any of them as a forecast for your project.

### A clear “no” is a result

Abandonment statistics count every stopped PoC as a failure. Some of them were the PoC doing its job. A 2025 case study in the _Journal of Systems and Software_ described a PoC that assessed moving a system to public cloud. After optimization, the projected cost was still 50% higher than the existing private cloud, and the first estimate had been 300% higher. That PoC saved the organization from a bad migration. A test that fails on schedule costs you three weeks instead of six months.

## What a Passing Proof of Concept Should Hand Over

A passing PoC creates obligations. Two interview studies of machine-learning engineers, one from 2024 and one from 2026, describe what the 2026 authors call “oversight debt.” The checks someone did by hand in a notebook during the PoC have to become automated pipelines, tests, validation sets and monitoring. That work goes beyond polish. It replaces a person with a system.

The useful question to ask of any passing PoC: what is this relying on a person to notice, remember or fix? Each answer becomes a line in the production plan. Before you approve the next phase, check that the plan covers:

-   **A maintainable architecture** rather than a demo script, or a written decision to rebuild.
-   **Logging and monitoring**, so problems show up before customers report them.
-   **Security, privacy controls and documentation** for everything the PoC skipped.
-   **Cost under real usage**, measured with actual billing rather than a spreadsheet.
-   **A named owner** for the code, the infrastructure and support after launch.
-   **The people who can block launch**, such as IT and security, consulted before the build rather than at the end.

That last point is easy to underrate. One developer described spending three weeks on a polished prototype that an IT team rejected in a single meeting, after three questions he couldn’t answer. Headlines about fast PoC-to-production timelines usually leave out the same thing. Walmart’s 63-day “vision to viable” assistant and Dentsu’s copilot built in under 12 weeks both ran on technology foundations that already existed, and Dentsu was still adding response evaluations after launch. Speed borrowed from existing infrastructure doesn’t transfer to a team without it.

What happens after handover is its own discipline, and our overview of [SaaS product lifecycle stages](https://refact.co/insights/digital-product/saas-product-lifecycle-management) maps what follows launch.

A proof of concept is worth exactly as much as the question it was built to answer and the honesty of its report. Ask something sharp, test it under conditions that can actually answer it, and write down everything it left unproven. If you have a demo that impressed the room and a build decision nobody has made yet, that gap is what our [product design and discovery work](https://refact.co/services/product-design) is built to close: naming the riskiest assumption, scoping the smallest test that settles it, and planning what production will need before the code decides for you.

## FAQ

### What is proof of concept software?

Proof of concept software is a small, time-boxed build that tests whether one specific technical approach can work before a team commits to the full product. It answers a feasibility question under defined conditions, with pass and fail criteria set in advance. It does not prove demand, usability or production readiness.

### How long should a software proof of concept take?

There is no reliable industry benchmark, but a single technical question can usually be tested in two to four weeks. If the scope can't fit in about a month, it is probably testing several assumptions at once and should be split. Set the end date and budget cap in writing before work begins.

### Can proof of concept code go to production?

Sometimes, but it should be a deliberate decision rather than the default. PoC code often skips tests, monitoring, security and clear structure, so promoting it means investing in those properties once the value is proven. Decide up front whether the code will be deleted, archived or promoted.

### What is the difference between a proof of concept and an MVP?

A proof of concept tests whether something can be built. An MVP tests whether real customers will use it and pay for it. A PoC is usually seen only by the team and decision-makers, while an MVP goes to real users and runs long enough to measure behavior such as retention.

### What percentage of proofs of concept fail?

No reliable figure exists for software PoCs in general. For AI projects, surveys from Gartner and S&P Global put production entry at roughly half, while stricter measures such as wide-scale deployment or sustained business impact show much lower rates. Some stopped PoCs are successes, because a clear no saves a costly build.

### Does a proof of concept need authentication, logging or security?

Only if those are part of the question being tested. Leaving them out keeps the PoC fast, but anything excluded must be documented as untested. The production plan then has to account for every safeguard the PoC skipped.
