IT Consulting

Software development discovery phase: what to do before you build

A practical software development discovery phase guide: scope, risks, costs, outputs, and questions to answer before coding starts.

Syntanea
Software development discovery phase: what to do before you build

Software development discovery phase is the work you do before the team starts building the wrong thing with confidence.

Most failed software projects do not fail because React, .NET, Python, or the cloud provider betrayed anyone. They fail earlier. A workflow was half understood. A manager assumed an exception was rare. A vendor estimated from a feature list that sounded clear in a meeting and became messy two weeks later.

Discovery is how you slow down for a short time so the project can move faster later. For a small internal tool, that might mean five focused days. For a system that touches finance, operations, integrations, and customer data, it might mean three or four weeks.

Abstract navy and teal geometric discovery map for software planning

What a software development discovery phase should answer

Good discovery is not a workshop where everyone writes wishes on sticky notes and leaves with a pretty PDF. It should answer enough hard questions to decide what to build first, what not to build yet, and what could break the plan.

By the end, you should know:

  • Who will use the system and what job they are trying to finish
  • Which workflow happens every day and which happens twice a year but matters a lot
  • What data the system needs, where it comes from, and who owns it
  • Which integrations are required for version one and which can wait
  • What security, audit, compliance, or approval rules cannot be guessed later
  • What the first release must prove before more budget is added
  • If those answers are still fuzzy, a fixed delivery plan is mostly theatre.

    Why project discovery reduces software cost

    Discovery costs money, so buyers sometimes try to skip it. That is understandable. Nobody wants to pay for meetings before paying for code.

    The problem is that unclear work does not disappear. It moves into development, where it is more expensive. A missing edge case in week one might be a conversation. The same edge case after the database, screens, permissions, and reports are already built can become a rebuild.

    A simple example: a company wants an internal approval tool. The first brief says there are three approval levels. During discovery, the team finds six real paths: urgent approvals, substitutions during holidays, country-specific limits, approval by cost center, audit overrides, and a monthly exception report. That changes the data model. It also changes the estimate.

    Finding that before development is not delay. It is damage control.

    Discovery phase deliverables that are actually useful

    A useful discovery phase should leave the buyer and the development team with working decisions, not just notes.

    For most custom software projects, the deliverables should include:

  • A short problem statement in plain language
  • User groups and the jobs they need to finish
  • Current workflow map, including exceptions and manual workarounds
  • Prioritized version-one scope and a separate later list
  • Key screens, wireframes, or clickable prototype for risky flows
  • Integration list with owners, access needs, and known limitations
  • Data model sketch or entity list for the core business objects
  • Risk register with technical, operational, and decision risks
  • Estimate range with assumptions, not a fake precise number
  • Delivery plan for the first four to eight weeks
  • The format can be simple. A 12-page decision document is often better than a 70-page specification nobody reads.

    How long the software discovery phase should take

    The right length depends on risk, not company size.

    A rough guide:

  • 3 to 5 days for a small automation, proof of concept, or internal tool with one owner
  • 1 to 2 weeks for an MVP with several user roles, payments, reporting, or one important integration
  • 2 to 4 weeks for an operational system with legacy data, ERP or CRM integration, audit needs, or several departments
  • Longer only when the project includes regulated data, procurement delays, heavy migration, or many external stakeholders
  • If a vendor proposes six weeks of discovery for a small landing-page-backed MVP, ask why. If someone offers to skip discovery for a system that will run finance or operations, ask a harder question: what are they estimating from?

    What to cover in discovery workshops

    The best workshops feel less like brainstorming and more like careful interviewing. The goal is to expose how work really happens.

    Ask questions like:

  • Walk me through the last real case, not the ideal process.
  • What happens when data is missing or wrong?
  • Who can override the rule, and how is that recorded?
  • Which spreadsheet, email inbox, or Slack thread is quietly part of the process?
  • What report does someone rebuild manually every month?
  • What would make the first version useless?
  • What decision are we avoiding because it is politically awkward?
  • That last question is uncomfortable. It also saves projects. Many software problems are decision problems wearing a technical jacket.

    Discovery for AI and automation projects

    AI projects need discovery even more than normal software projects because the demo can look useful before the workflow is safe.

    For AI automation, discovery should separate three things:

  • Inputs the model can read, such as documents, emails, tickets, invoices, calls, or forms
  • Decisions the business can safely automate
  • Exceptions that must still go to a person
  • Do not start with "we need an AI agent." Start with the queue, the handoff, the cost of mistakes, and the review path. A 70 percent automation rate can be excellent if the other 30 percent is routed clearly. A 95 percent accuracy claim is useless if nobody knows what happens when the system is wrong.

    For a deeper AI rollout plan, see our AI implementation roadmap.

    Red flags during software project discovery

    Discovery is also a chance to notice whether the project is ready.

    Watch for these signs:

  • Stakeholders disagree on the goal but want one estimate anyway
  • Nobody owns final decisions
  • The current process has many exceptions, but nobody can name them
  • Integrations are described as "simple" before anyone checks API access
  • Users are not available for interviews
  • The budget assumes version three, but the timeline assumes version one
  • The team wants fixed price but keeps changing the business rules
  • None of these has to kill the project. They do mean the first phase should focus on reducing uncertainty before building too much.

    A practical discovery agenda for two weeks

    Here is a simple two-week structure for a medium-sized business application.

    Week 1: interview process owners and users, map the current workflow, collect sample data, review existing systems, list integrations, and identify the first release goal.

    Week 2: sketch the core flows, confirm data rules, check integration access, split must-have scope from later scope, estimate delivery options, and choose the first milestone.

    The output should be a decision package: what we build first, why that piece matters, what it costs, what can go wrong, and what the buyer must decide before development starts.

    FAQ

    What is a software development discovery phase?

    A software development discovery phase is a short planning stage before development. The team maps users, workflows, data, integrations, risks, scope, and success criteria so the first build is based on evidence rather than assumptions.

    Is discovery necessary for every software project?

    Not always. A very small, well defined task may not need formal discovery. Custom business software, MVPs, automation projects, AI workflows, and legacy system work usually need it because hidden rules and integrations can change the design and budget.

    How much does a software discovery phase cost?

    Small discovery engagements often cost a few thousand euros. More involved discovery for a business application can land between EUR 5,000 and EUR 20,000, depending on workshops, UX work, technical research, and integration checks.

    What should happen after discovery?

    After discovery, you should have enough information to approve the first release, delay the project, change scope, or choose a different delivery model. The next step is usually a small build phase with clear milestones and weekly review.

    Can discovery be part of a fixed-price project?

    Yes. In many cases the safest fixed-price agreement is discovery first, then fixed price for a narrower build phase. Pricing the whole product before discovery usually pushes uncertainty into buffers and change requests.

    Need a clearer plan before you build?

    Syntanea helps companies turn loose product ideas, manual workflows, and AI automation concepts into scoped software projects. We are based in Wrocław and work with European teams that want practical delivery, not ceremony.

    If you are planning custom software and the scope still feels slippery, talk to Syntanea. We can run a focused discovery phase, map the risks, and help you decide what version one should actually include.

    Related reading

  • Custom software development cost in Europe - budget ranges and why unclear scope gets expensive
  • How to choose a custom application development partner in Europe - questions to ask before hiring a team
  • MVP development cost in Europe - what to budget for a first release
  • AI implementation roadmap - how to plan useful business AI in 90 days