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.

Parnia SebtiNovember 19, 2026
A terminal records one green feasibility pass above a much larger field of explicitly untested production concerns.

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, 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. 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
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 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.

BuildQuestion it answersWho sees itWhat it cannot tell you
Proof of conceptCan this technical approach work under realistic conditions?Engineers and the people making the build decisionWhether users want it or how it behaves at scale
PrototypeHow should the product look and flow?Designers, stakeholders, test usersWhether the underlying system can be built
MVPWill real customers use it and pay for it?Real end usersHow the full product performs at volume
PilotDoes it work in the real operation, with real staff?A limited group of live usersWhether results hold across every site or team

Asana’s breakdown of PoC, prototype and MVP 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, and the design side in MVP vs prototype.

Diagram comparing proof of concept software, prototype and MVP stages
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 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 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.

SituationStart with a PoC?What the test checks
Core feature depends on an unfamiliar API or data sourceYesWhether the integration returns usable data at the volume you need
Product needs AI accuracy above a set barYesAccuracy on real inputs against a pass or fail target, plus cost per request
Legacy system must connect to a new front endYesData mapping, permissions and response time on the existing system
Users have not confirmed they want the productNo, start with interviewsDemand, which code cannot answer
Layout and user flow are undecidedNo, build a prototypeClicks and flows, not code
Team has built this kind of system many timesUsually no, go to a small MVPOnly 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 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, 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 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 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
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 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 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 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.

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. An IDC white paper on enterprise GenAI 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 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 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.

Building a product and unsure what to scope first? Let’s talk. Free 30-minute call, no pitch.

Share
Written by
Parnia Sebti
Parnia Sebti

Parnia Sebti is a project and account manager at Refact, coordinating teams, clients, timelines, and delivery across the studio’s work. She helps keep projects organized from planning through execution, making sure communication stays clear and priorities stay aligned. Her role connects client needs with the internal team’s workflow, helping turn requirements, feedback, and moving parts into structured delivery. At Refact, Parnia also contributes to shaping the internal tools and processes the team uses to manage projects more effectively and keep work moving with clarity.

More from Parnia Sebti
Questions

Common questions.

What clients usually want to know before starting a project.

Still have a question? Ask us
Related Insights

More on Digital Product

See all Digital Product articles

User Research for Founders

Building a new product can feel like working with the lights off. You have an idea you care about, but one question keeps coming back: “Will anyone actually use this?” That is what user research for founders is for. It helps you replace guesses with real signals from the people you want to serve, so […]

Custom Client Portal: A Practical Build Guide

You will not hear most client portals fail. They are put out there, an announcement email is sent, and a handful of logins are tallied in the opening week. After that they go dormant, with support requests continuing to come in over the very channels the portal was meant to do away with. Gartner put […]

Media Data Insights That Drive Action

Media teams collect more data than ever, but media data insights only matter when they lead to better decisions. Pageviews, scroll depth, subscriptions, ad performance, and content engagement all tell part of the story. The hard part is turning that flood of numbers into clear actions your team can use. This is not about storing […]

Your next step

Let's build something that lasts.

Tell us what you are trying to build, improve, or migrate. We will help you identify the right next step and what it will take to move forward.