Skip to content
Proudly Canadian, serving Windsor to Toronto, Ontario · clients welcome from every countryContact usClient login
CodeLumaDevelopment Inc.

Home / Blog / Article

CodeLuma insights · May 25, 2026 · 6 min read

The Discovery Phase: What Happens During Our First Two Weeks Working Together

A transparent walkthrough of a two-week software discovery phase: kickoff, stakeholder and user interviews, workflow mapping, data and system review, prototypes, prioritised scope, estimate and roadmap, with what you provide and receive.

The most expensive mistakes in software happen before anyone writes a line of code: building the wrong thing, misunderstanding users, underestimating integrations or committing to a scope nobody has examined. A discovery phase exists to prevent them. It is a short, focused period at the start of a project where we learn your business, your users and your systems, and turn a promising idea into a plan you can trust. Here is what actually happens in the first two weeks of working together at CodeLuma, so you know what to expect and how to prepare.

The schedule adapts to project size. Larger projects may need longer; simple ones can be shorter.
The schedule adapts to project size. Larger projects may need longer; simple ones can be shorter.

Why we start with discovery

Quotes based on a phone call and a feature list are guesses. Discovery replaces guesses with evidence: we talk to the people who will use the system, examine the data and tools that exist today, test the riskiest assumptions with prototypes, and produce a scope and estimate with visible reasoning. The result is fewer surprises, better decisions about priorities and, frequently, a smaller and cheaper first release than the client initially imagined. It also gives you a low-risk way to test whether we work well together before committing to a larger project. See how we estimate projects and how to scope an MVP.

A project agreement and pen on a desk
Original CodeLuma 3D render: a project agreement and pen on a desk.

Before day one: preparation

Once you decide to proceed, we agree a short statement of work with a fixed price and dates for discovery. We ask you to nominate a primary contact with decision-making authority, to identify the people we should interview, and to gather existing materials: current spreadsheets and documents, screenshots of systems in use, brand guidelines, analytics access, competitor examples, and any earlier specifications. We arrange secure access to systems under appropriate confidentiality terms, following the same practices as in our secrets guide and our security article.

Days 1 to 2: kickoff and alignment

A kickoff workshop of an hour or two with the key stakeholders establishes the basics: the business goals, the problem in the owner's words, who the users are, what success looks like in measurable terms, constraints (budget range, deadlines, regulations, technology preferences) and known risks. We agree the communication rhythm and tools; see our communication article. We also set the discovery's boundaries: what we will and will not decide during these two weeks. By the end of day two we have a written problem statement and a list of questions to answer.

Days 3 to 5: listening

We interview stakeholders and, crucially, real users, whether staff who will use an internal tool or customers of your product. We ask how they do the work today, what frustrates them, what workarounds they use, what data they touch, and what a great outcome looks like. Where possible we observe people working. We map the workflows end to end, noting handoffs, delays and error-prone steps, and gather requirements in the language of the user rather than as technical features. This is where hidden rules tend to surface, and where spreadsheets and informal processes reveal what the software must replicate or improve; see our spreadsheet migration article.

Days 6 to 8: technical and data review

In parallel we investigate the technical landscape: existing systems and their APIs, data sources and quality, hosting, security and compliance requirements, and any third-party services. We run small, time-boxed technical spikes for the riskiest questions, such as whether an integration supports what you need, whether performance targets are feasible, or how messy the data really is. See our integration guide, our API design article and our architecture guide. If there is an existing application, we review the code, dependencies and vulnerabilities; the approach resembles the audit in our legacy modernisation case study. We also consider privacy obligations (our privacy law overview) and where AI could genuinely help, or should not be used (our AI integration guide).

Days 9 to 11: shaping the solution

With the problem understood, we design. We sketch the main user flows and produce wireframes, then a clickable prototype of the most important journeys. Prototypes are the most efficient way to find misunderstandings: a stakeholder who reacts to a screen tells you more in five minutes than in an hour of discussion. We test the prototype with a few users and revise. A prioritisation workshop then sorts the backlog into must-haves for the first release, valuable follow-ups and ideas for later, using impact versus effort, risk and dependencies. This is the moment to cut ruthlessly; see our MVP guide and our idea validation article.

The output is useful even if you decide to build with someone else.
The output is useful even if you decide to build with someone else.
A clipboard with a completed checklist
Original CodeLuma 3D render: a clipboard with a completed checklist.

Days 12 to 14: plan, estimate, present

We consolidate the learning into a discovery report and a presentation for your team:

  • The problem, goals and success metrics, confirmed.
  • Findings from interviews and technical review, including risks and unknowns.
  • The recommended solution and architecture in plain language, with alternatives considered, including buying off-the-shelf where that is smarter.
  • The prioritised backlog and release plan, with the first release clearly defined.
  • A ranged estimate for the first release with assumptions, risks and options; and an indicative budget for later phases; see our pricing model comparison.
  • Hosting and running costs, and post-launch support suggestions (retainer, post-launch plans).
  • Next steps and a timeline.

You own these documents. If you decide to proceed with us, they become the foundation of the build. If you decide not to, or to seek other quotes, you can hand the package to another team, and a competing vendor should be able to quote much more accurately from it. We think that transparency is a strength.

What we need from you

  • A decision-maker available for short check-ins several times a week.
  • Introductions and time with real users and stakeholders.
  • Prompt access to systems, data and documents.
  • Honesty about constraints, politics and past failures, which often carry the most useful lessons.
  • Willingness to have assumptions challenged, including some you love.

What discovery is not

It is not a hidden way to charge for a specification that only we can use, and it is not a delay: two weeks of clarity typically save months of rework. It is also not a guarantee that the project should proceed. Sometimes discovery concludes that a simpler tool, a process change or an off-the-shelf product is the better answer. We would rather tell you that than build something you do not need.

How discovery connects to the rest of the project

After discovery, we move into build: iterative development with regular demonstrations, automated testing and deployment (CI/CD), and visible progress reports. Launch is planned with monitoring, backups and support; see backups and monitoring. Afterwards, we continue with improvements and maintenance. Choosing a partner for this journey is covered in what to look for when hiring.

If you have an idea, a struggling system or a spreadsheet that has outgrown itself, discovery is the safest first step. Book a discovery conversation and we will tell you honestly whether and how we can help. Our software team runs discovery for projects of all sizes, with support available throughout.


Put this into practice with CodeLuma

CodeLuma's paid two-week discovery gives you a clear scope, a clickable prototype, a prioritised roadmap and a ranged estimate you own and can take anywhere, before you commit to a full build.

Start a conversation. Tell us about your project and we will reply with practical next steps, or browse all CodeLuma services. CodeLuma Development Inc. is a Canadian company that works with teams in Windsor, Essex, London, Toronto, Mississauga and across Ontario, throughout Canada and remotely.

Keep reading

Share this article: Facebook · LinkedIn · X · Email

← All articles

Ready to put this into practice?

Talk to a Canadian full-stack team that builds complex, connected systems for clients across Canada and worldwide.

Start a project