Engineering & AI Delivery

Forward Deployed Engineer Academy

The engineer who sits with the customer, finds the real problem, and builds the thing that solves it.

A forward deployed engineer is part software engineer, part solution architect and part consultant. This academy builds that combination from nothing: you start by writing your first Python program and you finish by handing a working, deployed solution to a stakeholder who did not attend any of the technical meetings.

From Zero to Enterprise Deployment

170 chapters · 17 modules · 3 levels · 4 build projects · no prior programming assumed

The role

What a forward deployed engineer actually does

A forward deployed engineer works where the customer is. The job combines software engineering, solution architecture, enterprise integration and the consulting skill of working out what the problem really is, then delivers something into production and hands it over. It is not purely an AI role, although a growing share of the work now involves putting language models into enterprise workflows.

The delivery runs in five stages: discover the customer's problem, design and prototype, build and integrate, deploy and operate, then prove the business outcome and hand over. Each of those stages needs different skills, and the gap between engineers who can build and engineers who can deliver is usually the middle three.

This academy is vendor-neutral. It teaches the engineering and the delivery craft rather than one platform's product, and it assumes you are starting from nothing.

Three levels

FDE 100

Foundations

No prior programming or forward deployed engineering background. Modules 1 to 4.

FDE 200

Engineering and Integration

Learners who have completed the fundamentals, or engineers who pass the diagnostic. Modules 5 to 12.

FDE 300

Enterprise Deployment

Learners ready to run an engagement end to end. Modules 13 to 17.

How long it takes

We quote coverage, not duration. A corporate programme runs at whatever pace the team can absorb alongside their actual work, and the same material has been designed to be worked through quickly by experienced engineers or slowly by people starting from nothing. An experienced engineer can take a diagnostic and skip the foundations. Tell us who is in the room and we will set a schedule around them.

Curriculum

17 modules · 170 chapters

Every chapter carries a plain explanation, a worked example, an exercise, a production consideration and an assessment.

FDE 100 · Foundations4 modules · 40 chapters

M1 FDE Foundations Ch 1–10 · 10 chapters

What the role actually is, who you work with, and the shape of a delivery.

  1. What a forward deployed engineer does, and what the role is not
  2. Where the role came from and why enterprises create it
  3. Engagement models: embedded, project-based and advisory
  4. How an enterprise IT estate is actually organised
  5. Who you will work with on the customer side
  6. The five stages of an FDE delivery lifecycle
  7. Reading a customer's technology landscape in the first week
  8. What success looks like, and who decides
  9. Where FDE work goes wrong, and the early warning signs
  10. Setting up your own working environment and habits
M2 Programming Fundamentals Ch 11–20 · 10 chapters

Enough Python, Git and Linux to build and change software with confidence.

  1. Python from zero: values, names, and running your first program
  2. Control flow, functions and the shape of readable code
  3. Collections, iteration and the patterns you will use daily
  4. Files, formats and talking to the outside world
  5. Errors, exceptions and failing on purpose
  6. The command line and the Linux ideas that matter
  7. Git: commits, branches and undoing things safely
  8. Working with others: pull requests, review and history
  9. Debugging as a method, not a panic
  10. Automated testing and why it speeds you up
M3 Backend Engineering Ch 21–30 · 10 chapters

HTTP, REST and a FastAPI service you can defend in a review.

  1. How the web actually works: requests, responses and status codes
  2. REST in practice, and where REST stops being enough
  3. Your first FastAPI service
  4. Request validation and typed models
  5. Designing an API someone else can use
  6. Authentication: sessions, tokens and what they protect
  7. Authorisation, roles and the principle of least privilege
  8. Background work, queues and long-running jobs
  9. Structuring an application so it survives growth
  10. Testing a service end to end
M4 Databases and Data Engineering Ch 31–40 · 10 chapters

SQL, PostgreSQL and pipelines that hold up when the data is messy.

  1. Relational thinking: tables, keys and relationships
  2. SQL for people who have never written it
  3. Joins, aggregation and the queries that answer real questions
  4. Designing a schema for a business process
  5. Indexes, query plans and why a query is slow
  6. Transactions, consistency and what a database guarantees
  7. Extracting from source systems without breaking them
  8. Transforming and loading: the work between systems
  9. Data quality, validation and reconciliation
  10. Building a pipeline that can be re-run safely

FDE 200 · Engineering and Integration8 modules · 80 chapters

M5 Customer Discovery and Consulting Ch 41–50 · 10 chapters

Finding the real problem before you write a line of code.

  1. Why the stated problem is rarely the real one
  2. Running a discovery conversation
  3. Mapping stakeholders and who actually decides
  4. Turning a workflow into a written description everyone recognises
  5. Decomposing a problem into things you can build
  6. Writing requirements that survive contact with delivery
  7. Choosing measures: what will count as better
  8. Building a business case and estimating return
  9. Saying no, and scoping what you will not do
  10. Presenting findings to people who did not attend the workshops
M6 Solution Architecture Ch 51–60 · 10 chapters

Designing a system, and being able to explain every trade-off in it.

  1. What an architecture is, and what a diagram is for
  2. Decomposing a system into components and boundaries
  3. Choosing between synchronous and asynchronous designs
  4. Cloud building blocks and what they cost
  5. Designing for scale you actually expect
  6. Resilience: failure modes and what you do about them
  7. Integration patterns and when each one fits
  8. Storage choices and the consequences of each
  9. Writing an architecture decision record
  10. Defending a design in a technical review
M7 Enterprise Integration Ch 61–70 · 10 chapters

ERP, CRM and the legacy systems nobody is allowed to replace.

  1. The enterprise application landscape and how it grew
  2. Integrating with an ERP without becoming part of it
  3. CRM integration and the shape of customer data
  4. File-based and batch integration, which is still everywhere
  5. Events and messaging: publishing what happened
  6. Message brokers, queues and delivery guarantees
  7. Idempotency, retries and exactly-once wishful thinking
  8. Working with legacy systems and their owners
  9. Master data, identifiers and matching records across systems
  10. Monitoring an integration you do not own both ends of
M8 Machine Learning Foundations and Model Lifecycle Ch 71–80 · 10 chapters

The problems a language model is the wrong tool for, and how to work them properly.

  1. When the answer is machine learning, when it is an LLM, and when it is rules
  2. Supervised, unsupervised and the shape of a learning problem
  3. Features: building them, and why they decide the result
  4. Training, validation and the discipline of holding data back
  5. Classification metrics and choosing the one that matches the cost of being wrong
  6. Regression metrics and what an error actually means to the business
  7. Cross-validation, tuning and not fooling yourself
  8. Experiment tracking and being able to reproduce last Tuesday
  9. Model registry, versioning and promoting a model to production
  10. Monitoring a deployed model: drift, decay and when to retrain
M9 Model Internals for Engineers Ch 81–90 · 10 chapters

Enough of what is inside a model to reason about it instead of guessing.

  1. Neural networks from nothing: weights, layers and what training changes
  2. Tokenisation, and why a model counts text the way it does
  3. Embeddings as geometry: what a vector actually encodes
  4. Vector databases and choosing one for a real workload
  5. Attention, and the idea that made transformers work
  6. Transformer architecture at the depth an engineer needs
  7. Context windows, memory and what gets forgotten
  8. Open weights against hosted models: control, cost and constraint
  9. Fine-tuning against prompting against retrieval: choosing between them
  10. Running an open model yourself, and when that is the right answer
M10 Applied AI Engineering Ch 91–100 · 10 chapters

Language models in production, with evaluation rather than hope.

  1. What a language model is, in terms an engineer can use
  2. Prompting as an engineering practice
  3. Embeddings and what similarity actually measures
  4. Retrieval-augmented generation end to end
  5. Chunking, indexing and the retrieval quality problem
  6. Structured output and making a model fit your schema
  7. Evaluation: building a test set before you build the feature
  8. Measuring quality, cost and latency together
  9. Choosing a model, and changing your mind later
  10. Failure modes: hallucination, drift and silent degradation
M11 Agentic AI and Automation Ch 101–110 · 10 chapters

Tools, orchestration and keeping a human in the loop.

  1. What makes a system agentic, and when it is the wrong answer
  2. Tool calling: giving a model something to do
  3. Designing a tool a model can use correctly
  4. The Model Context Protocol and connecting to real systems
  5. Multi-step workflows and keeping state
  6. Orchestration: sequencing, branching and recovery
  7. Human approval steps and where to place them
  8. Guardrails, permissions and limiting the blast radius
  9. Observing an agent: traces, logs and replay
  10. Evaluating an agentic workflow against a business outcome
M12 Prototyping and Interfaces Ch 111–120 · 10 chapters

Getting something in front of a customer quickly, without building a product.

  1. Why a prototype beats a document, and what a prototype is not
  2. Streamlit: a working interface in an afternoon
  3. Gradio and the fastest route to a demonstrable model
  4. Connecting a prototype to your own backend API
  5. Designing for AI output: streaming, waiting and partial results
  6. Showing uncertainty, sources and letting a user verify an answer
  7. Handling failure in the interface rather than hiding it
  8. Collecting feedback from the people trying it
  9. Polishing a prototype enough for a stakeholder audience
  10. Knowing when a prototype must be thrown away and rebuilt

FDE 300 · Enterprise Deployment5 modules · 50 chapters

M13 DevOps and Production Deployment Ch 121–130 · 10 chapters

Getting it off your machine and keeping it running.

  1. Containers: what Docker actually does
  2. Writing a Dockerfile you would ship
  3. Local environments that match production
  4. Continuous integration: the pipeline that guards the repository
  5. Continuous delivery and deploying without drama
  6. Deploying to a cloud environment
  7. Kubernetes fundamentals, without pretending you are an SRE
  8. Configuration, environments and keeping them apart
  9. Release management, versioning and rollback
  10. Infrastructure as code and reproducing an environment
M14 Enterprise Security and Operations Ch 131–140 · 10 chapters

The questions security, privacy and operations will ask you.

  1. Identity and access management in an enterprise
  2. Secrets: storing them, rotating them, and never committing them
  3. Data privacy and what you may not move
  4. Governance, approvals and the path to production
  5. Logging and what belongs in a log
  6. Monitoring, metrics and alerting that someone acts on
  7. Incident handling: the first hour
  8. Postmortems and changing the system, not the people
  9. Service levels, support models and what you are promising
  10. Security review: preparing for it and surviving it
M15 AI Risk, Security and Compliance Ch 141–150 · 10 chapters

The attack surface and the regulations that a normal application never had.

  1. Why an AI application has risks a normal application does not
  2. Prompt injection, direct and indirect, and what actually stops it
  3. The OWASP risks for language model applications
  4. Personal data in prompts, logs and traces
  5. Data residency, retention and what may leave the estate
  6. Bias and fairness: auditing a model for who it works badly for
  7. Audit trails for an AI decision someone may have to defend
  8. SOC 2 and HIPAA: what an auditor will ask you for
  9. India's DPDP Act and the EU AI Act, in engineering terms
  10. Auditing a live AI application end to end and writing it up
M16 Demonstration and Storytelling Ch 151–160 · 10 chapters

Showing the work so that a room of non-engineers understands what it is worth.

  1. Why a demonstration is an argument, not a tour of features
  2. Structuring a demo: problem, insight, solution, impact
  3. Choosing what to show and what to leave out
  4. Preparing data that makes the point without being fake
  5. Visualising an AI output so a non-technical viewer can judge it
  6. Running a live demo and surviving the thing that breaks
  7. Reading the room and changing course mid-demonstration
  8. Answering the hard question honestly without losing the room
  9. The follow-up: what you send afterwards and when
  10. Turning a successful demonstration into an agreed next step
M17 FDE Engagement and Delivery Ch 161–170 · 10 chapters

Pilot to handover, and leaving something the customer can run.

  1. Scoping a pilot that proves something
  2. Running a delivery with a customer in the room
  3. Reporting progress to the sponsor who is funding the work
  4. User acceptance testing and what acceptance means
  5. Documentation someone will actually read
  6. Training the people who will own it
  7. Change management and getting the thing adopted
  8. Handover: runbooks, access and the last mile
  9. Measuring the outcome after you leave
  10. What to do when the engagement goes badly
Practical work

Four projects you build

Slides and multiple-choice questions do not make a forward deployed engineer. The projects are the programme; the chapters exist to get you through them.

PROJECT 1

Build an enterprise application

An API-backed business application with PostgreSQL behind it, authentication, automated tests and a frontend someone can actually use. The first time the whole stack is yours.

PROJECT 2

Enterprise system integration

Integrate simulated CRM, ERP and transactional systems. The work is in what goes wrong: API failures, inconsistent data, validation and reconciliation.

PROJECT 3

Production-grade AI solution

A document intelligence and workflow automation application with retrieval, tool calling, evaluations, a human approval step and the security controls an enterprise will ask about.

PROJECT 4

Simulated customer engagement

Run discovery, define scope, design, implement, deploy, demonstrate and hand over a working solution to simulated stakeholders. The whole lifecycle, compressed.

How it runs

Delivery, assessment and what you get

Self-paced, cohort and enterprise delivery are all available. The labs are self-contained: Python, PostgreSQL, Docker, FastAPI and Git, with starter repositories, test cases and deployment scripts, so nothing in the practical work depends on a trainer being online.

Assessment is by project evidence rather than by quiz score. You finish with four working builds and the documentation that goes with them, which is the thing an employer can actually look at.

What this is, stated plainly.

  • This is a Durga Analytics programme and what you finish with is a Durga Analytics record of completion, backed by the assessments and the four projects. What it attests to is the work itself, which is the thing an employer can look at.
  • It is vendor-neutral. It teaches the engineering and the delivery craft rather than one platform's product, and it is built to make you capable of the work rather than to get you through anything.
  • This programme is newly built. We are not claiming delivered cohorts or a client list for it, and we would rather start with a short foundation and discovery pilot so the depth can be checked against your own engineers before anyone commits to the full pathway.

Talk to us about running this

Tell us your learners' current technical level, the responsibilities they need to take on, and your stack. That decides how much of the pathway you actually need.