Software developers
Extend your API and application skills into AI systems, customer discovery and delivery.
BANGALORE · CLASSROOM & LIVE ONLINE
Forward Deployed Engineer Course in Bangalore
Learn to turn a customer’s AI idea into a working application. Build the skills to understand the problem, connect the systems and deliver a solution people can use.
Physical classes in BengaluruLive online classesWeekday and weekend batches
PHYSICAL CLASSES IN BENGALURU
Learn in person at BuildAI Careers.
Choose in-person or live online FDE classes in Bengaluru. In-person batches are held at our address below.
BuildAI Careers#52, Vakil Whispering Woods
Marsur, Anekal Taluk
Bengaluru – 562106
Karnataka, India
Students from Electronic City, HSR Layout, Bommasandra, Chandapura and across Bengaluru are welcome to walk in to our facility for in-person FDE batches.
Ask About Classroom Batches ↗Your FDE mentor: Gaurav S.
Get feedback on your code, architecture and technical communication as you work through the programme.
See the work before you enrol.
Watch the teaching demo on this page, explore the full curriculum and review the linked portfolio project and project acceptance exercise.
- One enterprise AI delivery project
- Five review gates from architecture to live defence
- Code, architecture and communication feedback
Use your introductory call to discuss your experience, the selected labs and what you will build.
WATCH THE VIDEO · 2 MINUTES
FDE training at BuildAI Careers
YOUR STARTING POINT
Bring the skills you already have.
An FDE works close to a customer’s users and systems. The role combines hands-on engineering with clear communication and responsibility for delivery.
Data, cloud and QA professionals
Build on your experience with data, infrastructure or testing as you learn the complete workflow.
Technical consultants
Strengthen the engineering behind your solution design, demos and customer conversations.
Newer to programming? Start by discussing your Python, Git, SQL and API foundations with a course advisor.
A CONNECTED LEARNING PATH
Your complete learning path.
Explore eight stages and 34 detailed modules. Start with the foundations you need, build the core delivery skills, then choose advanced labs around your project.
Customer discovery and engineering
Turn a customer problem into a clear brief. Build the software foundations to deliver it.
FDE practice and customer discovery
Turn an unclear request to reduce support workload into a bounded engagement. Practise interviewing a business owner and an operator separately, then reconcile their different definitions of success.
What you will learn
- Map users, stakeholders, decisions and the current workflow. Identify the person who accepts the finished work.
- Separate the business problem from a requested tool. Compare an AI approach with rules, search and ordinary automation.
- Define scope, exclusions, dependencies, access needs, acceptance criteria and a measurable baseline.
- Create a current state process map, stakeholder map and responsibility matrix. Record decision rights, access dependencies and escalation owners.
- Prioritise use cases by task volume, error cost, feasibility, data readiness and operational risk. Estimate the baseline before promising an improvement.
- Write an agreed scope, assumptions log and acceptance test. Revisit the scope when the customer changes a requirement during the exercise.
Practical exercise
A customer asks for an autonomous support agent but cannot grant write access to the service desk. Conduct discovery, propose a useful first release and explain the change in scope.
What you will produce
Interview notes, workflow map, prioritised use cases, project charter and acceptance criteria.
How you check the work
A reviewer can trace each proposed feature to a user need, name the acceptance owner and identify what is outside the first release.
Engineering readiness and systems fundamentals
Build the everyday engineering habits needed to work in a customer environment. Learn how code, processes, networks and data fit together before debugging an AI system.
What you will learn
- Use a terminal, environment variables, virtual environments and package managers. Navigate files, inspect logs and understand process exit codes.
- Understand Linux processes, permissions, ports, DNS, HTTP, TLS and client server communication. Trace a request from the browser to a backend and database.
- Use Git clone, branch, commit, merge and pull request workflows. Keep credentials out of history and understand the difference between configuration and secrets.
- Practise JSON, CSV, text encodings and structured configuration. Diagnose file paths, time zones and inconsistent date or number formats.
- Decompose a task, estimate complexity and write a minimal reproducible example. Compare local development, a test environment and a shared deployment.
- Run a readiness exercise in Python, SQL and API use. Use the results to choose the foundation work to complete before advanced labs.
Practical exercise
A service works on one laptop but fails on another. Investigate the dependency, configuration, file path and port assumptions. Write a setup guide that removes the ambiguity.
What you will produce
Readiness record, environment setup, troubleshooting notes, Git exercise and reproducible request.
How you check the work
Another learner can reproduce the environment and follow the request across the application without copying secrets or relying on an undocumented local setting.
Production Python and collaborative development
Develop a maintainable service that another engineer can extend. Practise the code review and debugging habits needed when an application moves beyond a personal notebook.
What you will learn
- Write modular Python with types, validation, exceptions, configuration and structured logs. Use asynchronous I O where it improves the application.
- Manage dependencies, virtual environments, tests, formatting and Git branches. Review a pull request and resolve a merge conflict.
- Use AI coding assistants to draft and debug code, then inspect changes, test behaviour and check dependency and licence risks.
- Use functions, classes, iterators, context managers, type annotations and dependency injection where they clarify responsibility.
- Compare synchronous and asynchronous calls, concurrency limits, connection pooling, cancellation and resource cleanup.
- Add pytest fixtures, mocks, integration tests, linting, packaging and dependency pinning. Review generated code and investigate an unfamiliar failure before changing it.
Practical exercise
A document processing service occasionally hangs when a remote API is slow. Reproduce the issue, add a timeout and concurrency limit, and demonstrate cleanup after cancellation.
What you will produce
Repository, dependency lock file, pull request, automated tests and debugging note.
How you check the work
A fresh checkout runs successfully; tests expose the original failure; the reviewer can explain why the patch fixes it.
APIs and application backends
Build services with clear contracts so user interfaces, agents and customer systems can depend on them. Make error handling part of the contract.
What you will learn
- Design HTTP and REST endpoints with FastAPI, typed request models and OpenAPI documentation.
- Add authentication, pagination, uploads, validation and useful errors. Handle timeouts, rate limits, retries and repeated requests safely.
- Compare REST, gRPC, WebSockets and background jobs. Practise an event or webhook where the workflow needs one.
- Design resources, response codes, versioned schemas, pagination and validation. Document breaking changes and backward compatibility.
- Implement API keys or token based authentication, role checks, file size limits, rate limits and correlation identifiers.
- Use idempotency keys for writes, bounded retries with backoff and background jobs for long tasks. Compare REST, gRPC and streaming interfaces using the same use case.
Practical exercise
A client retries a timed out purchase request. Prevent a duplicate order, return the original result and prove the outcome with concurrent integration tests.
What you will produce
OpenAPI contract, request examples, authentication tests and duplicate request test.
How you check the work
Malformed, unauthorised and repeated requests have documented responses; timeouts do not leave an ambiguous business action.
Data and AI foundations
Work confidently with business records, document pipelines and model results.
SQL and enterprise data
Make business data trustworthy before adding AI. Learn how records, relationships and transactions shape the application a customer can safely use.
What you will learn
- Use joins, aggregations, window functions, transactions and indexes. Read an execution plan and investigate a slow query.
- Model business entities and relationships in PostgreSQL. Compare relational, document and vector storage.
- Practise schema mapping, migrations, reconciliation and read only access to a legacy style data source.
- Practise joins, grouping, subqueries, common table expressions and window functions. Compare query plans and useful indexes.
- Apply keys, constraints, transactions and isolation. Design schema changes and examine the consequences of concurrent updates.
- Compare PostgreSQL with document storage, legacy SQL Server or Oracle style interfaces and vector extensions. Define source to target mapping and reconciliation rules.
Practical exercise
Migrate a synthetic customer and order dataset with missing references, duplicate identifiers and partial failures. Reconcile the result and rerun without creating duplicates.
What you will produce
Entity diagram, schema, migration scripts, query review and exception report.
How you check the work
Relationships and totals reconcile; exceptions are visible; a failed migration can resume or roll back using a documented procedure.
Data pipelines and document preparation
Prepare reproducible information flows for AI systems. Work with the messy documents and changing records that make production ingestion harder than a single file upload.
What you will learn
- Build extract, transform and load workflows with batch processing and a streaming example. Compare Airflow, dbt and queue based approaches.
- Parse PDFs, tables and scanned documents using text extraction and optical character recognition. Preserve source locations and metadata.
- Track data quality, lineage, incremental updates and deletion. Handle malformed records and recover interrupted processing.
- Compare ETL and ELT, batch schedules and event driven updates. Use an Airflow style workflow, dbt transformation or queue when it fits the dependency pattern.
- Extract text, tables and layout from PDFs and scans. Assess OCR errors, duplicate pages, encoding, document versions and source provenance.
- Define freshness and quality checks, dead letter handling, lineage, checkpointing and deletion propagation. Compare an event log with a Kafka example and a simpler job queue.
Practical exercise
A policy document is corrected and one restricted attachment is deleted. Update the index, preserve the new source version and prove the old content is no longer retrievable.
What you will produce
Pipeline definition, document manifest, quality checks, lineage view and recovery demonstration.
How you check the work
The pipeline is repeatable, partial errors are recoverable and changed access or deletion is reflected in downstream data.
Statistical reasoning and business measurement
Interpret model results and business measurements carefully. Learn how sample choice, error costs and uncertainty affect a delivery decision.
What you will learn
- Use averages, medians, percentiles and distributions to describe a dataset. Compare a mean response time with tail latency and explain why both matter.
- Understand sampling, selection bias, missing data, class imbalance and data leakage. Distinguish association from a causal improvement.
- Read a confusion matrix and calculate precision, recall, false positives and false negatives. Choose a metric from the operational consequences of an error.
- Use confidence intervals and a bootstrap exercise to express sampling uncertainty. Separate measurement uncertainty from assumptions about future adoption.
- Design an A B comparison or staged pilot with a stable baseline and consistent task definition. Consider reviewer disagreement and changes in traffic mix.
- Calculate task level cost, review effort, throughput and an illustrative return on investment. Vary adoption and error assumptions instead of reporting one unexplained number.
Practical exercise
A pilot appears faster but receives easier requests than the baseline. Rework the comparison, report task mix and error costs, and explain what the evidence does and does not establish.
What you will produce
Measurement plan, worked metric sheet, sampling note, comparison results and sensitivity table.
How you check the work
The measurement matches the user task, the sample and assumptions are visible, and the conclusion does not confuse a selected pilot result with a universal improvement.
Machine learning and language model foundations
Choose the right type of model for a business task and understand its limits. Build enough conceptual depth to question results rather than treating a model as a black box.
What you will learn
- Compare rules, supervised learning, clustering and language models. Practise classification, regression, feature preparation and validation.
- Understand neural networks, attention, transformers, tokens, context windows and embeddings at application level.
- Use a pretrained model and a small scikit learn baseline. Track experiments, model versions and the effect of data leakage.
- Practise classification, regression and clustering; understand reinforcement learning conceptually. Compare model performance with a simple rule based baseline.
- Prepare features, avoid train and test leakage, use cross validation and inspect class imbalance, precision, recall and calibration.
- Explain neural networks, activations, backpropagation, tokenisation, embeddings, attention and transformers. Use pretrained Hugging Face components and record model versions and licences.
Practical exercise
Compare a rule, a small classifier and a language model for routing synthetic support tickets. Inspect difficult examples and evaluate all approaches on the same held out records.
What you will produce
Baseline, feature and data notes, experiment record, confusion matrix and model choice.
How you check the work
The chosen method suits the task; leakage is excluded; the explanation distinguishes an observed result from a general claim.
Language models and knowledge systems
Build answers that use the right information and show their sources.
Prompts and controlled model responses
Turn a model call into a predictable application component. Learn to manage context, instructions, outputs and failure cases without tying the system to a single provider.
What you will learn
- Call hosted model APIs directly before adding frameworks. Manage credentials, streaming responses, token usage and provider errors.
- Write clear instructions, examples and context. Validate structured JSON outputs against a schema and version prompts alongside code.
- Compare models on the same task. Record useful decision summaries and tool activity without requiring private model reasoning.
- Compare direct APIs from selected hosted providers and an open model. Control token budgets, sampling, streaming, provider errors and response validation.
- Practise zero shot and few shot instructions, prompt chaining, routing and context selection. Separate trusted instructions from untrusted retrieved content.
- Version prompt templates and structured schemas, build regression cases and compare manual prompt changes with an optimisation exercise using DSPy or a similar approach.
Practical exercise
Extract invoice fields from mixed sample inputs. Reject invalid JSON, handle absent fields, compare two models and test the same prompt against an injected instruction in a document.
What you will produce
Prompt registry, typed output schema, comparison dataset, cost table and failure handling tests.
How you check the work
Outputs pass schema and business validation, missing evidence is handled explicitly and each release has a reproducible prompt and model configuration.
Retrieval augmented generation
Build a document answering system whose retrieval and answer generation can be inspected separately. Treat source quality and permissions as part of the architecture.
What you will learn
- Build RAG, which retrieves relevant information before a model answers. Connect parsing, chunking, embeddings, storage and generation.
- Use metadata filters, hybrid keyword and semantic search, reranking and query rewriting. Compare chunk sizes with an evaluation set.
- Return source references, handle conflicting or missing evidence and apply document permissions before retrieval.
- Compare character, token, recursive and structure aware chunking. Preserve source pages, timestamps, document identifiers and access metadata.
- Use embeddings, similarity search, metadata filters and hybrid keyword retrieval. Compare local FAISS or Chroma with pgvector, Qdrant or a managed vector store.
- Measure retrieval recall and relevance, citation correctness and answer support. Add abstention for missing evidence, conversation context handling and incremental reindexing.
Practical exercise
Answer questions over policies with duplicate sections, conflicting dates and restricted documents. Investigate whether a bad answer came from parsing, retrieval or generation.
What you will produce
Ingestion and retrieval code, source manifest, citation viewer, test questions and error analysis.
How you check the work
Answers point to the supporting passage, permission filters are enforced before generation and unsupported questions take a defined fallback path.
Advanced retrieval and knowledge graphs
Improve retrieval by testing specific failure modes. Compare advanced approaches against a simple, well measured baseline before adding complexity.
What you will learn
- Compare dense search with BM25 keyword retrieval, hybrid fusion and cross encoder reranking. Use maximal marginal relevance to balance relevance and diversity.
- Explore multi query retrieval, query decomposition and HyDE, which uses a generated example to help retrieve relevant passages. Test whether each approach helps the same reviewed questions.
- Compare corrective RAG, which checks retrieved evidence and retries, with self reviewing answer workflows. Set limits so correction cannot loop indefinitely.
- Build parent child and hierarchical retrieval for long documents, metadata aware filters and structured table retrieval. Check citation integrity after passage transformations.
- Explore GraphRAG using entities, relationships, a small ontology and source provenance. Compare graph traversal with joins and ordinary retrieval on connected questions.
- Create an ablation report that isolates each change. Measure retrieval recall, answer support, latency, storage and cost together.
Practical exercise
A document assistant misses questions that combine two policy sections. Compare query decomposition, reranking and a small knowledge graph. Keep the simplest approach that meets the acceptance criteria.
What you will produce
Baseline and advanced pipelines, graph schema, query set, ablation report and cost comparison.
How you check the work
Every advanced component has measured value on the task, respects source permissions and preserves a traceable source for the final answer.
Advanced knowledge and user experience
Connect useful information to a usable interface. Explore graph based knowledge where relationships matter, then show users the evidence behind a result.
What you will learn
- Compare knowledge graphs, ontologies and ordinary search for connected business information. Trace answers back to source records.
- Build a simple Streamlit or Gradio interface; explore React or Next.js when a richer interface is needed.
- Design uploads, streaming, source previews, feedback, loading states and recovery. Provide clear keyboard navigation and readable results.
- Define entities, relationships, ontologies and provenance. Compare a graph query, a relational join and semantic retrieval for a connected business question.
- Build a Streamlit or Gradio interface and connect it to the backend. Include source previews, feedback capture, session state and upload status.
- Design readable errors, keyboard access, cancellation, loading states and recovery. Use a small usability task to discover where users misunderstand an AI response.
Practical exercise
Build an account support view that joins customer, product and incident information. Let a reviewer inspect the source records and correct a mistaken relationship.
What you will produce
Knowledge model, small graph extension, working interface and usability findings.
How you check the work
A user can trace an answer to records, identify a failed step and recover without submitting the same action unintentionally.
Workflow automation and agents
Connect tools, control actions and recover when a workflow is interrupted.
Visual prototyping and workflow automation
Test a workflow quickly before committing to custom engineering. Use visual tools to explore the user journey, then inspect the integration and security details behind the diagram.
What you will learn
- Build a small visual flow with a tool such as n8n, Langflow or an equivalent platform. Connect a trigger, data transformation, model step and approval.
- Work with webhook contracts, credential storage, retries and error branches. Separate the convenience of a builder from the guarantees of the connected service.
- Compare a visual RAG or agent prototype with a direct Python implementation. Identify where debugging, version control or custom access rules favour code.
- Practise human review, notification routing and task status tracking with synthetic data. Avoid sending real messages or changing business systems during test runs.
- Export configuration where supported, document versions and review platform licensing and hosting needs.
- Define the point at which a prototype needs custom APIs, tests, observability, deployment ownership and a migration plan.
Practical exercise
Prototype a request intake and approval workflow visually. Add a failing external step and a duplicate webhook, then design the code based implementation needed for a controlled rollout.
What you will produce
Workflow export or diagram, integration contracts, failure demonstration and prototype to service plan.
How you check the work
The learner can explain how each step executes, where credentials live and which controls need strengthening before a real customer uses it.
Tool using agents and controlled workflows
Build an agent that performs a bounded task with explicit tools. Control execution in application code and make the approval boundary visible to the user.
What you will learn
- Design a single agent with explicit tools, typed arguments, state and a bounded execution loop.
- Separate planning from actions. Add permissions, approval steps, budgets, cancellation and limits on repeated tool calls.
- Manage short term state and persistent memory. Test stale context, a failed tool and an interrupted session.
- Compare a deterministic workflow, a single agent and a planner executor pattern. Define typed tools, termination conditions and the permitted action space.
- Manage task state, short term context and persistent memory with retention rules. Add approval checkpoints, time limits and cost limits.
- Handle timeouts, invalid tool arguments, repeated actions, stale state and interrupted sessions. Record observable tool activity and concise decision summaries.
Practical exercise
Create a service desk assistant that classifies a ticket and prepares an update. Require approval for the update and recover safely if the application restarts after approval.
What you will produce
State model, tool definitions, permission rules, execution trace and interruption tests.
How you check the work
The system stops at its limits, preserves the approval boundary and does not duplicate an external action after restart.
Agent orchestration and interoperability
Use orchestration when a workflow needs explicit state, branching and coordination. Make each additional agent earn its place through a measurable improvement.
What you will learn
- Use LangGraph for explicit workflow state and compare multi agent patterns through selected CrewAI or AutoGen exercises.
- Build a Model Context Protocol or MCP connection to expose a tool with authentication, validated inputs and limited permissions.
- Explore Agent to Agent or A2A communication, delegation, handoffs and message contracts. Compare complexity against a simpler workflow.
- Implement LangGraph nodes, edges, checkpoints, conditional routes and resumable execution. Compare a graph with plain Python control flow.
- Explore CrewAI and AutoGen examples for specialised roles, delegation, shared information and parallel tasks. Design handoff contracts and conflict resolution.
- Compare agent communication patterns including A2A, durable queues and direct calls. Bound fan out, prevent recursive delegation and test partial completion.
Practical exercise
Build a research and review workflow with independent source collection and a final check. Compare it with a single agent on the same reviewed task set.
What you will produce
Workflow graph, agent contracts, state recovery test and comparison report.
How you check the work
Every handoff is inspectable, failed branches have a recovery path and the design explains whether multi agent complexity improved the result.
MCP servers and agent tool contracts
Build a narrowly scoped tool connection that can be inspected and tested independently of the agent. Understand what the protocol supplies and what the application still has to enforce.
What you will learn
- Distinguish the MCP host, client and server. Examine tools, resources and prompts through a small server and client exercise.
- Define input schemas, output contracts and useful error responses. Compare local process and remote HTTP deployment patterns conceptually and in a selected lab.
- Implement authentication, user context, permission checks and allowed operations at the server. Limit access to credentials, files and network destinations.
- Test untrusted tool descriptions, unexpected argument values, excessive output and malicious retrieved content. Apply timeouts, audit identifiers and execution limits.
- Handle reconnects, cancellation, version changes and repeated actions. Require confirmation for consequential writes and ensure a retry cannot repeat a completed action.
- Compare an MCP integration with an ordinary API wrapper. Choose the simpler option when interoperability does not add useful value.
Practical exercise
Expose a read only inventory lookup and a separately approved reservation action. Attempt an unauthorised reservation, retry a completed request and inspect the audit record.
What you will produce
MCP server, tool schemas, client demonstration, access tests and deployment or local execution guide.
How you check the work
The server enforces identity and allowed operations, errors are usable and external actions remain safe even if an agent supplies inappropriate arguments.
Integrations evaluation and security
Integrate business systems, check quality and protect access to data.
Business systems and enterprise connectors
Connect AI applications to the systems where work happens. Design connectors around identity, data contracts and recovery rather than a successful one off API call.
What you will learn
- Connect to a CRM, ERP, service desk or simulated enterprise API. Map fields and handle pagination, webhooks and API version changes.
- Implement least privilege access, secrets management and audit events. Recognise OAuth, OpenID Connect, SSO and SAML integration patterns.
- Compare synchronous calls, queues and event streaming with a Kafka example. Isolate tenants and reconcile records after failures.
- Map CRM, ERP and service desk objects, validate source fields and plan schema evolution. Compare polling, webhooks and event subscriptions.
- Implement scoped credentials and secret rotation patterns. Explain OAuth, OpenID Connect, SSO and SAML responsibilities and where the identity provider fits.
- Reconcile records after retries and outages, enforce tenant boundaries and log external changes. Include an integration ownership and support plan.
Practical exercise
Synchronise a simulated CRM contact update with a support record while the remote service intermittently fails. Reconcile the final state without leaking another tenant’s records.
What you will produce
System landscape, mapping specification, connector tests, audit trail and reconciliation report.
How you check the work
External writes are authorised, duplicate events are safe and the team can determine the final state after an outage.
Safe SQL and analytics assistants
Connect natural language questions to business data without giving a model unrestricted database access. Preserve both data security and the meaning of the numbers.
What you will learn
- Define a semantic layer for measures, time windows and entity names. Provide approved schemas and examples without exposing unnecessary records.
- Generate parameterised or validated queries against a read only role. Restrict tables, columns, row scope, execution time and result size.
- Inspect query structure before execution, handle invalid syntax and use a bounded correction loop. Separate analytical reads from business transactions.
- Test ambiguity in revenue definitions, currency, time zones, cancelled records and duplicate joins. Require clarification when the business meaning is unclear.
- Return the executed query or an appropriate explanation, source date and supporting table or chart. Check calculated totals against a trusted query.
- Protect against prompt injection, schema extraction and cross tenant questions. Record query activity without logging sensitive result data unnecessarily.
Practical exercise
Build a sales operations assistant over synthetic records. Ask an ambiguous monthly revenue question, attempt a forbidden table read and compare the final totals with reviewed SQL.
What you will produce
Schema and metric glossary, query validation rules, reviewed questions, reconciliation and access tests.
How you check the work
Queries stay inside the approved read boundary, totals reconcile and the assistant does not invent a business definition when the question needs clarification.
Evaluation and experiment design
Measure whether an AI application works for its intended users. Build a repeatable release decision that combines automated evaluation with informed human review.
What you will learn
- Create a reviewed test set covering normal use, ambiguity, missing information and difficult cases. Separate development and final checks.
- Measure retrieval, grounded answers, task completion and tool correctness. Use RAGAS or DeepEval where the metric fits.
- Calibrate model based judging against human review. Run regression comparisons and report uncertainty when the sample is small.
- Construct development, regression and held out sets with representative, difficult and adversarial cases. Track dataset versions and reviewer disagreements.
- Evaluate retrieval, grounding, task completion, structured outputs and tool correctness. Use RAGAS, DeepEval or a custom evaluator according to the task.
- Calibrate model based judges, inspect scoring bias, compare against human review and report sample uncertainty. Run prompt, retrieval and model ablations to identify what caused a change.
Practical exercise
A model upgrade improves fluent answers but introduces unsupported citations. Compare versions on the same cases and decide whether to release, revise or roll back.
What you will produce
Evaluation protocol, reviewed dataset, score breakdown, failure examples and release recommendation.
How you check the work
The release decision follows stated acceptance criteria and includes important regressions even when the aggregate score improves.
Application and AI security
Protect data and actions across the entire application. Treat model instructions as one component of a wider security design.
What you will learn
- Model threats across users, documents, prompts, tools and connected services. Test direct and document based prompt injection.
- Apply role based access, tenant isolation, output validation, safe SQL execution, secret scanning and dependency checks.
- Redact sensitive fields, prevent data leakage and protect action tools with approval and server side controls. Test the controls adversarially.
- Draw trust boundaries for users, retrieved documents, models, tools and services. Use OWASP style threat categories to organise tests.
- Test prompt injection, unsafe output handling, data exfiltration, excessive permissions, secret leakage and dependency risks. Validate at server side action boundaries.
- Implement authentication, role based access, tenant isolation, safe SQL patterns, content limits, redaction and audit events. Compare guardrail libraries with ordinary validation and access controls.
Practical exercise
Place malicious instructions in a retrieved document and attempt cross tenant access through an agent tool. Patch the application boundary and rerun the attack cases.
What you will produce
Threat model, attack test set, security findings, remediation pull request and retest record.
How you check the work
Unauthorised reads and writes are blocked independently of model cooperation; logs support investigation without exposing secrets.
Governance deployment and operations
Deploy repeatably, investigate failures and manage operating cost.
Responsible AI and governance
Design accountable AI use in an organisation. Make ownership, data handling and human oversight concrete enough to support a deployment review.
What you will learn
- Create a risk register and document data ownership, retention, deletion, consent requirements and human oversight.
- Assess bias, accessibility, harmful outputs and appropriate use. Maintain model, dataset and prompt change records.
- Study how DPDP, the EU AI Act and sector requirements affect deployment decisions. Map controls to organisational review with NIST and OWASP examples.
- Prepare a data inventory, processing map, retention schedule and deletion procedure. Identify customer approvals and supplier dependencies.
- Assess fairness, accessibility, unsafe outputs and foreseeable misuse. Define who reviews consequential outputs and who can suspend a workflow.
- Study DPDP, EU AI Act and sector scenarios at an awareness level. Map NIST and organisational review requirements to evidence, owners and review dates.
Practical exercise
Prepare a governance review for a synthetic financial operations assistant. Trace personal data, define review ownership and show how a deletion request propagates.
What you will produce
Risk register, data flow, retention and deletion design, oversight plan and approval record template.
How you check the work
Material risks have accountable owners and testable controls; unresolved regulatory interpretation is escalated to the appropriate specialist.
Cloud deployment and infrastructure
Deploy an application in a repeatable environment. Understand the trade offs between a managed service, containers and a private customer environment.
What you will learn
- Package applications with Docker, secure image builds and environment configuration. Deploy a service on one selected cloud.
- Compare AWS, Azure and Google Cloud patterns, managed AI services, private networks and on premises requirements.
- Practise a Kubernetes deployment with ingress, storage, health checks and scaling. Use Terraform for repeatable infrastructure and clean teardown.
- Build minimal and multi stage Docker images, pin dependencies, scan artefacts and manage secrets outside the image.
- Deploy on one selected platform and compare AWS Bedrock, Azure hosted AI and Google Cloud Vertex style architectures. Explain networking, IAM, storage and private endpoints.
- Practise Kubernetes manifests, ingress, persistent volumes, resource limits, health checks and autoscaling. Use Terraform plans, state handling and teardown for repeatable infrastructure.
Practical exercise
Move a local application to a protected cloud environment. Recreate it from configuration, rotate a secret and diagnose a failing health check.
What you will produce
Deployment diagram, container configuration, infrastructure code, environment guide and teardown procedure.
How you check the work
A fresh environment reproduces the application, exposed endpoints match the design and no credential is embedded in a repository or image.
Release engineering and model operations
Release AI changes with the same discipline as software changes. Track the code, data, model and prompt combination needed to reproduce a result.
What you will learn
- Build continuous integration and delivery with automated tests, security checks, versioned artefacts and release approval gates.
- Track model, prompt, dataset and configuration versions with tools such as MLflow. Compare staged, canary and blue green rollout.
- Design migrations, backups, restore checks and rollback. Detect a model or data change that affects the service after release.
- Build GitHub Actions or an equivalent pipeline with tests, dependency checks, image creation, evaluation gates and environment approvals.
- Version datasets, prompts, models and serving configuration. Explore MLflow or Weights and Biases for experiments and model records.
- Compare staging, canary and blue green deployment; test schema migrations, backup restoration and rollback. Define when quality changes require a release block.
Practical exercise
Release a prompt change that breaks a critical workflow. Make the evaluation gate catch it, then practise rollback and restore after a separate simulated data failure.
What you will produce
CI and delivery pipeline, artefact manifest, release notes, rollback record and restore check.
How you check the work
The team can identify the exact deployed combination and recover to an accepted state using a repeatable procedure.
Observability reliability and cost
Operate an AI service under latency, reliability and cost constraints. Follow a request across the full system and connect technical signals to a completed user task.
What you will learn
- Trace requests through retrieval, model calls and tools. Collect logs, metrics and traces with OpenTelemetry and selected monitoring tools.
- Define service level indicators and objectives. Investigate latency, errors, timeouts, drift and incorrect answers with Langfuse or a comparable tool.
- Measure cost per completed task and tail latency. Test caching, batching, routing, quotas, circuit breakers and fallbacks under load.
- Capture structured logs, metrics and traces with OpenTelemetry, Langfuse and selected Prometheus or Grafana views. Protect sensitive content in telemetry.
- Define service level indicators, objectives and error budgets. Investigate tail latency, tool failures, bad retrieval, model drift and service saturation.
- Measure cost per accepted task and compare caching, batching, routing, concurrency controls, circuit breakers and fallback models. Test quality before retaining an optimisation.
Practical exercise
A service becomes slower and more expensive after adding a tool. Use traces to identify the cause, test an optimisation and show both quality and cost before and after.
What you will produce
Dashboard, trace examples, load report, cost model, incident timeline and recovery runbook.
How you check the work
The reviewer can locate a failure, explain its business effect and demonstrate recovery without hiding a quality regression.
Advanced AI application engineering
Go deeper into model adaptation, private serving, multimodal input and interfaces.
Fine tuning and model adaptation
Adapt a model only when the task and evidence justify it. Understand the difference between teaching a response pattern and supplying changing business knowledge.
What you will learn
- Compare prompting, retrieval and fine tuning using a task baseline. Prepare a licensed dataset and separate training and evaluation records.
- Explore supervised fine tuning, LoRA and QLoRA on a suitable small model. Understand adapters, overfitting, distillation and preference optimisation.
- Track experiments, evaluate quality and cost, and define rollback criteria. Treat training a foundation model from scratch as a conceptual topic.
- Compare prompting, retrieval, supervised fine tuning and distillation using the same baseline and held out task set.
- Prepare licensed data, remove leakage and duplicates, choose examples and track provenance. Explore LoRA and QLoRA adapters, PEFT style workflows and training configuration.
- Inspect overfitting, memorisation and distribution shift. Understand preference optimisation and reinforcement learning conceptually; compare adapter serving, rollback and total operating cost.
Practical exercise
Adapt a small open model for a synthetic support classification or response format task. Compare it with a prompt only baseline and retain the adaptation only if the evidence supports it.
What you will produce
Dataset record, experiment configuration, adapter or reproducible run plan, evaluation and cost comparison.
How you check the work
The test set is independent, licences and provenance are recorded and the benefit is stated for the measured task rather than all tasks.
Private serving and performance
Understand private inference from a developer laptop to a hosted serving endpoint. Choose model size and serving architecture from the workload and available resources.
What you will learn
- Run an open weight model locally with Ollama and examine a vLLM serving setup where suitable hardware is available.
- Understand quantisation, GPU memory, concurrency, batching and capacity. Compare hosted APIs, private cloud and local inference.
- Check model licences, artefact provenance, network boundaries and operational costs. Plan graceful degradation when capacity is exhausted.
- Use Ollama for local inference and inspect vLLM serving where hardware allows. Compare model formats, quantisation, context length and GPU memory needs.
- Measure prefill and generation behaviour, concurrency, batching, cache usage and throughput. Include tail latency and an out of memory case.
- Compare hosted APIs, private VPC deployment, on premises and constrained local environments. Check licences, artefact provenance, storage, network egress and update ownership.
Practical exercise
Serve a suitable small model locally, run a documented workload and compare the observed behaviour with a hosted alternative. Design a capacity limit and graceful fallback.
What you will produce
Serving configuration, hardware and model record, benchmark workload, capacity estimate and privacy boundary diagram.
How you check the work
Performance claims identify the exact workload and hardware, and the design explains what happens when capacity or connectivity is exhausted.
Multimodal and industry systems
Build beyond text chat while preserving task specific quality checks. Use industry knowledge to define the right input, output and review process.
What you will learn
- Combine text, images or speech in a controlled workflow. Practise OCR, transcription, document extraction and multilingual evaluation.
- Explore financial operations, manufacturing inspection, telecom support, healthcare administration and retail workflows using appropriate sample data.
- Compare an agent solution with deterministic automation or a computer vision model. Include a domain reviewer and an explicit escalation path.
- Combine OCR, image understanding, speech transcription and text extraction. Handle layout, noisy scans, accents, language variation and low quality input.
- Explore manufacturing inspection, telecom incidents, financial operations, retail and healthcare administration with synthetic or approved data.
- Compare computer vision, deterministic automation, retrieval and agent solutions. Define domain acceptance criteria, data access controls and escalation for consequential outputs.
Practical exercise
Build a multilingual document or inspection workflow. Evaluate difficult inputs separately and let a domain reviewer correct and escalate uncertain results.
What you will produce
Industry brief, modality pipeline, reviewed sample set, error breakdown and human review interface.
How you check the work
Each modality has a quality check and the application handles uncertainty without silently converting a weak input into a confident action.
Full stack AI application engineering
Build the user facing application around the AI workflow. Give users a reliable way to submit work, inspect progress, review evidence and recover from errors.
What you will learn
- Use HTML, CSS, JavaScript and TypeScript fundamentals. Build a React or Next.js interface with components, state, forms and accessible controls.
- Connect the interface to a typed API. Handle authentication state, server side authorisation, validation, file upload limits and cross origin settings.
- Render streaming responses, source references and job status. Support cancellation, reconnects and resumable tasks without creating duplicate submissions.
- Create feedback, approval and exception review screens. Design loading, empty, partial success and unavailable service states.
- Add frontend component tests and browser journeys for key tasks. Test keyboard operation, small screens and network failures.
- Package and deploy the frontend with its backend. Manage environment configuration, asset delivery and a documented compatibility contract.
Practical exercise
Turn a document assistant into a small product with upload progress, source previews, approval and job history. Disconnect the network mid task and demonstrate recovery.
What you will produce
Frontend repository, API contract, accessible user journeys, browser test record and deployed demonstration.
How you check the work
A user can finish the main task on a small screen, inspect evidence, recover from failure and understand whether an action has completed.
Architecture customer delivery and careers
Design for scale, manage customer delivery and explain your work clearly.
Distributed systems and scaling design
Practise the architecture questions that arise when a small application becomes a shared customer service. Reason from workload, failure tolerance and operating cost.
What you will learn
- Estimate requests, concurrency, storage, model throughput and network use. Define a load profile and distinguish average use from a peak.
- Compare load balancing, reverse proxies, API gateways and content delivery networks. Explain routing, timeouts and service discovery.
- Design caches with expiration and invalidation, queues with retries and dead letter handling, and storage with partitioning and replication.
- Understand consistency, availability and partition trade offs, transactional boundaries and eventual consistency. Compare a distributed transaction with a compensating workflow.
- Explore event driven design, bulkheads, circuit breakers and backpressure. Distinguish a durable job from a synchronous request.
- Review a design against security, tenancy, cost and recovery constraints. Add capacity limits, degraded operation and a migration path as usage grows.
Practical exercise
Design a document processing service that must absorb a sudden upload spike while serving interactive questions. Estimate capacity, isolate background work and demonstrate a queue based failure recovery.
What you will produce
Capacity worksheet, component and sequence diagrams, failure analysis, scaling plan and load experiment.
How you check the work
The design identifies bottlenecks, makes consistency and availability choices explicit and describes what users experience during overload or a dependency failure.
Solution architecture and commercial judgement
Design a solution that can be delivered and funded. Connect architecture choices to the customer’s constraints and the evidence required for the next investment decision.
What you will learn
- Create architecture diagrams, decision records, data contracts and a delivery estimate. Explain dependencies, assumptions and trade offs.
- Compare build, buy and configure options. Distinguish a proof of concept, a pilot and an operational service.
- Build a cost and value model with a baseline, review effort and adoption assumptions. Test how the result changes when assumptions change.
- Create product requirements, architecture and sequence diagrams, decision records and data contracts. Compare build, buy and configuration options.
- Estimate effort, dependencies, infrastructure cost and support work. Separate a proof of concept, pilot and operational service with explicit exit criteria.
- Model benefits using task volumes, baseline effort, review costs, adoption and error rates. Run sensitivity checks and separate observed outcomes from assumptions.
Practical exercise
A customer wants a low cost pilot with a path to private deployment. Propose staged options, explain trade offs and defend a recommendation to both engineering and business reviewers.
What you will produce
Requirements brief, solution blueprint, option comparison, delivery estimate, business case and risk log.
How you check the work
The plan names its assumptions and dependencies, makes a testable next decision and does not treat a successful demo as established business value.
Customer delivery adoption and handover
Manage the work around the software. Keep users, engineering, security and operations aligned as requirements change and the system moves into everyday use.
What you will learn
- Run discovery and demonstration sessions, prioritise feedback and manage scope changes with a decision log.
- Plan user acceptance testing, staged rollout, user training and support ownership. Measure retained use and completed tasks after launch.
- Lead a simulated incident conversation, write a clear update and hand over a runbook. Turn repeated customer needs into reusable product feedback.
- Run discovery workshops, demonstrations and feedback reviews. Maintain a prioritised backlog, decision log and change request process.
- Plan user acceptance testing, rollout groups, training, support ownership and escalation. Measure retained use, task completion and review effort.
- Practise incident communication, post incident review and handover. Write a runbook another operator can follow and establish a process for improvements after launch.
Practical exercise
A stakeholder changes the workflow midway through a pilot and a tool outage occurs before the final demo. Replan the scope, communicate the incident and deliver a credible operating handover.
What you will produce
Demo plan, change log, acceptance record, adoption measures, user guide and runbook.
How you check the work
The customer understands the release boundary and unresolved issues; another operator can perform the key recovery task from the handover.
Field engineering and reusable product work
Turn customer learning into stronger delivery and reusable software. Manage the boundary between a useful customer adaptation and a change that belongs in the shared product.
What you will learn
- Record patterns across engagements and separate one customer’s preference from a recurring product need. Explain the evidence behind a feature request.
- Compare configuration, a maintained extension, a product change and a temporary workaround. Assess upgrade, security and support implications.
- Define ownership for customer specific connectors, deployment templates and domain components. Document version compatibility and deprecation paths.
- Create a playbook with discovery questions, data contracts, acceptance cases and operating checks for a repeatable sector workflow.
- Plan a transition from initial delivery to the support or product team. Include known issues, escalation rules and criteria for retiring custom code.
- Practise a product feedback review with engineering and a customer update with a business sponsor. Use completed tasks, retained use and support evidence to prioritise changes.
Practical exercise
Two simulated customers request similar integrations with conflicting requirements. Propose the reusable core, isolate customer configuration and present a maintainable product roadmap.
What you will produce
Field feedback brief, reusable component design, ownership matrix, sector playbook and transition plan.
How you check the work
The design avoids copying an unsupported custom branch for every customer and explains who maintains the system after the initial engineer leaves.
Data structures algorithms and technical problem solving
Strengthen the coding skills needed to reason about application behaviour and prepare for role specific technical interviews. Connect algorithm choices to realistic engineering tasks.
What you will learn
- Analyse time and space complexity. Practise arrays, strings, hash maps, sets, linked lists, stacks and queues.
- Use sorting, binary search, two pointers, sliding windows and prefix sums. Explain invariants and test edge cases.
- Traverse trees and graphs with breadth first and depth first search. Use heaps for ranked work and a trie for prefix matching where appropriate.
- Explore recursion, backtracking and selected dynamic programming patterns. Compare a correct simple solution with a more efficient alternative.
- Apply these structures to duplicate detection, top results, dependency ordering, bounded work queues and an LRU style cache.
- Practise explaining a solution, testing it and responding to changed constraints. Choose interview topics from the target role rather than memorising disconnected answers.
Practical exercise
Implement a bounded task scheduler and a small cache, then solve a record reconciliation problem. Explain complexity, add edge case tests and revise the implementation when memory is limited.
What you will produce
Worked code, complexity notes, edge case tests and a recorded or written technical walkthrough.
How you check the work
The solution is correct, the complexity explanation matches the code and tests cover empty input, duplicates, boundaries and an appropriate stress case.
Portfolio and interview practice
Make your engineering work easy to inspect and discuss. Prepare for the technical and customer conversations relevant to the role you want.
What you will learn
- Present the problem, your contribution, architecture, working code, evaluation and deployment evidence in a clear repository.
- Practise Python, SQL, debugging, system design and customer discovery discussions. Extend data structures and algorithms practice where a target role requires it.
- Prepare a project walkthrough, resume and technical explanation. Label simulated work accurately and protect customer information and credentials.
- Build a portfolio with problem context, personal contribution, architecture, setup, evaluation, deployment and operating evidence.
- Practise Python and SQL tasks, API design, debugging, AI system design, customer discovery and design trade off conversations.
- Study arrays, hash maps, stacks, queues, trees, graphs, complexity and selected interview patterns where required. Prepare a resume and a concise project explanation with accurate ownership.
Practical exercise
Walk through your capstone, debug an injected failure and respond to a changed customer requirement. Explain the decision in both an engineering review and a short business update.
What you will produce
Portfolio case study, clean repository, recorded demo outline, resume and interview practice notes.
How you check the work
You can reproduce the work, explain a failure and a design choice, and distinguish simulated work, external components and your own contribution.
Prefer the complete curriculum?
Download Curriculum Keep the module details, exercises and project guide in one document.
LEARN THROUGH THE WORK
Build something you can explain.
Progress from small services to a complete application. Use public, synthetic or authorised data, and keep evidence of how each build behaves.
Business data service
Build an authenticated API and SQL database. Test imports, duplicates and recovery.
Document intelligence
Extract information from PDFs and scans, then return answers with source references.
Knowledge assistant
Compare retrieval approaches and measure answer quality, permissions and cost.
Controlled AI agent
Connect tools, add approval before changes and recover from a failed action.
SQL and analytics assistant
Answer business questions through validated, read-only queries.
Model engineering lab
Explore fine tuning or private serving with a recorded comparison.
Security and operations
Test an application, fix weaknesses and demonstrate rollback and recovery.
Full stack industry application
Bring the interface, AI workflow and review process together.
THE FINAL CAPSTONE
One complete customer engagement.
Choose an industry workflow. Run discovery, build the application, demonstrate the tests and deliver an operating guide. Defend your decisions in a technical and business presentation.
- Working code and a useful interface
- Evaluation and security evidence
- Deployment and recovery plan
- Customer demo and handover
CLASSROOM OR LIVE ONLINE
A route that fits your experience.
Join physical classes at our Bengaluru address or learn live online from home or work. Batches run Monday to Friday; confirm the timetable, format and selected labs before enrolling.
Get comfortable building
Strengthen Python, SQL, Git and APIs before moving into larger AI applications.
Connect the full workflow
Build retrieval, agents and integrations, then add testing, security and deployment.
Go deeper where it matters
Explore model adaptation, private serving, multimodal workflows or a richer frontend.
Review the work at every stage.
Each module includes an exercise, a practical output and an assessment check. Your portfolio brings together the brief, architecture, code, evaluation, deployment and handover.
BENGALURU AND THE ROLE
Understand the opportunity.
Our Bengaluru research explores the city’s enterprise AI delivery ecosystem and 2030 outlook. Use it alongside the course curriculum to understand the work you want to prepare for.
BEFORE YOU ENQUIRE
A few useful answers.
Are physical FDE classes available in Bangalore?
Yes. Physical classes are available at BuildAI Careers, #52, Vakil Whispering Woods, Marsur, Anekal Taluk, Bengaluru – 562106, Karnataka, India. Students in Bengaluru can choose in-person batches or live online FDE classes. You are welcome to walk in to our facility to ask about in-person batches.
What is the FDE course fee?
The Forward Deployed Engineer course fee is Rs 34,999, including GST, server access and limited API.
When does the next FDE batch start?
The next batch starts on 2 Nov and runs Monday to Friday, 9:00–10:30 AM. The following batch starts on 16 Nov and runs Monday to Friday, after 9:00 PM. Each batch is limited to 15 learners.
How long is the Forward Deployed Engineer course?
The course runs 12 weeks, with additional days if required, and includes 50 hours of live instruction plus hands-on exercises.
Who is eligible for FDE training?
You need hands-on technical experience and the basics of Python, Git, SQL and APIs. It is not designed for complete beginners.
Are weekday and weekend batches available?
Current FDE batches run Monday to Friday. The 2 Nov batch runs 9:00–10:30 AM. The 16 Nov batch runs after 9:00 PM.
Is placement assistance included?
Enrolled learners receive placement assistance, resume review and weekly interview preparation. This is assistance, not a job guarantee. Terms apply.
What will I build for my FDE portfolio?
You build one enterprise AI delivery project from start to finish: you diagnose a customer problem, build the data, RAG, agent and API workflow, make it safe and production-ready, operate it, and defend the deployment in a live technical review. You can look at a runnable portfolio project and the project acceptance exercise before you enrol.
How much feedback will I get?
You get direct, regular feedback. Every batch is capped at 15 learners, so your mentor reviews your code, architecture and communication personally, and each of the five stages ends with a review gate.
How can I assess the course before joining?
Explore the full curriculum, try the FDE practice exercises, and take the 4-minute readiness test. You can also request an introductory call to discuss your experience, the labs and what you will build.
What does an FDE do?
A Forward Deployed Engineer works with customers to turn a business problem into a working software or AI system. The work includes understanding requirements, connecting data and tools, testing the result, deploying it and supporting the handover.
THE FULL FDE PROGRAMME
Explore our FDE training.
See the programme overview, delivery approach and support available as you prepare for forward deployed engineering work.
Your lead mentor
Gaurav S — Lead FDE, working with multinational clients (15 years of IT experience; previously at HCL, Accenture, HP and Wipro)
Ask about project feedback, the teaching approach and the support available for your course.
View Gaurav’s profile →