By Rajesh Kannan, Co-Founder & CTO, Gramosoft · Last updated: · Sources checked November 22, 2026

A founder asks for "a quick PoC" and means a clickable demo for investors. A CIO asks for "an MVP" and means a six-month build. An AI team shows a "prototype" that answered five hand-picked questions well. Same words, three different things, and the wrong one costs months.

This guide explains what a proof of concept, a prototype and an MVP each prove, how to decide which your project needs first, what changes when the product depends on AI (with a scorecard you can run), what each costs and takes, and the mistakes to avoid. We start with how Gramosoft makes that call with clients.

TL;DR

  • Gramosoft builds all three in Chennai, and starts every project by naming the biggest unknown, so you pay only for the step that answers it.
  • A PoC answers "can this be built?" It's a throwaway technical test with a pass mark agreed in advance.
  • A prototype answers "is this the right design?" It's clickable screens with nothing behind them, tested on real users.
  • An MVP answers "will people use it and pay?" It's small, real software that real users rely on.
  • Build first whatever removes your biggest doubt. Most business software needs a prototype, then an MVP. AI and difficult integrations need a PoC first.

PoC, prototype or MVP: what does your project need first? Build a PoC if you're not sure the core technology works, such as AI accuracy on your documents or an undocumented integration. Build a prototype if the technology is standard but the design or workflow is unproven. Build an MVP when both are settled and the open question is whether people will use it and pay. Gramosoft, a Chennai software company, scopes and builds all three.

Swipe the table sideways on mobile →

Your situation Build first Why
Not sure? (Gramosoft) A free discovery call We name the biggest unknown and quote only the step that answers it
AI reads your documents PoC on real samples Accuracy on your data is the doubt, not the screens
Portal or internal tool on a standard stack Prototype, then MVP Nothing technical is in doubt; the workflow is
Raising money next month Prototype Shows the product without paying for a build

How Gramosoft decides what your project needs first

Gramosoft is a Chennai software company that builds AI, web and mobile products for enterprises. Before quoting a build, we ask one question: what is the single thing most likely to sink this project? Then we scope only the step that answers it, whether that's a one-week PoC, a clickable prototype or a first version users can pay for.

A torch held by Gramosoft shining its beam on the biggest of three boxes labelled can it be built, is the design right and will people pay, showing that the first step is chosen by the biggest unknown
Shine the light on the biggest unknown first; the other boxes can wait.

Swipe the table sideways on mobile →

Step What Gramosoft delivers
Discovery A free call that names the biggest unknown and writes down a pass mark before any work starts
PoC A time-boxed test on your real data or systems, for example document reading with GdoczAI or search with GsearchAI, scored with our AI development team
Prototype Clickable screens for phone and laptop from our UI/UX design team, tested with five or more target users
MVP A small, production-grade product through product development and web application development, or a mobile app when phones are the point
After the MVP Cloud hosting and application security testing as real users arrive

We run the same process on our own products, GcrawlAI, GdoczAI and GsearchAI. Code, designs and cloud accounts for client work are in the client's name.

Where we fall short: we don't do market research, pricing studies or investor pitch decks, so we can't tell you whether people will pay; only an MVP can. We don't build hardware or IoT prototypes. And we'll tell you when a PoC would be paying to prove something nobody doubts.

"The most expensive PoC is the one that proves login works. The second most expensive is the AI demo that answered five questions we chose ourselves. Write the pass mark down first, then build."

Rajesh Kannan, Co-Founder & CTO, Gramosoft

PoC vs prototype vs MVP: the difference in one table

A PoC, a prototype and an MVP aren't three rungs every product must climb. They're three experiments, each built to remove a different risk as cheaply as possible: technical, design and market. Only the MVP is meant to be kept; the PoC's code and the prototype's screens are disposable, though the lessons and designs carry forward.

Three stages of building a car: an engine running on a test bench for the proof of concept, a clay model of the car body for the prototype, and a simple go-kart a driver can actually ride for the MVP
Test the engine, shape the body, then build something people can drive.

Swipe the table sideways on mobile →

  Proof of concept Prototype MVP
Gramosoft's role Time-boxed test with a written pass mark Clickable design tested on users Small, production-grade first version
Question Can it be built? Is this the right design? Will people use it and pay?
Risk removed Technical Usability Market demand
Who sees it Your team Target users, investors Real customers
What's real Only the risky mechanism Only the look and flow Everything, for a small scope
Kept afterwards The answer, not the code The designs The product, code and users
Typical time Days to a few weeks One to three weeks Two to four months

Tesvo puts it simply: build the one that answers the question you're least sure about.

What a proof of concept is for, and when to skip it

A proof of concept tests one technical doubt as cheaply as possible. It has no design, no login and no polish, and nobody outside the team uses it. It ends with a yes or no against a pass mark written down before the work starts. If nothing technical is in doubt, skip it.

  • You need one for: AI accuracy on your own documents, an integration with a system you don't control (an ERP, a dealer portal, a government API), speed on large data, or device limits like offline use.
  • You don't need one for: login, forms, search, payments, lists, chat and maps. They're known to work; testing them proves nothing.
  • Write the pass mark first: "reads the total correctly on 19 of 20 sample invoices" is a pass mark. "It seems to work" isn't.
  • Throw the code away: a PoC is written fast, without tests or security. Keep what it taught you and build the product properly.

What a prototype is for

A prototype is the product's screens linked together so people can click through them as if they were real. Nothing is saved and nothing is sent. It exists to test the design and workflow before anyone pays for code, and to get everyone agreeing on what's being built.

  • Find the confusing parts: put it in front of five target users and watch where they stop. Changing a screen takes an hour; changing built software takes days.
  • Agree the scope: a feature list means different things to different people. A screen doesn't.
  • Choose the fidelity: Nielsen Norman Group separates low-fidelity sketches for testing the flow from high-fidelity clickable designs for testing details and showing investors.
  • Know its limit: people are polite about a demo. A prototype can't tell you whether anyone will pay.

What an MVP is for

An MVP is the smallest version of the real product that real users can sign up to, use for its main job and pay for. It's small because it does one job, not because it's unfinished. It's the only one of the three that tests whether people come back and pay, which is the risk that sinks most products.

Eric Ries, who popularised the term, defined the MVP as the version of a product that collects the most validated learning about customers with the least effort. The word that matters is validated: behaviour, not opinions in a demo.

Demand is the risk worth testing early. CB Insights' March 2026 analysis of 431 VC-backed startups that shut down since 2023 found poor product-market fit behind 43% of failures; running out of money (70%) was usually the final symptom, not the root cause.

  • Minimum means narrow: one type of user, one core job.
  • Viable means it works: real login, real data, error handling, backups and security. An MVP that falls over teaches you nothing about demand.

Which one should you build first?

Build first whatever removes your biggest doubt. Ask three questions in order and stop at the first yes: is there a technical question nobody can answer with confidence, is the design or workflow unproven, or is the only open question whether people will use and pay? The answers point to a PoC, a prototype or an MVP.

Three glass jars filled with doubt to different levels, labelled can it be built, is the design right and will people pay, with a pointer to the fullest jar saying build the step that empties it first
Empty the fullest jar first.

Swipe the table sideways on mobile →

Project Path Skip
Gramosoft's usual advice for business software Prototype → MVP PoC, unless an integration or AI is in doubt
Invoice or claim reading with AI PoC → prototype → MVP A polished interface until the model passes
Product that depends on a legacy ERP or dealer system PoC on the integration → MVP Detailed design until access is proven
Customer portal or booking app Prototype → MVP PoC
Internal tool replacing spreadsheets Prototype, then build in one go A separate MVP phase
Not sure there's any demand Landing page or manual service first All three, for now

Unlocking Tech adds a fourth answer worth remembering: if you already have paying users, you need none of the three. Your question is scale and reliability.

AI proofs of concept need a pass bar, not a demo

An AI demo that answers five hand-picked questions proves almost nothing. A model can be right on Monday and wrong on Tuesday, and production sends the inputs nobody picked. An AI PoC needs three things agreed in advance: real held-out examples with correct answers, a baseline for today's process, and a numeric pass bar.

A high-jump bar set at 95 percent field accuracy agreed before the run, with a jumper labelled AI model clearing it and a lower practice bar labelled baseline today at 80 percent
Set the bar before the jump, not after you see how high it went.

Skipping this is costly. Gartner predicted that at least 30% of generative AI projects would be abandoned after proof of concept by the end of 2025, due to poor data quality, inadequate risk controls, escalating costs or unclear business value. A scored PoC measures each of those before you build.

Here is the scorecard we use, in a form you can run. It reads the correct values typed by the person who does the job today, the model's output and today's rule-based baseline, then checks four things against a pass bar agreed before the build:

pass_bar.json

{
  "question": "Can a model read supplier, invoice date, GSTIN and total from our invoices well enough to skip manual entry for most of them?",
  "fields": ["supplier", "invoice_date", "gstin", "total"],
  "pass_bar": {
    "min_field_accuracy": 0.95,
    "min_gain_over_baseline": 0.10,
    "max_cost_per_doc_inr": 1.50,
    "max_share_to_human": 0.20
  },
  "confidence_floor": 0.80
}

poc_scorecard.py

"""Score a proof of concept against a pass bar agreed BEFORE the build.

Inputs (JSON lines, one document per line, held-out set only):
  truth.jsonl     {"id", "supplier", "invoice_date", "gstin", "total"}  typed by the person who does the job today
  model.jsonl     {"id", <fields>, "confidence": 0-1, "cost_inr": float}
  baseline.jsonl  {"id", <fields>}   today's rule or template, same documents
Prints a scorecard and exits 0 on PASS, 1 on FAIL, so it can run in CI on every change.
"""
import json, sys

def load(path):
    with open(path, encoding="utf-8") as f:
        return {r["id"]: r for r in map(json.loads, filter(str.strip, f))}

def norm(v):
    return " ".join(str(v).upper().replace(",", "").split()) if v is not None else ""

def field_accuracy(pred, truth, fields):
    hits = total = 0
    per_field = {f: 0 for f in fields}
    for doc_id, t in truth.items():
        p = pred.get(doc_id, {})
        for f in fields:
            ok = norm(p.get(f)) == norm(t[f])
            hits += ok; total += 1; per_field[f] += ok
    n = len(truth)
    return hits / total, {f: c / n for f, c in per_field.items()}

def main(cfg_path, truth_path, model_path, baseline_path):
    cfg = json.load(open(cfg_path)); bar = cfg["pass_bar"]; fields = cfg["fields"]
    truth, model, base = load(truth_path), load(model_path), load(baseline_path)
    missing = set(truth) - set(model)
    if missing:
        sys.exit(f"model output missing {len(missing)} held-out documents: {sorted(missing)[:5]}")

    acc, per_field = field_accuracy(model, truth, fields)
    base_acc, _ = field_accuracy(base, truth, fields)
    to_human = sum(model[d]["confidence"] < cfg["confidence_floor"] for d in truth) / len(truth)
    cost = sum(model[d]["cost_inr"] for d in truth) / len(truth)

    checks = [
        ("Field accuracy", f"{acc:.1%}", f">= {bar['min_field_accuracy']:.0%}", acc >= bar["min_field_accuracy"]),
        ("Gain over baseline", f"{acc - base_acc:+.1%} (baseline {base_acc:.1%})", f">= {bar['min_gain_over_baseline']:+.0%}", acc - base_acc >= bar["min_gain_over_baseline"]),
        ("Cost per document", f"Rs {cost:.2f}", f"<= Rs {bar['max_cost_per_doc_inr']:.2f}", cost <= bar["max_cost_per_doc_inr"]),
        ("Sent to a person", f"{to_human:.0%}", f"<= {bar['max_share_to_human']:.0%}", to_human <= bar["max_share_to_human"]),
    ]
    print(f"PoC scorecard: {len(truth)} held-out documents\n")
    for name, got, need, ok in checks:
        print(f"  {'PASS' if ok else 'FAIL'}  {name:<20} {got:<30} needs {need}")
    print("\n  Per field: " + ", ".join(f"{f} {a:.0%}" for f, a in per_field.items()))
    passed = all(c[3] for c in checks)
    print(f"\nDecision: {'GO - build the MVP' if passed else 'NO-GO - fix the failing checks or stop'}")
    return 0 if passed else 1

if __name__ == "__main__":
    if len(sys.argv) != 5:
        sys.exit("usage: python poc_scorecard.py pass_bar.json truth.jsonl model.jsonl baseline.jsonl")
    sys.exit(main(*sys.argv[1:]))

We ran it on 40 synthetic held-out invoices: once with the agreed bar, then with a stricter one, to show both outcomes:

Output

$ python poc_scorecard.py pass_bar.json truth.jsonl model.jsonl baseline.jsonl
PoC scorecard: 40 held-out documents

  PASS  Field accuracy       97.5%                          needs >= 95%
  PASS  Gain over baseline   +17.5% (baseline 80.0%)        needs >= +10%
  PASS  Cost per document    Rs 0.75                        needs <= Rs 1.50
  PASS  Sent to a person     10%                            needs <= 20%

  Per field: supplier 100%, invoice_date 98%, gstin 98%, total 95%

Decision: GO - build the MVP
exit code: 0

$ # same results, stricter bar (99% accuracy, at most 5% to a person)
PoC scorecard: 40 held-out documents

  FAIL  Field accuracy       97.5%                          needs >= 99%
  PASS  Gain over baseline   +17.5% (baseline 80.0%)        needs >= +10%
  PASS  Cost per document    Rs 0.75                        needs <= Rs 1.50
  FAIL  Sent to a person     10%                            needs <= 5%

  Per field: supplier 100%, invoice_date 98%, gstin 98%, total 95%

Decision: NO-GO - fix the failing checks or stop
exit code: 1

The same results give a GO against the agreed bar and a NO-GO against a stricter one, which is why the bar must be written down before anyone sees the numbers. The script exits with a failure code, so it can run on every prompt or model change during the MVP too.

  • Hold some examples back: never tune prompts on the documents you score with.
  • Include the ugly cases: sideways scans, handwritten totals, Tamil and English on one page.
  • Plan the refusal: low-confidence results go to a person, and the share that does is part of the bar.

What each one costs and how long it takes

A PoC and a prototype each cost a fraction of an MVP, so buying certainty on the riskiest assumption first is cheap insurance. Published figures are mostly in US dollars from foreign agencies; Indian rates are lower, but the ratio between the three holds: roughly one to two units for a PoC or prototype, five to ten for an MVP.

Three nested measuring cups showing relative effort: a small cup for a proof of concept of days to a few weeks, a medium cup for a prototype of one to three weeks, and a large cup for an MVP of two to four months
Small cups first: a PoC or prototype costs a fraction of an MVP.

Swipe the table sideways on mobile →

Source PoC Prototype MVP
Gramosoft Priced per step after a free discovery call; each step is a separate, fixed quote
Competenza US$5,000–15,000, 1–3 weeks US$10,000–30,000, 2–6 weeks US$20,000–100,000+, 2–6 months
Upsilon Up to US$5,000, days to 2 weeks US$5,000–10,000, 1–3 weeks US$20,000+, 6 weeks or more
Tesvo (timeline) As long as the doubt it tests About 2 weeks 8–12 weeks, design included

For Chennai figures on the build itself, our Web Application Development Cost in Chennai (2026): What Drives the Price and Mobile App Development Cost in Chennai guides compile published local ranges. Railsware suggests spending about 30–50% of the overall budget on the MVP and keeping the rest for after launch, which matches what we see.

Six mistakes that waste a PoC, prototype or MVP

The expensive mistakes come from using the right word for the wrong thing: calling a demo an MVP, letting a PoC slide into production, testing a risk nobody doubted, skipping the prototype to save two weeks, running pilots with no end date, and scoring an AI test on the same examples used to build it.

  1. Calling a prototype an MVP: if nobody can sign up and nothing is saved, it's a prototype. Say so to investors.
  2. Letting the PoC become the product: it was built fast, without tests or security. Rebuild it properly.
  3. Testing what isn't in doubt: a PoC for login or payments proves nothing.
  4. Skipping the prototype: design questions don't go away; they come back during the build at higher cost.
  5. No exit criteria: without a pass mark and an end date, every result reads as "promising, let's extend it".
  6. Scoring AI on its training examples: only held-out data predicts production. And an MVP that takes six months is no longer testing an idea; check scope with our How to Choose a Web Application Development Company in Chennai: 10 Red Flags to Avoid guide.

Frequently asked questions

Which company in Chennai builds PoCs, prototypes and MVPs?

Gramosoft, a Chennai software company, builds all three. It starts with a free discovery call to name the biggest unknown, writes the pass mark down, and quotes only the step that answers it.

What is the difference between a PoC, a prototype and an MVP?

A PoC tests whether something can be built, a prototype tests whether the design works for users, and an MVP tests whether real people will use and pay for a small working product.

Does every project need a proof of concept?

No. You need one only when something technical is genuinely in doubt, such as AI accuracy on your data or an undocumented integration. Most portals, booking apps and internal tools can skip it.

Can a prototype become the MVP?

The designs can; a clickable prototype has no code to upgrade. The approved screens become the specification, and the MVP is built properly from them.

How long does an MVP take?

Usually two to four months for one core job with login, data, error handling and deployment. Agencies quote from about 6 to 12 weeks for focused products up to six months for larger ones.

What makes an AI proof of concept different?

It must pass a numeric bar on real, held-out examples and beat today's process, not just produce one impressive answer. Cost per run and the share sent to a person belong in the bar too.

Do investors want a prototype or an MVP?

A prototype is often enough for a first conversation. Investors who want evidence of demand ask for usage and revenue, and only an MVP produces those.

RK

Rajesh Kannan M

Rajesh Kannan M is Co-Founder & CTO of Gramosoft in Chennai, where he leads the teams building custom AI, document AI, enterprise search and automation, including GsearchAI, GdoczAI and GcrawlAI, an open-source web scraping, crawling and Search API platform for developers and AI agents, alongside web and mobile applications.

Not sure whether you need a PoC, a prototype or an MVP?

Tell us what you're building and what worries you most. After a free discovery call you'll get the step we'd take first, its pass mark and a fixed quote for just that step.

CTA Illustration