What We Look for in a Client Before We Look at the Project
Before scoping any website or app, we check whether a client can explain their goals, commit to a decision-maker, and put scope in writing.
Before we talk wireframes, budgets or tech stacks, we look at whether the client can answer a few basic questions clearly, whether one person can actually approve decisions, and whether they're willing to put scope in writing. This isn't a formality. The data on why web and software projects fail points overwhelmingly at the client relationship, not the code.
Why we screen clients before we scope projects
Most studios treat the discovery call as a chance to sell. We treat it as a chance to find out whether the project can succeed at all, because the evidence says the technical part is rarely what breaks a project.
An analysis of the Standish Group's CHAOS data found that clear, stable requirements reduce failure risk by 37%, and getting requirements right is called the single most impactful thing a team can do. The same analysis found that user involvement is consistently cited as the top success factor across 30 years of CHAOS reports, with executive support second. It also found that teams with high "decision latency" — slow to decide — achieve only 18% project success rates versus 63% for teams that decide quickly.
Read those together and the pattern is obvious. A project doesn't fail because a developer picked the wrong framework. It fails because nobody could say what "done" looked like, or because the one person who could approve a decision was never in the room, or because approvals took three weeks every time.
The numbers on how often this actually goes wrong
Different research bodies measure "failure" differently, so the headline percentages vary, but they all point the same direction.
| Source | Success | Challenged / over budget | Failed / cancelled |
|---|---|---|---|
| CHAOS Report, 2015 edition (as summarized) | 29% | 52% | 19% source |
| CHAOS Report, 2020 edition (as summarized) | 35% | 45% | 20% source |
| PMI Global Project Management Survey, 2017 | 15% delivered as planned | 43% exceed budget, 49% exceed timeframe | 14% cancelled without results source |
| Standish data (alternate framing) | 16.2% complete success | 52.7% "challenged" | 31.1% pure failure source |
None of these numbers are directly comparable, because "success," "challenged" and "cancelled" mean different things in each study. But every single one puts the share of projects that go smoothly at well under half. Separately, IT projects exceed budgets by an average of 45% and schedules by 7 months, and 17% of large IT projects end so badly they threaten the existence of the organization. That's the downside we're trying to screen out before we ever open a project plan.
What actually causes the failures
Across multiple studies, the root cause keeps tracing back to the same place: requirements and communication, not technology.
- Poor requirements gathering is responsible for over 39% of failure cases, and communication breakdowns are cited in 57% of failures
- 12.3% of projects are challenged due to incomplete requirements, 12.8% due to lack of user involvement, and roughly 30% of failures trace to lack of stakeholder involvement
- Less than 20% of business executives describe their own requirements-gathering process as a clear articulation of business needs, and 49% of projects experience scope creep because scope was never clearly defined and controlled
A consulting-firm survey put it bluntly: many of its own experts named the client's own lack of understanding of the software process as one of the primary reasons a project fails, since clients who don't know how development works often ask for delivery "ASAP, at the lowest price point and highest quality". That combination — rushed timeline, lowest price, highest quality — is not a brief. It's a warning sign.
The specific signals we check for
These aren't abstract. They're things that show up in the first call or the first discovery form, and they're consistent across agency and freelancer vetting checklists.
Vague answers to "what does success look like." A client who cannot clearly explain what they want will never be satisfied with what is delivered, and answers like "I'll know it when I see it" are a warning sign. If a client can't describe the outcome, no amount of design polish will feel like the right outcome to them.
Refusal to put scope in writing. A client who says "we don't need a contract, let's just shake on it" removes every form of protection an agency has, including agreed scope, payment terms, and legal recourse. We treat this as a hard stop, not a negotiation point.
Pressure to skip process steps. Clients pressing for rushed turnarounds for no valid reason, or trying to bypass reasonable process stages, are a first-tier red flag. Discovery, wireframes and review cycles exist because skipping them is where the 49% scope-creep number above comes from.
Scope inflation during the first conversation. A client agreeing to a logo project who then mentions "also a website, business cards, and maybe some social media graphics" during the same call guarantees scope creep once work begins. If the ask keeps growing before a contract is even signed, it will keep growing after.
Low-effort discovery responses. A discovery form with one-word answers, skipped questions, or half-baked responses signals the client hasn't thought things through and will need heavy hand-holding later. We read this less as laziness and more as a preview of how reviews and feedback will go for the next three months.
Dictating budget instead of discussing it. A client who states a number and refuses to discuss scope-to-budget fit is showing the same power-imbalance pattern flagged in freelance-client vetting research — treating the studio as staff rather than a vendor with its own constraints.
The India context: readiness varies a lot more than clients assume
For a Pune studio, this matters differently than it would for a US agency, because a large share of prospective clients are MSMEs at very different points on the digital-maturity curve. India's MSME sector has over 6.3 crore enterprises, contributes roughly 30% of GDP, and employs about 11 crore people, with Udyam registrations surpassing 4.5 crore by June 2024. That's a huge and varied pool.
But digital maturity across that pool is uneven. A national survey found the Digital Maturity Index rose from 56.6 in 2023 to 57.3 in 2024, and reached 58.0 in 2025, with South India leading regionally at 62.9 versus 55.8 in the North. Despite that improvement, only 12% of MSMEs have reached full digital maturity.
Adoption is real but shallow. A PayNearby-led survey of over 10,000 MSMEs found 68% acknowledged growth and beneficial impact on their business and personal lives after adopting digital technology, and over 65% use some form of digital technology for daily operations. But the back office often hasn't caught up: only 29% use accounting software and 17% use POS software. That's a practical detail we probe for before scoping any integration — a client who wants a website that "connects to inventory" may still be running that inventory on a notebook.
The broader picture cuts both ways. India processed over 185.87 billion real-time digital payment transactions in FY2024-25, the highest volume globally, with UPI powering 85% of the country's digital payments — so payments infrastructure is rarely the blocker. But the same report notes the Economic Survey 2024-25 estimates 55-60% of registered MSMEs have moved online in some form, which means close to half of registered small businesses we might talk to are not meaningfully online yet. For those clients, the conversation isn't "refine your website." It's "get the basics live first," and we say that upfront rather than scoping a project the client isn't ready to use.
What this checklist looks like in practice
Before we discuss the project itself, we're trying to get clear answers on:
- Who decides. One name, one person who can approve a homepage draft or a feature cut without a committee re-review.
- What success looks like, in their words. Not "a modern website" — a specific outcome, like leads per month, orders per week, or fewer support calls.
- Whether they'll sign something. A scope document, even a short one, before work starts.
- How they answer the discovery questions. Thoughtful and specific, or rushed and vague.
- What "urgent" actually means to them. A real business reason, or a preference for skipping steps.
- Where their operations actually stand today. Manual registers and WhatsApp orders is a different starting point than an existing POS system, and it changes what the project should even include.
None of this is about turning clients away. It's about scoping projects that match where a business actually is, with someone who can make decisions and is willing to say what those decisions are. The failure statistics above aren't about bad developers. They're about projects that were set up to disagree with themselves from the start.
Questions people also ask
Isn't client vetting just a way for agencies to reject inconvenient work?
No — it's a way to scope work correctly. The research on project failure consistently points to requirements clarity and stakeholder involvement, not technical difficulty, as the deciding factor in outcomes, per the CHAOS-based analysis. Skipping vetting doesn't avoid conflict — it defers it to the middle of the project, which is more expensive for everyone.
What if a client can't answer "what does success look like" right away?
That's common and not disqualifying by itself. The problem is a client who can't get there even after a structured discovery conversation. Vague, unfalsifiable answers like "I'll know it when I see it" are the signal to watch for, not initial uncertainty.
Why does a written scope document matter so much for smaller projects?
Because scope creep doesn't require a large project to happen. Nearly half of projects surveyed experienced scope creep specifically because scope was never clearly defined and controlled. A short, specific scope document protects both sides regardless of budget size.