Vibe Engines
YouTube

Vibe Engines is free, interactive AI engineering & system design — runs in your browser. Pick a learning path

Forward Deployed Engineer  /  Discovery & Scoping
FDE Track 02~13 min readIntermediate
The Highest-Leverage Hour

Find the real problem
before you build the wrong one.

The most expensive mistake an FDE makes isn’t a bug — it’s three weeks building the thing the customer asked for instead of the thing they needed. Discovery is how you avoid it: a disciplined hour of watching, asking, and scoping that decides whether everything after it lands or misses.

01

The wrong-problem tax

Every hour of discovery you skip, you pay back with interest later. Build the wrong thing and you don’t just lose the build time — you lose the credibility of the demo, the momentum with the champion, and often the second chance. This is the wrong-problem tax, and it’s the single biggest reason deployments fail. Not bad code. The right code for the wrong problem.

The trap is that a customer hands you a solution shaped as a request. “We need a dashboard.” “Can you build us a chatbot?” Those are guesses at a solution, made by someone who lives with a problem you haven’t seen yet. Your job in discovery is to walk backwards from the requested feature to the pain that produced it — because the best solution to that pain is frequently not the feature they named.

→ The reframe that saves weeks

When you hear a feature request, silently translate it: “They’re telling me they have a problem important enough to imagine a fix. What is it?” Then go find the problem. The feature is a clue, not a spec.

02

Watch, don’t (only) ask

The highest-signal discovery activity isn’t an interview — it’s sitting next to someone while they do the thing you’re there to fix.

Ask a person to describe their workflow and you get a clean, idealized story: step one, step two, done. Watch them actually do it and you see the truth — the spreadsheet they export and paste into, the three tabs they flip between, the field they always leave blank because it’s wrong, the exception that shows up twice a week and derails everything. The mess is the opportunity. It’s where time is lost, errors creep in, and value is waiting.

This is the jobs-to-be-done lens: people don’t want your software, they want a job done — “get this report out by Friday without three people touching it.” Frame discovery around the job, not the tool, and you naturally find the parts of the job that hurt most.

Do

  • Ask them to “show me how you do this today,” then go quiet.
  • Note every manual step, copy-paste, and workaround.
  • Ask “what happens when it goes wrong?” — the exceptions are gold.
  • Count: how many people, how often, how long.

Avoid

  • Leading questions that confirm your pre-built solution.
  • Accepting a summary — “basically we just…” hides the mess.
  • Talking about your product before you understand their job.
  • Interviewing only managers; watch the people who do the work.
03

The questions that surface truth

A handful of questions do most of the work. They fall in four buckets — the problem, success, constraints, and people. (The full list is in the discovery questions cheatsheet; here’s the logic behind each bucket.)

BucketWhat you’re really finding outA question that gets there
The problemThe pain behind the request, and its cost“Walk me through the last time this went wrong.”
SuccessWhat “solved” looks like, concretely“If this worked perfectly, what’s different on Monday?”
ConstraintsThe landmines that reshape the whole build“Where can this run, and can data leave your network?”
PeopleWho wants it, who can block it, who decides“Whose approval could stop this?”

The constraints bucket deserves special care because it’s the one engineers under-ask and later regret. “Where can it run?” and “can the data leave your network?” often reshape the entire architecture — a SaaS design becomes an on-prem one — and finding that out in week one instead of week six is worth a dozen clever features. It’s the bridge from this handbook to integration and deployment.

04

Define success as one number

A deployment without a success metric is a deployment you can’t win, because “better” is unfalsifiable. Push, gently but firmly, for one number that would move if you succeeded: hours saved per week, error rate on a task, time-to-answer, percentage of cases handled without a human. It doesn’t have to be perfect; it has to be agreed.

Pair the metric with a good-enough bar. Most AI-shaped solutions aren’t 100% accurate, and that’s fine if you know the threshold that makes them useful. “If it’s right 85% of the time and flags the rest for a human, that saves us four hours a day” is a scoping goldmine — it tells you exactly what to build and when to stop.

→ The demo bar

Also ask directly: “What would you need to see to believe this is real?” The answer defines your first demo — and stops you from polishing things the customer doesn’t care about.

05

Scope the smallest slice that proves value

Discovery ends in a decision: what to build first. The art is cutting scope without cutting the point.

The instinct is to build the whole vision. The discipline is to build the smallest end-to-end slice that a real user could try and that would make them believe. One workflow, one real data source, one convincing result — beats ten features in mock-up every time. A POC is an argument, and a narrow argument delivered fully is more persuasive than a broad one delivered in slides.

Cutting scope without cutting the point
MustOne workflow, end to end, on real data — the thing that proves the value.
Fake itAnything not core to the proof: hardcode it, stub it, do it by hand behind the scenes.
LaterEvery “can it also…”. Write it on a visible list so the customer feels heard.
TimeboxGive the slice a deadline (a week or two). A demo date forces the cuts.

Two techniques make the cutting concrete. MoSCoW (Must / Should / Could / Won’t) forces everything below “Must” to prove its way up. And a hard timebox — “we demo Friday” — is the best scope-cutter there is, because it converts an open-ended build into a set of decisions about what to leave out.

06

Red flags and when to walk

Discovery also protects you. Some engagements are set up to fail no matter how good your code is, and the signals show up early if you’re watching. Surfacing them is a service to everyone — including the customer.

Red flagWhy it kills deployments
No problem ownerIf no single person owns the pain, no one will adopt or defend the solution.
No success metricYou can’t prove value, so “it works” becomes an opinion you’ll always lose.
No path to the dataThe data you need is behind a system no one will grant access to. The build stalls at integration.
No championNobody internal wants it to succeed and will fight for it. Momentum dies at the first obstacle.

One red flag is a caution; several is a conversation. You don’t always walk away — sometimes the move is to fix the flag (help them define a metric, find a champion, start the access request) as the first deliverable. But naming the risk beats silently building into it. With the real problem, a success metric, and a scoped slice in hand, you’re ready for the part where most POCs actually die: integration.

Deep dive

The assumptions block, and the one line that makes it mean something

Discovery produces answers. This is how those answers become a schedule you can defend when the customer is four weeks late with the data.

The most common way a well-scoped deployment overruns is not scope creep. It is that the customer took nine weeks to grant database access and the timeline never moved. Everything you learn in discovery has to land in one of two places in the statement of work — an acceptance criterion or an assumption — and assumptions only protect you if one specific sentence is attached to them.

where a discovery answer goes
▸

Measurable & ours

“40 of the 60 weekly exceptions resolved without a human.” Becomes an acceptance criterion with a named approver and a review window.

▸

Needed from them

“Read access to the invoice warehouse by week 1.” Becomes an assumption with a date.

▸

Still unknown

Goes on the open-risk list and into the next session. An unexamined axis is where the surprise comes from — usually data or risk.

Anything that lands in none of the three is a scope argument already scheduled for month four.
# the assumptions block, written properly
customer provides read access to the invoice warehouse by   week 1
customer names one SME available 4h/week for            weeks 1–8
customer decisions returned within                            5 business days
environment (VPC, IdP app registration) available by       week 2

# and the clause without which the four lines above are decoration
"delays in the above shift milestone dates day-for-day."

Nobody objects to that sentence when it is proposed before signature, and nobody can add it afterwards. It is also the cheapest possible way to make a customer’s internal dependencies visible to their own sponsor — which is frequently the thing that gets the access granted in week two rather than week nine.

→ The six-question budget

A real discovery call has room for about six questions that matter, and the skill is which six. Cover the axes rather than drilling one: outcome, data, users, constraints, success, risk. The test before asking anything: if the answer came back either way, would I build something different? If not, it is costing you a slot. Practise the trade-off in the scoping question log.

By the numbers

Worked example: from “we need a dashboard” to one number

A finance team asks for a dashboard of invoice exceptions. The numbers below are illustrative, but each one comes from a move on this page: watch, count, sort, slice, agree a bar, check a constraint, write the assumption.

StepWhat you heard or sawArithmeticDecision
1“We need a dashboard of exceptions.”—A clue, not a spec. Ask to watch the work.
2Shadowing: each exception is exported to a sheet, looked up in the ERP, then emailed60 weekly exceptions × illustrative observed mean of 12 min720 min = 12 h of modeled pre-change workload; document the observation sample
3Sort the pile you watched45 of 60 are a PO-number mismatch75% of the volume is one type
4Pick the slice: PO mismatches only, end to end, real data45 × 12 min9 h of modeled pre-change workload in this slice, before review and rework
5Agree a pilot target: resolve 40 cases under approved rules, with human handling for the rest40 × 12 = 480 min before new-workflow effortAt most 8 h of pre-change work is addressed in this planning model; measure actual review, rework and unfinished cases before claiming capacity released
6“Can the data leave your network?” “No.”—Deploy in their VPC. It changed the build, so it earned its slot.
7Assumption: warehouse read access by week 1. It lands in week 5.Four-week delay on the stated critical pathPropose a week-12 milestone through the agreed change process; confirm parallel work and mitigation before approving a new date

The observed lookups give the dashboard request a more concrete first target: one common exception type. The 12-hour and 8-hour figures are planning calculations, not post-change outcomes. Step 5 needs a quality bar, review effort, a denominator and an owner before “40 resolved” becomes success. Compare measured case-level work against the baseline and include unresolved work. Step 7 records an access dependency and its schedule consequence through change control; a late dependency does not automatically prove the whole delivery moves by the same amount.

Trade-offs

Cost and trade-offs of each discovery move

Here Time is what a move costs you, and Space is what you get back. Durations are typical budgets, not rules.

CaseTimeSpaceWhy
Shadowing a userA session or two per roleThe real workflow, its counts and its exceptionsReveals workarounds and actual task steps. Combine it with logs, representative records and interviews; one observed session is not a population baseline.
Structured interviewUnder an hourGoals, constraints, politicsCheap breadth, but self-reported. Check the counts by watching.
The six-question budgetOne callOne answer per axisA question whose answer would not change the build wastes a slot.
A real data sampleHours to get, minutes to readShape, nulls, volume, access pathExposes the “no path to the data” flag before signature, not in week six.
Skipping discoveryZero nowWeeks on the wrong buildThe wrong-problem tax, paid later with interest.
Timeboxed sliceA week or twoOne workflow proven on real dataThe deadline makes the cuts. Without one, every “can it also…” gets in.

The expensive moves (shadowing, a real data sample) are the ones that find what interviews cannot. Skipping them saves an afternoon and risks the engagement.

In the wild

Where this shows up in real-world work and interviews

  • Discovery happens twice

    Once before signature, to scope and price. Again when real data arrives, because the sample always hid something. Plan the second pass as a checkpoint in the timeline, so a re-scope reads as the plan working rather than as a slip.

  • AI projects: your eval set

    The cases you watched become test cases, and the good-enough bar becomes the eval threshold. Approved PO-mismatch examples can seed development coverage. Adjudicate reference labels, reserve a representative holdout and add synthetic challenge cases for failures missing from the observed sample. Do not tune on the same cases used to make the final acceptance claim.

  • Product and user research

    The same discipline runs product teams’ user research. Jobs-to-be-done frames the work. Rob Fitzpatrick’s The Mom Test makes the core rule memorable: ask about what people did last time, not whether they would like your idea.

  • The interview version

    If an interviewer plays a customer who “wants a chatbot”, do not design one. Ask for the last time the problem hit, who felt it, how often, and what “solved” would change on Monday. Then propose a slice with one number and one stated assumption. Pushing back politely is the skill being tested.

Self-check

Check yourself

A customer says: “Build us a chatbot over our policy documents.” What is your first question?

Something like “Walk me through the last time someone needed a policy answer and didn’t get it.” The chatbot is a guessed solution. The pain might be slow answers, or it might be that the documents disagree with each other, and then a chatbot would just answer wrongly with confidence. Find which before choosing what to build.

You have about six questions. Which is the weakest use of a slot: “What colour should the UI be?”, “Can data leave your network?” or “Whose approval could stop this?”

The colour. Whatever the answer, you would build the same thing this month, so it fails the test of “would I build something different?” The network question can move the whole architecture, and the approval question can decide whether anything ships.

A manager says the task takes 5 minutes. Watching shows 12, with two tab switches and an email. Which number goes in the baseline?

Record the 12-minute observation and the manager estimate separately. Agree the task boundary and sampling method, then observe enough representative cases to characterize the baseline and its variation. One observed task does not establish the average duration of every case. Customer review confirms the definition; it does not remove sampling uncertainty.

The data access is easy, but there is no success metric and no champion. Walk away?

Not yet: that is a conversation, not an exit. Make fixing the flags the first deliverable. Sit with the problem owner and agree one number, and find someone inside who will defend the result. If they will not engage with either, the engagement is set up to stall however good the code is, and saying so early is the honest move.

Frequently asked

Quick answers

What is customer discovery for an FDE?

It’s the process of finding the real problem behind a customer’s request, the constraints around it, and what "solved" actually means — before building. For an FDE it’s hands-on: watching users do the work, asking targeted questions, and scoping the smallest slice that proves value. Good discovery is the difference between a solution that lands and weeks spent on the wrong thing.

Why watch users instead of just asking them?

People describe an idealized version of their workflow and skip the messy parts — the spreadsheet they copy-paste into, the field they always leave blank, the exception that happens twice a week. Those messy parts are usually where the real problem and the real value live. Watching surfaces them; interviews alone rarely do.

How do you scope a proof of concept?

Pick the single workflow that best demonstrates value, cut it to the smallest end-to-end slice that a user could actually try, and timebox it. Everything else goes on a “later” list you can point to. A good POC does one real thing convincingly rather than ten things in mock-up. The scoping question is: what is the least I can build that would make them believe?

What are red flags in a customer engagement?

No clear owner of the problem, no metric that would prove success, no realistic path to the data you’d need, and no internal champion who wants it to work. Any one is a warning; several together mean the deployment is likely to stall regardless of how good your code is. It’s better to surface these in discovery than discover them in week six.

Customer Discovery & Scoping · part of the FDE track · Vibe Engines · 2026
Finished this one? 0 / 209 Handbooks done
NextLearning a Customer’s Domain Fast Next on the “The deployment loop” ladder · rung 2 of 8

Explore the topic

See this alongside everything else on the same subject — handbooks, system designs, challenges and tools, in one place.

More Handbooks