Module 1 · The FDE role and mindset · Chapter 1
What an FDE actually does
- A forward deployed engineer (FDE) is a software builder who works inside a customer's business and stays until the software really works.
- It is one of the fastest-growing jobs in AI, and it pays well (real numbers below).
- You already have half the skills if you can code. This course teaches the other half.
The one picture to remember: the FDE is the chef who cooks in your kitchen.
Next: you will meet a few words again and again. Here they are in plain language, then the real numbers on why this job is worth learning.
Words you'll meet
- FDE: a builder who works with the customer and stays until it really works.
- SDE: a software engineer who builds the company's own product.
- Production: the real thing people depend on, not a practice version.
- Proof of concept (POC): a small build that shows an idea can work.
- Pilot: a small real trial with real users and data.
- Stakeholder: anyone who cares how the project turns out.
- Champion: a person at the customer who helps you succeed.
- Baseline: how things are today, so you can prove they got better.
Why it is worth learning right now
Real data from public job boards, snapshot 15 November 2026. Posted base salary only.
Who is hiring: OpenAI (95 roles), Palantir (91), Databricks (86), Anthropic (46), plus Scale AI, Cohere, Stripe and others. Pay is only listed on some postings (144 of the 367 list US-dollar ranges), and ranges vary by level and location. See every opening on the jobs and pay page.
Next: who does what. Four jobs touch software and customers, and people mix them up.
Four jobs, one kitchen
Four jobs touch software and customers. Picture a restaurant. Only one chef cooks in your kitchen.
Where the picture breaks down: a real FDE also carries what worked back to the company, so the product gets better for everyone.
Next: the title "FDE" is not used the same way everywhere.
Three jobs share one title
Companies use "FDE" in different ways. Always read the posting.
- Builder FDE: writes and runs real code inside the customer's business. This course is about this one.
- Sales-flavoured FDE: a solutions engineer with an FDE title. Shows the product to buyers.
- Sales-tooling FDE: builds tools for the company's own sales team.
Next: how these jobs differ in practice: where does each person's week go?
Where does the time go?
Same week, four different people. Every job is a mix of five things. Click each role to see its mix.
- Time writing code: hours spent building.
- Time with customers: calls, visits, watching them work.
- Responsibility if it breaks: who gets the phone call at 9 a.m. when it stops working.
- Finding the real problem: asking questions until you know what to build.
- Making things reusable: turning one fix into something others can use.
The bars are the author's rough picture, not measured data. Compare the shapes, not the numbers.
- The SDE is tall on code and short on customers.
- The consultant is the reverse: lots of customer time, little code.
- The FDE is the only role tall on customers and on "responsibility if it breaks", with real code too.
- The last bar, "reusable", is the loop back to the product. We come to it in Stage 5.
| Role | Time with customers | Time writing code | Responsibility if it breaks |
|---|---|---|---|
| SDE | Low | High | Low |
| Solutions engineer | High | Low | Low |
| Consultant | High | Low | Low to medium |
| FDE | High | Medium | High |
Next: how a real FDE project goes, start to finish. We follow one made-up delivery company through five stages.
How an FDE project goes: the map
Every project has five stages, like moving house. Press next to see the whole map first.
The example we follow: a delivery company with 6 planners, who keep goods moving. Their VP of operations (VP means vice president) has just said "We need AI for our supply chain." The supply chain is the path goods take from makers to buyers.
- Watch how the work really happens. The first request ("AI for our supply chain") is rarely the real problem. You leave with a clear problem, a champion at the customer, and a way to measure success.
- Build the smallest thing that shows the idea working, fast. Example: a screen built from 500 sample shipments.
- Five planners try it on real, messy data. Many projects stall here, because nobody owns the move to production.
- Everyone depends on it. You add alarms, access rules, a security review and a plan to undo changes.
- A system that works earns the next team and the next use case. You reuse what you built.
- What you learn here is handed to the product team, so the next customer starts further ahead. We explain this loop after Stage 5.
Now we walk the stages one by one. Stage 1 starts with a phone call.
Stage 1: Discover, the first call
In Discover you do not build anything. You talk and you watch, to find the real problem.
Below is the first call with the VP. You are the FDE. Choose how you respond and watch two meters: customer trust, and scope risk (the chance the project grows beyond what you can deliver).
Notice: the best path never said yes or no to the six weeks. It asked what goes wrong today. Trust rose and risk fell at the same time.
The VP's answer gave you a clue: planners spend hours phoning carriers (trucking firms) to find late shipments. Next, turn that clue into numbers.
Stage 1: Discover, turn the clue into numbers
A vague wish is hard to act on. A number is easy. In Discover, an FDE measures how big the problem is today (the baseline), so you can prove later that it got better.
Made-up example: the 6 planners spend about 4 hours a day phoning carriers to find late shipments.
- One planner chases carriers 4 hours a day.
- 6 planners: 6 x 4 = 24 hours a day.
- 5 days a week: 24 x 5 = 120 hours a week. This is the baseline.
- Goal: cut chasing in half. 120 / 2 = 60 hours saved (a guess to agree with the VP).
- One full-time person is about 40 hours, so 60 / 40 = 1.5 people's time.
So you leave Discover with four things: a clear problem (late shipments found too slowly), a user (the planners), a baseline (120 hours a week) and a champion (a person at the customer who wants this to work).
Next: Stages 2 and 3. You have a clear problem. Now you build something and put it in front of real users.
Stages 2 and 3: Proof of concept, then pilot
- Proof of concept (POC): the smallest build that shows the idea works. Fast and cheap on purpose.
- Pilot: a small real trial with real users and real data.
Three weeks into the project, you have built a POC. It shows late shipments on a screen, using a sample file of 500 shipments. Here comes the moment that tests every FDE.
The demo is real, but it only proves the idea works on 500 clean rows. A pilot with a small group tests it on the real 20,000 shipments, with security and an owner in place, before everyone depends on it. Saying yes risks the tool failing in front of all the planners on Monday. Saying no throws away goodwill. Agreeing what "ready" means keeps both the trust and the safety.
A sample reply: "I would love that. First, let us run it with 5 planners for two weeks on real data, and ask security to review it. Then everyone gets it the Monday after."
The gap between a working demo and a system people trust is where projects commonly stall. Demos run on clean sample data and skip access rules, alarms and ownership. Closing that gap is a large part of what customers pay an FDE for.
Next: Stage 4. A pilot that works needs to become something everyone can depend on.
Stage 4: Production
Production is the real thing real people depend on. If it breaks at 9 a.m. Monday and someone cannot work, it is production.
Think of a school play. Rehearsal in an empty hall is practice. Opening night with parents in the seats is production.
On opening night you need working lights and a plan for when things go wrong. For software, that means:
- Alarms that tell you when it breaks.
- Access rules about who may see which data.
- A security review, a check that private information is safe.
- A plan to undo a change that goes wrong.
For the delivery company, this is the week all 6 planners start relying on the screen. This is where an FDE earns their pay.
Next: Stage 5, and the part that makes an FDE different from everyone else.
Stage 5: Expand, and the loop back to the product
Expand. The screen works. Now the warehouse team asks for one too. You reuse what you built, so the second project is faster than the first.
Then one more thing happens. It is called the loop back.
What is it?
Something you built for one customer becomes a feature of the product, for every customer.
Example: the planners asked "alert me when a shipment is more than 2 hours late". You built it for them. A month later two other customers ask for the same thing. The product team makes it a built-in setting.
Why does it matter?
- The company: every customer makes the product better, so the next customer is easier to win and to set up.
- The next customer: starts with the alert already built. Days, not weeks.
- You: your work lasts beyond one customer.
How does it happen?
- Notice: you build the same fix a second time.
- Write it down: what the customer asked for, and the hours it saved (your baseline numbers).
- Hand it over: give the product team that evidence.
- Build it once, in a general way: as a setting, not hard-coded for one customer.
- Next customer: starts from the feature, so their Discover is shorter.
Why don't regular software engineers do this?
It is not that they cannot. It is where they sit. This is a pattern in many companies, not a rule for every one.
- An SDE usually hears about customers second-hand (support tickets, product managers). They rarely see one customer's messy day.
- They build for many imagined users, so one customer's details are hard to see.
- A consultant leaves when the report is delivered, so nothing flows back.
The FDE sees the real mess and can build the fix. That makes the FDE the link between customers and the product.
Next: you have now seen the whole job. Here is what you can practise in the rest of the course.
What is coming in this course
You just did one exercise. The rest are hands-on too. Seven chapters are free, so you can try the next ones now:
- Token and context lab: see how a model chops your text into pieces and what its "desk" can hold.
- Embedding map: watch meaning turn into dots on a map, and search by idea.
- RAG lab: build a "chat with your documents" pipeline step by step and see why it fails.
- KV-cache animation: watch why an AI's first word is slow and the rest are fast.
- GPU memory calculator: size the hardware for a 70-billion-parameter model on your own.
- Plus 38 more chapters: agents, evals, security reviews, OAuth, discovery calls, demos, serving models in production.
Mix-ups to avoid
- "An FDE is a salesperson with a laptop." Some titles are sales jobs. The builder FDE writes and runs real code.
- "A great demo means we are nearly done." Real data, permissions and ownership usually take longer than the demo.
- "The first request is the problem." "We need AI" is a wish. Ask and watch to find the real problem.
Recap
- The FDE cooks in the customer's kitchen and owns the result in production.
- Five stages: Discover, Proof of concept, Pilot, Production, Expand. Most projects stall between demo and production.
- In Discover you turn a vague wish into a problem, a user and a baseline number.
- The loop back: what you build for one customer can become a product feature for all of them.
- Hiring is strong and pay is high, but read the posting: some FDE titles are sales jobs.
Chapter quiz
Four questions. Score 70% or more to mark this chapter complete.