Back to all posts
Methodology7 min read·October 26, 2026

What Should a Paid Software Discovery Workshop Deliver?

TB
ThynkBlox Team
Engineering

A paid software discovery workshop should deliver a clear problem definition, an agreed first-release scope, evidence about important assumptions, and a delivery recommendation with its costs and limits explained. You should receive usable files, recorded decisions and a list of unresolved questions with owners. Judge software discovery workshop deliverables by whether they help you decide what to build, whether to proceed and what another supplier would need to implement it.

What should you agree before paying for discovery?

Define the purchase in terms of outputs, not attendance. A proposal that promises interviews and workshops describes activities. Ask what those activities will produce and how you will accept the results.

Agree which decisions discovery must support. These might include whether to replace an existing tool, which customer journey belongs in the first release, or whether a required integration is practical.

For each promised output, specify its format, level of detail and acceptance condition. Also agree who supplies business information, who approves scope, and how missing access or unavailable participants will affect the work.

Discovery can end with a recommendation to pause, buy an existing product or narrow the idea. Make room for those conclusions in the brief.

Which deliverables should you expect?

Use this as a starting specification. Scale the detail to the decision and the uncertainty involved.

DeliverableWhat it should containHow to judge it
Problem and outcome briefTarget users, current difficulties, desired outcomes and constraintsCan you explain why the build is worth considering?
Workflow and scope mapMain journeys, exceptions, roles and release boundariesCan you distinguish essential work from later options?
Prioritised requirementsExpected behaviour, business rules and acceptance examplesCan a supplier explain what completing each item means?
Design evidenceRelevant sketches or prototypes, feedback and resulting changesCan you see what was explored and what remains untested?
Technical assessmentSystem boundaries, data needs, integration findings and optionsCan you trace the recommendation to evidence and constraints?
Delivery and estimate briefProposed sequence, cost ranges, assumptions and dependenciesCan you understand what would change the price or schedule?
Decision and handover packDecisions, unresolved questions, owners and editable source filesCan someone continue without reconstructing the workshop?

Do not demand every possible document. Ask for enough detail to make the next decision responsibly.

How detailed should the scope and requirements be?

The scope should describe work people need to complete, rather than a list of screens.

“Customer dashboard” leaves too much open. A more useful requirement explains who uses it, what information they can see, which actions they can take and what happens when information is missing.

Record important exceptions alongside the main journey. Consider rejected requests, duplicate submissions, unavailable integrations and actions that require approval. Identify who decides unresolved business rules.

Separate requirements into first-release commitments, later candidates and explicit exclusions. The guide to writing a software requirements document shows one way to structure them. Add acceptance examples to requirements whose meaning could otherwise be disputed.

For example, “a reviewer can approve a request” should explain who qualifies as a reviewer, which requests they may access, and what approval changes. That gives an implementing supplier something concrete to discuss and verify.

What design and technical evidence is worth paying for?

Request evidence that addresses the riskiest questions.

If users may misunderstand a workflow, ask for a prototype and a record of feedback from the intended users. If no user sessions are included, the handover should say so. Stakeholder approval should be recorded separately from user feedback.

Specify which journeys the prototype covers and which interactions are only simulated. For more on defining that work, see why startups should consider UX before code.

For technical uncertainty, ask a precise question. Can the external system provide the required records? What access is needed? What happens when it is unavailable? Request the findings, their limits and the next step.

Any proposed architecture should explain its trade-offs against your needs. Record alternatives considered and the conditions that would justify revisiting the choice.

How should estimates and the delivery plan be presented?

Ask for an estimate whose assumptions you can inspect.

It should connect the proposed scope to a cost range and delivery sequence. Separate implementation from optional work and recurring charges. State what depends on your team, another provider or an unresolved decision.

An estimate should also explain its uncertainty. If integration access has not been confirmed, identify the affected work and explain what investigation would narrow the range.

Avoid accepting a single total supported only by a feature list. Request enough breakdown to compare options without pretending that every future task is already known.

The delivery recommendation should identify the smallest useful release, its acceptance conditions and the decisions required before work starts. It should also explain what can wait.

Who should own the outputs and unresolved decisions?

Agree ownership and reuse terms in writing before discovery begins.

Specify what you will receive: documents, diagrams, design files, research notes and any experimental code. Distinguish material created for your project from supplier templates or third-party materials.

Ask for terms that permit you to share the relevant outputs with another supplier and use them for implementation. Do not assume payment alone answers every ownership or licensing question; make the intended use explicit in the agreement.

Files should be accessible through accounts you control, with editable versions where practical. Clarify any restrictions on sharing participant information.

Each unresolved question also needs an owner. Record who will answer it, what evidence is needed and which decision depends on it.

What should a useful discovery outcome look like?

Consider this illustrative example: a founder wants a portal for submitting and approving service requests.

Discovery might conclude that request submission and review belong in the first release, while automated billing should wait. The pack would explain that boundary, show both journeys and define permissions.

Suppose access to an external scheduling system remains unavailable. The handover should record that limitation, identify who will obtain access, and make the integration estimate conditional on checking it.

A useful recommendation might propose a manual scheduling step for the initial release, with the founder explicitly accepting the extra work. The discovery pack should show the reasoning, the consequence and what would trigger reconsideration.

That is a usable decision. A presentation saying “build a seamless service platform” is too vague to guide implementation.

How can you test whether another supplier could use the work?

Apply a handover test: could a capable supplier explain the proposed build, challenge its assumptions and prepare an implementation proposal from the pack?

Check whether it answers these questions:

  • Who is the product for, and which problem takes priority?
  • What is included, excluded and still undecided?
  • Which findings are supported by evidence?
  • Which designs and technical ideas remain provisional?
  • What business rules and acceptance examples govern the main journeys?
  • What dependencies affect the estimate?
  • Are the files accessible, editable and permitted for reuse?

Another supplier may recommend changes. Portability means the reasoning is available for inspection and reuse; it does not require every supplier to reach the same conclusion.

Use software documentation best practices to assess the handover, alongside these questions for choosing a development agency.

What common mistakes should you avoid?

Accepting a polished sales deck as the whole output. Request the supporting requirements, findings, assumptions and source files.

Treating every assumption as resolved. Ask the supplier to distinguish evidence, working assumptions and unanswered questions.

Expecting a prototype to be production software. Agree whether experimental code is disposable or intended for further development, and what checks would precede reuse.

Leaving exclusions implied. State whether discovery includes user recruitment, detailed visual design, migration investigation, accessibility review or security assessment.

Buying more discovery than the decision needs. For a tightly bounded change with clear acceptance conditions, a focused assessment may be sufficient. Ask which uncertainty each activity will resolve before adding it.

What questions do founders ask about paid discovery?

Should discovery guarantee the final build price?

Require the supplier to state whether its figure is an estimate or a binding offer. Any commitment should identify the scope, assumptions, exclusions and change terms it covers.

Must the discovery supplier also build the product?

Make that a separate decision. Agree whether you can take the outputs elsewhere and whether any implementation discount carries conditions.

What if discovery recommends stopping?

Assess whether the recommendation follows from the findings and answers your original questions. A reasoned decision to stop can satisfy the brief when that outcome was allowed.

How do you know discovery is complete?

Review the agreed deliverables against their acceptance conditions. Confirm that files are accessible, decisions are recorded and remaining questions have owners. Completion should be something you can inspect.

Ready to build?

Let's turn these ideas into your next product.

Start your project