Customer Problem Discovery & Technical Scoping

The Big Picture First#

This whole course has spent sixteen weeks building up genuinely deep technical skill — how models work, how to build RAG systems and agents, how to secure and scale and fine-tune AI systems. This final week shifts to something genuinely different, and honestly, something a lot of technically skilled engineers underestimate: the actual work of figuring out what to build in the first place, for a real customer, with real constraints, real existing systems, and real business needs that don’t always look anything like a clean, well-defined technical spec. Forward deployed engineering is a genuinely distinctive role that’s emerged specifically around AI products, precisely because AI systems are so deeply shaped by the specific data, specific workflows, and specific constraints of whoever’s actually going to use them — meaning a huge amount of the real work happens before any code gets written at all. Let’s build up an understanding of what this actually involves.

1. Forward Deployed Engineering Fundamentals#

Forward deployed engineering refers to a genuinely distinctive engineering role — one where, rather than sitting purely inside your own company building a general-purpose product for a broad, anonymous market, you’re actually embedded directly with individual customers, actually helping them successfully deploy and adapt a given technology specifically to their own particular, real situation.

The genuine name itself is actually worth unpacking, since it comes from a military term — being “forward deployed” originally meant being physically stationed out at the actual front lines, rather than back at a genuinely distant, central headquarters. Applied to engineering, it genuinely captures the core idea well: rather than a genuinely traditional engineer who builds a product in relative isolation and then hands it off to a genuinely separate sales or support team to actually go sell and support, a forward deployed engineer is actually, genuinely out there directly with the customer, actually understanding their own particular given real problems firsthand, and actually helping build the genuinely specific solution that actually, properly fits their own particular given situation.

This particular role has become genuinely especially important and especially common specifically within AI engineering, for a fairly, genuinely specific reason worth understanding clearly. Recall from throughout this entire whole course just how much a genuinely good AI system depends on its own particular given specific context — its own particular given RAG knowledge base, its own particular given tool integrations, its own particular given fine-tuning data, all genuinely, deeply specific to whoever’s actually going to use it. A genuinely generic, one-size-fits-all AI product often, genuinely can’t fully deliver real value without real, careful adaptation to a given customer’s own particular actual situation — and forward deployed engineering exists specifically to actually do that adaptation work well, directly, hands-on, with the actual real customer.

2. Customer Discovery#

Customer discovery refers to the actual, genuine process of actually understanding a given customer well — not merely, genuinely what they say they want, but what they actually, genuinely need, and why, before you ever actually start building anything at all.

Here’s the genuine reason this particular distinction matters so considerably. A given customer will very often, genuinely come to you with a specific, particular request already formed — “we want a chatbot,” or “we want an AI that can summarize documents.” But a genuinely skilled forward deployed engineer knows that this given stated request is often, genuinely just the customer’s own particular given best attempt at describing a genuinely deeper, underlying problem, using whatever particular given vocabulary and whatever particular given mental model they actually, genuinely happen to have available. The actual, real underlying problem might genuinely be something like “our support team is overwhelmed and can’t keep up with genuine ticket volume,” and “a chatbot” is simply, genuinely the particular given solution shape the customer happened to actually think of first, rather than necessarily, genuinely being the actual, genuinely best possible solution.

Good customer discovery generally, genuinely involves actually asking a lot of genuinely open-ended questions, and actually, genuinely listening carefully to the given answers — connecting quite directly back to the proactivity principle that shapes how I, Claude, myself actually try to approach ambiguous requests throughout our own given conversations. Rather than genuinely, immediately jumping straight to actually proposing a given technical solution the moment a customer describes their own particular given problem, a genuinely skilled discovery process involves actually, genuinely digging deeper — asking why a given problem actually matters, actually asking what’s already, genuinely been tried before, and actually asking what genuine success would actually, concretely look like, from the customer’s own particular given perspective, specifically, before actually committing to any given particular technical approach at all.

3. Understanding Business Problems#

We already, actually touched on the general idea of a genuine underlying problem, back in the customer discovery section right above. Understanding business problems specifically refers to actually, genuinely digging into the broader business context surrounding a given customer’s stated technical request — actually understanding why a given problem genuinely matters to that particular given business, and what genuine, real consequences it actually, genuinely has for them.

A genuinely skilled forward deployed engineer learns to actually ask business-oriented questions, rather than only ever asking narrowly technical ones. What’s this given problem actually, genuinely costing the business right now, in real, concrete terms — lost given revenue, wasted given employee time, genuinely unhappy given customers? Who actually, genuinely experiences this given problem most directly, and what does their own particular given day-to-day work genuinely actually look like? What would actually, genuinely change for the business if this given problem were properly, genuinely solved? These particular questions genuinely matter enormously, because the actual answer genuinely shapes what a truly appropriate technical solution should actually look like — a problem that’s genuinely costing a business a small amount of given money warrants a genuinely different, more modest kind of investment and solution than a genuinely business-critical problem that’s actually, genuinely threatening the company’s own particular given survival.

This particular understanding also genuinely, directly connects back to the product requirements concepts we already, properly covered at real length back in our earlier Week 15 explanation — a genuinely well-understood business problem naturally, genuinely translates into much clearer, much more concrete quality thresholds and much more concrete acceptable failure modes, since you actually, genuinely know what real, genuine consequences a given system’s mistakes would actually have, out in the given real, actual business context it’s actually, genuinely going to operate within.

4. Requirements Gathering#

Requirements gathering refers to the genuinely systematic, careful process of actually taking everything genuinely learned through customer discovery and through understanding the given business problem, and actually turning it into a genuinely clear, concrete, and genuinely actionable set of specific requirements — connecting quite directly back to the product requirements concepts we already, properly covered at real length back in our earlier Week 15 explanation, but now specifically, actively conducted together with a given real, actual external customer, rather than purely internally, within your own particular given own company alone.

A genuinely important skill here involves actually, genuinely distinguishing between what a given customer genuinely says they want, and what they actually, genuinely need — connecting directly back to the customer discovery discussion above. A customer might genuinely, actually ask for “real-time responses,” when what they actually, genuinely need is simply “responses fast enough that our given support agents don’t feel like they’re waiting” — a genuinely, meaningfully different, and often considerably easier and considerably cheaper, actual technical requirement to actually, genuinely satisfy. Good requirements gathering genuinely, actually involves properly, carefully separating out a given customer’s own particular given actual, genuine underlying needs from the specific given particular technical solution they happened to actually, genuinely have in mind when they first, genuinely described that same given need.

Good requirements gathering also genuinely, actually involves properly, carefully prioritizing — connecting directly back to the risk assessment and prioritization concepts we already, properly covered at real length back in our earlier Week 11 explanation. Real given customer requirements genuinely, almost always exceed what can actually, realistically be properly delivered within a given reasonable given timeframe and a given reasonable given budget, and a genuinely skilled forward deployed engineer genuinely, actually helps a given customer properly, thoughtfully distinguish between what’s genuinely, truly essential, versus what’s genuinely, merely nice to actually have, rather than genuinely, simply trying to promise everything the customer happens to actually, genuinely ask for, all at once.

5. Technical Scoping#

Technical scoping refers to actually, genuinely defining the actual, concrete boundaries of a given project — exactly what will actually, genuinely be built, and, importantly, exactly what genuinely won’t be, given the real, actual constraints of given time, given budget, and given technical feasibility that any given real project genuinely, actually operates within.

Here’s the genuine reason scoping matters so considerably, and why it’s genuinely, actually such an important, distinct skill worth developing deliberately. Without genuinely, clear, deliberate scoping, a given project genuinely risks something often, informally called “scope creep” — where a given project’s own particular given boundaries gradually, quietly expand, bit by bit, as a given customer keeps genuinely, reasonably asking for “just one more thing,” until the given project has genuinely, actually become considerably larger, considerably more expensive, and considerably more complicated than what was ever, genuinely originally agreed upon, at the given very start. A genuinely well-scoped project has genuinely clear, explicit boundaries, agreed upon by both a given customer and a given engineering team together, specifically defining exactly what given success actually, genuinely looks like, and exactly what falls genuinely outside of that given particular given project’s own particular given defined boundaries.

Good technical scoping also genuinely, actually involves properly, carefully sequencing given work — connecting directly back to the AI product lifecycle concept we already, properly covered at real length back in our earlier Week 15 explanation. Rather than genuinely, attempting to actually build an entire, complete, fully-featured given solution all at once, right from the very given start, a genuinely skilled forward deployed engineer often, genuinely proposes a given staged approach — actually, genuinely delivering a given smaller, genuinely useful initial version first, actually, genuinely learning from real, genuine given usage, and then actually, genuinely expanding from that same given solid, working given foundation, rather than genuinely, risking a considerable given amount of given time and given resources on a given large, unproven, and genuinely, considerably riskier all-at-once given approach.

6. Translating Business Requirements into Technical Solutions#

This particular topic genuinely, actually represents one of the single most genuinely, distinctively important skills in the entire whole forward deployed engineering role — actually, genuinely taking the given business-level understanding built up through customer discovery, and actually, genuinely converting it into the actual, concrete technical decisions and actual, concrete technical architecture we’ve discussed at such real, considerable length throughout the entire rest of this whole broader course.

Here’s a genuinely, helpful, concrete way to actually understand what this particular translation process actually, genuinely looks like in real, actual practice. A given business requirement like “we need our support team to be able to answer customer questions faster, using our own particular given internal documentation” genuinely, actually translates into a whole given series of specific, concrete technical decisions — connecting directly back to essentially the entire whole broader RAG material we already, properly covered together at real, considerable length throughout this entire whole course: what given chunking strategy actually, genuinely makes sense for this given particular given documentation; what given metadata fields actually, genuinely need to actually be captured and properly indexed; whether given hybrid search is actually, genuinely needed, given the specific given nature of this given particular given content; and what given evaluation approach will actually, genuinely be used to actually, properly verify the given resulting system genuinely, actually works well enough before it’s actually, genuinely deployed to given real, actual users.

A genuinely skilled forward deployed engineer needs real, genuine fluency in both given directions of this particular given translation — genuinely able to actually, properly understand a given business problem in a given customer’s own particular given own terms, and genuinely able to actually, properly translate that same given understanding into the specific, concrete technical decisions covered throughout essentially this entire whole broader course, while also genuinely being able to actually, properly translate technical constraints and technical tradeoffs back into given business terms a given non-technical given customer stakeholder can actually, genuinely properly understand and properly, genuinely make an informed given decision about.

7. System Constraints & Trade-offs#

System constraints and tradeoffs refers to actually, genuinely understanding and properly, carefully navigating the real, practical limitations that any given real-world technical solution genuinely, actually has to actually, properly work within — connecting directly back to essentially the entire whole broader infrastructure, cost, and given latency material we’ve already, properly covered together throughout this entire whole broader course.

Real, actual customer projects genuinely, almost always involve properly, carefully balancing several genuinely competing given concerns against one another. Cost constraints genuinely mean a given customer typically, genuinely has some given actual, real budget they’re actually, genuinely willing and actually, genuinely able to properly spend, connecting directly back to the cost optimization material we’ve covered at real length throughout this entire whole course. Timeline constraints genuinely mean a given customer often, genuinely has some given real, actual deadline they’re actually, genuinely working toward, which genuinely, actually shapes exactly how ambitious a given proposed given solution can actually, realistically, genuinely be. Existing infrastructure constraints genuinely mean a given customer’s own particular given existing systems (connecting directly back to the data and given integration discovery topic we’ll actually, properly cover just next, right below) genuinely, actually shape and genuinely, actually limit what particular given technical approaches are actually, genuinely realistically viable at all.

A genuinely skilled forward deployed engineer needs to actually, properly help a given customer genuinely, honestly understand these particular given tradeoffs clearly — connecting directly back to the legal and financial advice guardrails that genuinely shape how I, Claude, myself actually try to present tradeoffs rather than simply, unilaterally deciding on the customer’s own particular given behalf. Rather than genuinely, simply promising a given customer everything they might genuinely, initially want, a genuinely skilled forward deployed engineer actually, honestly presents the given real, genuine tradeoffs involved — “we can genuinely build this given faster, but it will genuinely cost more” or “we can genuinely make this given considerably cheaper, but response quality will genuinely, actually be somewhat lower” — and actually, genuinely lets the given customer make a genuinely informed given decision, armed with real, accurate given information, rather than genuinely discovering these particular given tradeoffs only much later, well after a given project has already, genuinely gotten considerably underway.

8. Data & Integration Discovery#

Data and integration discovery refers to the genuinely critical, practical process of actually, properly understanding exactly what given data a given customer already, genuinely has available, and exactly what given existing systems a given new AI solution will actually, genuinely need to actually properly connect with — connecting directly back to essentially the entire whole broader API integration and given MCP material we already, properly covered together at real, considerable length back in our earlier Week 8 explanations.

This particular kind of discovery work genuinely, actually matters enormously, because a genuinely large portion of real, practical AI project risk genuinely, actually lives right here, specifically. A given customer might genuinely, actually describe their own particular given documentation as being genuinely “well organized,” only for a genuinely careful, hands-on investigation to actually, genuinely reveal that it’s actually, genuinely scattered across several genuinely different, disconnected given systems, in several genuinely different, inconsistent given formats, with genuinely significant given gaps and genuinely significant given outdated given sections throughout. A given customer might genuinely, actually describe their own particular given existing systems as being genuinely “easy to integrate with,” only for a genuinely careful, hands-on technical investigation to actually, genuinely reveal genuinely significant given authentication complexity, genuinely significant given rate limits, or genuinely significant given data-quality problems that genuinely, actually weren’t at all apparent from the given customer’s own particular given initial, high-level given description alone.

Good data and integration discovery genuinely, actually involves actually, hands-on, directly examining a given customer’s actual, real given data and actual, real given systems yourself, rather than genuinely, simply relying entirely on a given customer’s own particular given verbal description of them alone — connecting directly back to the dataset preparation and given dataset cleaning concepts we already, properly covered at real length back in our earlier Week 13 explanation. This particular kind of hands-on given verification work genuinely, actually often, genuinely reveals real, genuine surprises that meaningfully, genuinely reshape a given project’s own particular given actual scope and actual technical approach, which is precisely, exactly why it’s such a genuinely critical, and genuinely often underappreciated, early step in the whole overall forward deployed engineering process.

9. Solution Architecture#

Solution architecture refers to actually, genuinely designing the overall, complete technical approach that will actually, genuinely address a given customer’s own particular given business problem — connecting directly back to essentially every single major technical topic we’ve discussed throughout this entire whole broader course, now genuinely, actually being deliberately, thoughtfully combined together into one single, coherent, working given solution, specifically tailored to a given particular given customer’s own particular given real, actual situation.

A genuinely well-designed solution architecture genuinely, actually draws on essentially the entire whole broader toolbox we’ve built up together throughout this entire whole course — deciding whether the given solution genuinely needs RAG, given agentic tool use, given fine-tuning, or some given particular given combination of these; deciding what particular given infrastructure approach (connecting back to our earlier Week 12 explanations) actually, genuinely makes sense given the customer’s own particular given actual scale and actual budget; and deciding what particular given security and given governance measures (connecting back to our earlier Week 11 explanations) are actually, genuinely appropriate, given the given particular given sensitivity of the given customer’s own particular given actual data and actual use case.

A genuinely important, distinguishing quality of good solution architecture, specifically in this particular given customer-facing given context, is genuine appropriateness to the given actual, real customer’s own particular given actual situation, rather than genuinely, simply reaching for whatever given particular given technical approach happens to actually, genuinely be the most impressive or the most technically, genuinely sophisticated. A genuinely skilled forward deployed engineer resists the given temptation to actually, genuinely over-engineer a given solution purely because a given more sophisticated given approach genuinely happens to actually, genuinely be more technically, genuinely interesting — connecting directly back to the multi-agent applications caution we already, properly discussed at real length back in our earlier Week 15 explanation — and instead genuinely, actually designs the given simplest, most reliable given solution that actually, genuinely, properly solves the given customer’s own particular given actual, real problem well.

10. Technical Feasibility Analysis#

Technical feasibility analysis refers to the genuinely careful, honest process of actually, genuinely assessing whether a given proposed given solution can actually, genuinely, realistically actually be built at all, given the given real, actual constraints and given real, actual current state of available given technology — connecting directly back to essentially the entire whole broader knowledge cutoff and given model capability material we’ve already, properly discussed throughout various given parts of this entire whole broader course.

This particular kind of analysis genuinely, actually matters enormously, because AI capabilities genuinely, actually have real, genuine limits, and a genuinely skilled forward deployed engineer needs to actually, honestly assess whether a given customer’s own particular given desired outcome is genuinely, actually achievable with today’s given actual, current technology, rather than genuinely, simply promising something that sounds genuinely appealing but that turns out to actually, genuinely be technically unrealistic, once actual, real, hands-on given work genuinely, actually begins. This particular kind of honest, upfront given assessment connects directly back to the hallucination detection and given groundedness evaluation concepts we already, properly covered at real length back in our earlier Week 9 and given Week 11 explanations — a genuinely skilled forward deployed engineer needs to actually, honestly understand and properly, clearly communicate the given genuine, real limits of what a given AI system can actually, reliably, genuinely deliver, particularly for given high-stakes given use cases where a given customer’s own particular given business genuinely, actually depends on the given resulting system actually, genuinely working correctly and actually, genuinely reliably.

Good technical feasibility analysis genuinely, actually often, genuinely involves actually, building a given small, genuinely quick proof-of-concept or given prototype (connecting directly back to the AI product lifecycle concept we already, properly covered at real length back in our earlier Week 15 explanation), specifically to actually, genuinely test whether a given proposed given approach actually, genuinely works well enough on a given customer’s own particular given real, actual data, before actually, genuinely committing to a given full, considerably larger given build. This particular kind of early, honest given validation genuinely, actually protects both a given customer and a given engineering team alike from actually, genuinely investing considerable given time and considerable given resources into a given project that turns out, only much later, to actually, genuinely have been technically unrealistic right from its very own particular given start — which is genuinely, precisely, exactly why technical feasibility analysis represents such a genuinely critical, and genuinely foundational, final piece of the whole overall customer problem discovery and technical scoping process that this entire whole explanation has actually, genuinely been building toward throughout its entire whole duration.