Discovery is supposed to reduce uncertainty before a build begins. In practice it often produces a long document, a polished slide deck and an estimate that everyone treats as a commitment. The project then starts with unresolved questions hidden inside confident language.
For a Bangladeshi SME, the cost of weak discovery rarely appears in the meeting. It surfaces later as rework, a missed launch, a scope dispute or a system that fails in the warehouse. The symptoms are visible early if someone knows what to look for.
What discovery has to produce
Before diagnosing the process, agree on its output. A useful discovery phase leaves the business with these decisions:
- The problem and the outcome: which process is failing and what will be observably different.
- The scope boundary: which teams, branches, channels and systems are included, and which are explicitly not.
- The real process: the normal path plus the exceptions that consume the most time.
- The data and integration map: where each input comes from, who owns it and what happens when it fails.
- The constraints: budget range, deadline drivers, hosting, language, connectivity and legal obligations.
- The options: at least two delivery approaches with trade-offs, not one predetermined answer.
- The acceptance model: how the business will know each requirement is complete.
A document that changes none of these decisions is record-keeping.
Six symptoms of a discovery that is not working
Symptom: the room is full of managers and empty of operators
What you see: every workshop is attended by department heads, but the person who processes orders, prepares payroll or handles admissions is never present.
What is happening: the project is being described from memory and hierarchy. Managers know the official flow; operators know the workarounds, the duplicate registers and the phone calls that keep the process alive.
What to do: observe one real case end to end with the operator. Ask for the last five exceptions, not a generic description. Keep the session short and specific.
How to prevent it: list required participants in the discovery plan and make the process owner sign off that they attended.
Symptom: the process map describes the official process
What you see: the map is clean, sequential and has no loops. Everyone nods in the meeting, then returns to a spreadsheet that is not on the map.
What is happening: the team documented what should happen rather than what does. No artefacts were collected, so the map could not be checked against reality.
What to do: trace one order, invoice, student file or support ticket using the actual documents, messages and system screens. Mark every place where the case leaves the system.
How to prevent it: adopt an evidence rule: every step needs an artefact, an observation or a named source. Steps with none are assumptions and should be labelled.
Symptom: requirements are written as solutions
What you see: the requirement list says "dashboard", "mobile app", "AI chatbot" or "ERP integration" without saying which decision or task it supports.
What is happening: a preferred product has become the requirement. Alternative approaches cannot be compared fairly.
What to do: rewrite each item as a problem statement with a user, a trigger, a decision and evidence of success. Keep solution options in a separate section with cost and risk.
How to prevent it: review requirements with a simple test: can two different solutions satisfy this statement? If not, it is a design choice, not a requirement.
Symptom: the estimate arrives before the scope is stable
What you see: a fixed price is requested in week one, based on a paragraph and a reference to a similar project.
What is happening: commercial pressure is being absorbed by the estimate. The number looks precise but rests on untested assumptions.
What to do: ask for a range with assumptions attached, then split discovery from build. Re-estimate after the scope baseline is agreed.
How to prevent it: use a two-stage contract: paid discovery with a defined output, followed by a build proposal that references the signed scope.
Symptom: discovery has no end date
What you see: workshops continue, the document grows, and the start date moves each month. New stakeholders keep adding concerns.
What is happening: there is no decision-maker, no timebox and no agreed definition of enough. Discovery has become a way to avoid choosing.
What to do: set a decision date, list the unresolved items, and assign each one an owner. Default to the smallest testable scope where a decision cannot be made.
How to prevent it: write exit criteria at the start: the decisions that must be made, the evidence required and the person who signs them off.
Symptom: the build team receives a document, not a decision
What you see: the handover is an email with a file attached. Two weeks later developers are asking why a rule exists and getting different answers.
What is happening: context was not transferred. The decision log is missing, the glossary is incomplete, and the requirements are not linked to tests.
What to do: run a handover walkthrough with the build lead, record it, and produce a glossary plus a decision log. Link each acceptance criterion to a test case.
How to prevent it: define what "ready to build" means and refuse to start until the pack meets it.
Diagnosing a stalled discovery
- Read the decision log. If there is none, that is the first finding.
- Trace one real case through the documented process and note every departure.
- Compare the participant list with the people who actually do the work.
- Test five requirements against the "two solutions can satisfy this" rule.
- Check whether the estimate lists its assumptions and exclusions.
- Ask the build lead to explain three key rules from memory.
Fixes you can apply in two weeks
- Replace the full-day workshop with two 90-minute sessions around real cases.
- Add an exceptions log with frequency, cost and current workaround.
- Attach a named owner and a review date to every open question.
- Convert the top ten requirements into testable acceptance scenarios.
- Agree a stop date and publish what will be decided by then.
Measures that tell you discovery worked
Track the share of requirements backed by evidence, the age of open decisions, the number of scope changes after sign-off, first-pass acceptance in user testing and the gap between the estimate range and the final cost. These measures show whether discovery reduced uncertainty or merely moved it into delivery.
How we handle discovery
Our Custom Software & Integrations division treats discovery as a paid, timeboxed phase with a decision pack as its output. The pricing page explains how discovery and build are scoped separately. For the vendor side of the same decision, read how to evaluate automation vendors as the market changes.
Sources
- International Institute of Business Analysis, Business Analysis Body of Knowledge, accessed 17 November 2026.
- ISO/IEC/IEEE 29148:2018, Requirements engineering, accessed 17 November 2026.
- GOV.UK Service Manual, How the discovery phase works, accessed 17 November 2026.
- GOV.UK Service Manual, User needs, accessed 17 November 2026.
Responses (0)
No comments yet. Add the first one below.
Leave a response
Your email address will not be published. Required fields are marked *.