Why We Read the Support Inbox Before We Read the Spec
Specs describe what stakeholders assume users want. Support tickets show what users actually asked for, in their own words.
A spec tells you what someone in a meeting room decided the website or app should do. A support inbox tells you what customers are actually confused about, annoyed by, or asking for, in their own words. We read the inbox first because it's the closer of the two to reality, and reality is what we're building for.
This isn't a stylistic preference. It's a response to a pattern that shows up again and again in research on why software and web projects go wrong: the requirements themselves, and how little real user input shaped them, are the most consistently cited reason projects run late, over budget, or miss the mark.
The numbers on requirements failure don't agree with each other, but they agree on the culprit
If you go looking for a single, clean statistic on why IT and web projects fail, you won't find one. The estimates are all over the place. What's consistent is which category of failure keeps coming up on top.
The Standish Group's CHAOS Report data, summarized across 2010–2015, breaks "challenged" projects (late, over budget, or short on features) down by cause: incomplete requirements and specifications account for about 12.3% of challenges, lack of user input for 12.8%, and changing requirements for another 11.8% source. Add those up and requirements-related issues outweigh almost any other single cause. A separate summary of the same underlying Standish data puts it more bluntly: lack of stakeholder or user involvement contributes to roughly 30% of project failures source.
Older industry surveys go further still. A compiled review of failure research cites an Avanade study finding 66% of failures traced back to system specification problems and 51% to poor requirement understanding, a Meta Group estimate that 60–80% of failures stem from poor requirements gathering and management, and Forrester Research linking poorly defined applications to a 66% project failure rate, costing US businesses at least $30 billion a year source. A UK software delivery firm's own review states that poor requirements gathering is responsible for over 39% of failure cases, and communication breakdowns are cited in 57% of failures source.
Here's the honest caveat: these numbers don't reconcile. One aggregator citing the CHAOS Report says only about 2.5% of projects are "fully successful" source, while other summaries of the same report line put full success closer to 29–35% depending on the year source. Failure-cause percentages vary the same way — one PMI-attributed figure claims 42% of failures trace to poor requirements management, while others cite 39%, 66%, or 68% for similar categories source. We're not going to pretend there's a tidy consensus number. But across every source we reviewed, requirements and user-involvement failures show up as the largest identifiable cause of project trouble, more consistently than budget overruns, technology choice, or team skill. That's the pattern worth acting on, even if the exact percentage isn't.
Why a spec alone can't fix this
A spec is written by people who are, almost by definition, not the ones dealing with the product day to day. A founder, a marketing head, an operations manager — all reasonable people, all making informed guesses about what customers need. But guesses is what they are, filtered through internal priorities, competitor benchmarking, and whatever the loudest voice in the planning meeting believed last quarter.
The support inbox skips that filter. It's customers, in their own words, telling you what they tried to do and where it broke down.
UX research literature backs this up directly. A widely used UX methods guide notes that during the early "empathize" phase of design work, teams are expected to conduct internal research — meetings with sales, marketing, and support — specifically to pull insight from other teams before designing anything source. The same source points out that support data isn't just an input at the start — it's also how you check your work afterward: researchers use support ticket volume to determine whether a design change actually reduced the tickets it was meant to fix source.
Wikipedia's overview of user research states plainly that software projects typically start doing user research at the requirement-gathering stage, precisely so users are involved from the beginning rather than consulted after the fact source. That's the theory. In practice, a support inbox is one of the cheapest ways to do that research, because the users have already done the work of telling you what's wrong. Nobody has to be recruited, scheduled, or incentivized. They already wrote it down.
Help Scout, which builds support software for a living, describes this signal in a way we think is exactly right: support inboxes contain a continual stream of customers volunteering what they care about — about the product, the industry, competitors — but that signal is "camouflaged by the mundane mass of requests for password resets and schedule changes" source. Most of an inbox is noise. But the signal that's in there is unusually honest, because nobody writes an angry or confused support message to be polite about the product.
A UserVoice-commissioned survey of 200 product professionals found that feedback from customer-facing teams like sales and support is highly influential when product teams decide what to prioritize on their roadmap source. That's an internal admission from the product world: the people closest to customer complaints already shape what gets built, whether or not that influence is written into any formal process.
What we actually look for in an inbox before we read a spec
When a client hands us a brief for a new site or app, we ask for access to whatever they've got — support tickets, WhatsApp chat logs, call notes, marketplace reviews, whatever exists. Here's the checklist we run through:
| What we look for | Why it matters |
|---|---|
| Repeated questions about the same feature or page | Signals the current site/app fails to answer something obvious |
| Complaints that use the customer's own vocabulary | The spec's language often doesn't match how real users describe the problem |
| Tickets about things the spec doesn't mention at all | Gaps between what leadership thinks matters and what customers actually hit |
| Volume spikes tied to specific events (a sale, a feature launch) | Shows which changes generate confusion versus which land cleanly |
| Channel mismatch — where complaints actually arrive versus where the business expects them | Tells us where to prioritize fixing friction first |
That last point matters a lot for Indian businesses specifically, and it's often missed.
Why this matters more, not less, for Indian MSMEs
A PayNearby MSME Digital Index survey of over 10,000 Indian MSMEs found that 68% acknowledged real growth and benefit from adopting digital technology, and more than 65% use some form of digital tool for daily operations source. The same survey found that business owners aged 18–30 were the most digitally adept group, with 75% falling into that category and over 87% of them using smartphones for daily business operations source.
That's a young, mobile-first customer and owner base. Their version of a "support inbox" is often not a contact form on a website. It's WhatsApp messages, Instagram DMs, phone calls logged nowhere formal, or comments left on a marketplace listing.
ICRIER's research on Indian MSMEs during COVID-19 found that digital and e-commerce channels became the mainstream sales route for many small businesses, but that a majority of that online selling happened through third-party marketplaces rather than the business's own website or app source. That has a direct consequence for anyone writing a spec for a new site: the business's most honest, high-volume source of customer feedback may not live in an inbox tied to the domain at all. It might be sitting in a Meesho or Amazon reviews section, or scattered across a WhatsApp Business number, and nobody has pulled it together before the spec was written.
We check all of those, not just a formal contact-form export, before we take a spec at face value. If the spec says "add a live chat widget" but every actual complaint on the marketplace listing is about delivery timelines, live chat is not the priority, no matter how confidently it's written into the brief.
Where this method has limits
To be clear about what this is and isn't: there's no official standards body — not MeitY, not W3C, not Google's web.dev guidance — that prescribes reading support tickets before a spec as a formal methodology. This is an industry and UX-practice argument, built on research about why requirements fail and how support-facing teams already shape product decisions in practice, not a compliance requirement or a government-mandated process. We're recommending it because the evidence on requirements failure is strong and repeated across many independent sources, not because it's a checkbox anyone is required to tick.
It also doesn't replace a spec. A support inbox tells you what's broken. It rarely tells you what to build next, how to prioritize competing fixes, or what the business's actual constraints are — budget, timeline, compliance, brand. The spec still has to answer those. What changes is the order of operations: we read what customers already said before we accept what the brief assumes they want.
A short checklist before your next spec gets written
- Pull every available support channel: contact form, WhatsApp, marketplace reviews, call logs — not just the one tied to the current website.
- Read at least 100 recent tickets or messages before writing a single requirement, looking for repeated phrases, not just repeated topics.
- Cross-check the spec against that reading: for every proposed feature, ask whether a real complaint or request supports it.
- Flag anything in the spec that has zero supporting evidence in the inbox — it's not automatically wrong, but it needs a real justification beyond "we assumed this."
- After launch, watch ticket volume on the specific issue the change was meant to fix, the same way UX teams use support data to check whether a design change actually worked source.
Questions people also ask
Isn't reading support tickets just anecdotal, compared to a proper spec?
It's anecdotal in the sense that any single ticket is one customer's experience. But in volume, it's closer to primary user research than most specs are, since specs are usually built from internal assumptions rather than direct customer language. The research on requirements failure suggests the bigger anecdotal risk is a spec built without any user input at all source.
What if our business doesn't have a formal support inbox yet?
Most small and growing Indian businesses don't route everything through one channel. Check WhatsApp Business chats, marketplace review sections, and call logs — research on Indian MSMEs shows a majority of online sales for many businesses run through third-party platforms rather than an owned website, so that's often where the real customer voice already lives source.
How much support history should we look at before writing a spec?
There's no fixed number in the research, but the principle from UX practice is to treat it as an early-stage research input, done before requirements are finalized, not after source. In practice, a few months of recent tickets or messages, read closely rather than skimmed, is usually enough to surface the repeated patterns that matter.