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.
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.
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.
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.
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.
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.
- Calling a prototype an MVP: if nobody can sign up and nothing is saved, it's a prototype. Say so to investors.
- Letting the PoC become the product: it was built fast, without tests or security. Rebuild it properly.
- Testing what isn't in doubt: a PoC for login or payments proves nothing.
- Skipping the prototype: design questions don't go away; they come back during the build at higher cost.
- No exit criteria: without a pass mark and an end date, every result reads as "promising, let's extend it".
- 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.
Related guides
- Custom Software Development in Chennai: Cost, Process & How to Pick a Partner
- Web Application Development Cost in Chennai (2026): What Drives the Price
- Web App vs Mobile App: Which Should Your Business Build First?
- Fine-Tuning vs RAG vs Prompting: Which Should Your Business Use?
- AI Development Services in Chennai: 10 Practical Use Cases
- Mobile App Developers in Chennai: Freelancer vs Agency vs In-House
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.