🎯

Forward Deployed Engineer

Python · Backend · Generative AI · Agentic AI · AWS · Security · DevOps — a complete career track.

3Phases 8Modules 73Submodules
New FDE Batch Starting Soon
New FDE Batch Starting Soon
New FDE Batch Starting Soon
New FDE Batch Starting Soon
🧱
Phase 1

Engineering Foundation

Production-grade Python, clean architecture, testing and Git — then FastAPI services over PostgreSQL, MongoDB and Redis.

🤖
Phase 2

Generative & Agentic AI

LLM internals, prompt engineering, RAG with vector databases, then agents with MCP tools, memory, planning and guardrails.

🚀
Phase 3

Cloud, Security & Production

Linux, AWS, cloud security, system design, Kubernetes, Terraform, GitOps and the observability to run it for a customer.

🐍

Module 01 · Python

7 submodules

1.1
OOP

Object-Oriented Programming

  • Classes, objects, instance and class attributes
  • Inheritance, composition and method resolution order
  • Dunder / magic methods, operator overloading
  • Dataclasses, properties, class and static methods
  • Abstract base classes and protocols
1.2
DSA

Data Structures & Algorithms

  • Lists, tuples, sets, dictionaries and comprehensions
  • Collections module: deque, Counter, defaultdict, namedtuple
  • Stacks, queues, linked lists, trees, hash maps
  • Searching, sorting, recursion, two-pointer and sliding window
  • Time and space complexity (Big-O) analysis
1.3
Robustness

Error Handling & Type Safety

  • Exception hierarchy, try / except / else / finally
  • Custom exception classes and error contracts
  • Type hints, Optional, Union, Generics, TypedDict
  • Static checking with mypy
  • Logging module and structured log messages
1.4
Testing

Unit Testing with pytest

  • Test discovery, assertions and parametrisation
  • Fixtures, setup / teardown and conftest.py
  • Mocking and monkeypatching external calls
  • Coverage measurement and test design
  • Test-driven development workflow
1.5
Version Control

Git & GitHub

  • Repositories, staging, commits and history
  • Branching strategies, merge vs rebase
  • Pull requests, code review and conflict resolution
  • Tags, releases and .gitignore hygiene
  • GitHub Actions basics for running tests on push
1.6
Craft

Clean Code, Packaging & Environments

  • PEP 8, naming, docstrings and readability
  • Module and package layout, __init__ design
  • Virtual environments: venv, pip, requirements
  • Dependency and project management with Poetry
  • Pre-commit hooks, black, isort, ruff / flake8
1.7
Concurrency

Async Python

  • Event loop, coroutines, async / await
  • asyncio tasks, gather and timeouts
  • Concurrency vs parallelism; threads vs processes
  • Async HTTP calls with httpx
  • Common async pitfalls and debugging
🗄️

Module 02 · Backend & Databases

6 submodules

2.1
API Design

REST API Design

  • Resources, verbs, status codes and idempotency
  • Request / response modelling and pagination
  • Error contracts and API versioning
  • Clean layering: router, service, repository
2.2
Framework

FastAPI

  • Routing, path and query parameters, dependencies
  • Pydantic models, validation and serialisation
  • Middleware, CORS and exception handlers
  • OpenAPI / Swagger documentation
2.3
Auth

Authentication

  • Password hashing and credential storage
  • JWT access and refresh tokens
  • Role-based access control and route guards
2.4
SQL

SQL Databases (PostgreSQL)

  • Tables, keys and relationships
  • SELECT, JOIN, GROUP BY and aggregate queries
  • Indexes and reading a query plan
2.5
NoSQL & Cache

NoSQL & Caching

  • MongoDB documents, collections and CRUD
  • When to choose a document store over SQL
  • Redis caching, TTL and cache invalidation
2.6
Persistence

ORM, Migrations & Testing

  • SQLAlchemy models, sessions and relationships
  • Alembic migrations and rollback
  • Integration tests over a real database
🤖

Module 03 · Generative AI & LLM Foundations

6 submodules

3.1
Landscape

The Generative AI Landscape

  • Predictive vs generative AI; what changed and why
  • Model families: text, embedding, vision, audio, multimodal
  • Open vs closed models; hosted vs self-hosted
  • Where generative AI creates real business value
  • Build vs buy vs fine-tune decision framing
3.2
Internals

How LLMs Work

  • Neural network and machine learning basics
  • Transformer architecture and attention (conceptual)
  • Training, pre-training, instruction tuning and RLHF
  • Base vs instruction-tuned vs reasoning models
  • Why models hallucinate; typical failure modes
3.3
Context

Tokens, Context & Sampling

  • Tokenisation and token accounting
  • Context windows, truncation and context management
  • Temperature, top-p, max tokens and stop sequences
  • Determinism, seeds and reproducibility limits
3.4
Embeddings

Embeddings & Similarity

  • What an embedding represents
  • Cosine, dot-product and Euclidean similarity
  • Embedding models and dimensionality
  • Use cases: search, clustering, deduplication, classification
3.5
Provider APIs

Working with Provider APIs

  • OpenAI API: chat completions, embeddings, files
  • Anthropic Claude API: messages, system prompts, tools
  • Google Gemini API: multimodal requests
  • Amazon Bedrock: model access and invocation
  • Keys, quotas, retries, backoff and error handling
  • Streaming responses and token-by-token UX
  • Provider abstraction for vendor-neutral design
3.6
Cost & Latency

Model Selection, Cost & Latency

  • Matching model capability to the task
  • Benchmarks and their limits; running your own tests
  • Token pricing, cost per request and budget tracking
  • Latency budgets, batching and caching strategies
✍️

Module 04 · Prompt Engineering & LLM Applications

6 submodules

4.1
Fundamentals

Prompt Fundamentals

  • System, user and assistant roles
  • Instruction clarity, delimiters and formatting rules
  • Zero-shot vs few-shot prompting
  • Output contracts and refusal handling
4.2
Advanced

Advanced Prompting Techniques

  • Chain-of-thought and step-by-step reasoning
  • Self-consistency and multi-sample voting
  • Role, persona and constraint prompting
  • Decomposition and prompt chaining
  • Context compression and summarisation prompts
4.3
Tool Calling

Function / Tool Calling & Structured Output

  • Tool schemas and argument validation
  • JSON mode and schema-constrained responses
  • Parsing, repairing and validating model output
  • Mapping model output onto typed Python models
4.4
Prompt Ops

Prompt Templates, Versioning & Testing

  • Template design and variable injection
  • Versioning prompts alongside code
  • Regression tests for prompt changes
  • Golden datasets and snapshot comparison
4.5
Eval & Guardrails

Evaluation & Guardrails

  • Offline evaluation and scoring rubrics
  • LLM-as-judge and human review loops
  • Input / output filtering and content safety
  • Prompt-injection awareness at the application layer
  • Monitoring quality in production
4.6
Multimodal

Multimodal & Customisation

  • Vision, document and audio inputs
  • Prompting vs RAG vs fine-tuning: choosing correctly
  • Fine-tuning and distillation at an awareness level
  • Cost and maintenance trade-offs of each approach
📚

Module 05 · Retrieval-Augmented Generation (RAG)

6 submodules

5.1
Architecture

RAG Architecture

  • Why retrieval beats fine-tuning for private data
  • Ingest, index, retrieve, augment, generate pipeline
  • Failure modes: missing context, wrong chunk, stale index
5.2
Ingestion

Document Ingestion & Chunking

  • Loaders for PDF, DOCX, HTML, Markdown and databases
  • Fixed-size, recursive and semantic chunking
  • Chunk overlap, metadata and document hierarchy
  • Incremental re-indexing, updates and deletion
5.3
Vector DBs

Vector Databases

  • Pinecone: indexes, namespaces, upserts, filters
  • Chroma and FAISS for local and self-hosted use
  • pgvector as a SQL-native option
  • Index sizing, cost and refresh strategy
  • OpenSearch / managed vector options on AWS
5.4
Retrieval Quality

Retrieval Quality

  • Semantic, keyword (BM25) and hybrid search
  • Metadata filtering and access-scoped retrieval
  • Re-ranking with cross-encoders
  • Query rewriting, expansion and multi-query retrieval
  • Parent-document and small-to-big retrieval
5.5
Frameworks

Frameworks

  • LangChain: chains, runnables, retrievers, memory
  • LlamaIndex: indices, query engines, node post-processors
  • Managed RAG (Bedrock Knowledge Bases) vs custom
  • When to drop the framework and write it directly
5.6
Grounding

Grounding & RAG Evaluation

  • Citations, source attribution and traceability
  • Refusing to answer when context is insufficient
  • Metrics: context precision / recall, faithfulness
  • RAGAS-style evaluation harness wired into CI
🕹️

Module 06 · Agentic AI

9 submodules

6.1
Fundamentals

Agent Fundamentals

  • Agent vs chain vs workflow
  • The reason-act loop and tool use
  • Autonomy levels and where to draw the line
  • Deciding when an agent is the wrong answer
6.2
Tools

Tool Calling & Integrations

  • Designing safe, idempotent, well-described tools
  • Tool schemas, validation and error surfaces
  • Calling internal APIs, databases, search and files
  • Least-privilege credentials per tool
6.3
MCP

Model Context Protocol (MCP)

  • MCP architecture: hosts, clients and servers
  • Tools, resources and prompts over MCP
  • Building a custom MCP server for internal systems
  • Connecting MCP servers to agent runtimes and IDEs
  • Transport, auth and deployment considerations
6.4
Memory

Memory & State

  • Short-term conversation state and windowing
  • Long-term memory stores and retrieval of past context
  • Summarisation and context compaction
  • Durable state machines and resumable runs
6.5
Reasoning

Planning, Reasoning & Reflection

  • Task decomposition and planner / executor split
  • ReAct, plan-and-execute and tree-of-thought patterns
  • Self-critique, retries and reflection loops
  • Budget and step limits to prevent runaway loops
6.6
Multi-Agent

Multi-Agent Systems

  • Supervisor and specialist topologies
  • Handoffs, shared scratchpads and message passing
  • Parallel fan-out and result aggregation
  • Failure isolation between agents
6.7
Frameworks

Agent Frameworks

  • LangGraph: graphs, state, checkpoints, human interrupts
  • CrewAI: roles, tasks and crews
  • Amazon Bedrock Agents at an awareness level
  • Choosing a framework, or writing the loop yourself
6.8
Safety & HITL

Safety, Human-in-the-Loop & Observability

  • Approval gates for write and irreversible actions
  • Sandboxing, allow-lists and spend limits
  • Tracing runs, spans and tool calls
  • Debugging non-deterministic behaviour
  • Audit trails for agent actions
6.9
Production

Agent Evaluation & Production Readiness

  • Task-success metrics instead of vibes
  • Regression suites for agent behaviour
  • Cost, latency and step-count monitoring
  • Rollout strategy: shadow mode to full autonomy
☁️

Module 07 · Cloud, AWS & Security

23 submodules — Linux and networking, AWS core services, cloud security and system design

7.1
Linux

Linux Command Line

  • Filesystem hierarchy, navigation and file operations
  • Text processing: grep, sed, awk, cut, sort, jq
  • Processes, signals, top / htop, ps and kill
  • Disk, memory and CPU inspection (df, du, free, iostat)
  • Package management (apt / yum) and systemd services
7.2
Linux

Users, Permissions & Hardening

  • Users, groups, sudo and least privilege
  • File permissions, ownership, umask, ACLs
  • SSH keys, config and disabling password login
  • Firewall basics (ufw / iptables) and fail2ban
  • Log locations, journalctl and log rotation
7.3
Scripting

Bash Scripting

  • Variables, conditionals, loops and functions
  • Arguments, exit codes and set -euo pipefail
  • Pipes, redirection and process substitution
  • cron and scheduled maintenance scripts
7.4
Networking

Networking Fundamentals

  • OSI / TCP-IP model, ports and sockets
  • IP addressing, subnets, CIDR, NAT and routing
  • DNS records, resolution path and propagation
  • HTTP/1.1 vs HTTP/2, headers, methods, caching
  • TLS handshake, certificates and Let's Encrypt
7.5
Nginx

Nginx & Traffic Handling

  • Reverse proxy and upstream configuration
  • TLS termination and HTTP to HTTPS redirects
  • Load balancing methods and health checks
  • Static assets, gzip, timeouts and rate limiting
7.6
Cloud Basics

Cloud Foundations

  • IaaS, PaaS, SaaS and serverless models
  • Regions, availability zones and edge locations
  • The shared responsibility model
  • Console, CLI, SDK (boto3) and CloudShell
  • AWS, Azure and GCP service mapping
7.7
Troubleshooting

Troubleshooting Playbook

  • curl, dig, nslookup, traceroute, ss, netstat, tcpdump
  • Diagnosing connection refused, timeout, 502 and 504
  • Certificate, DNS and firewall failure patterns
  • A repeatable triage checklist for customer servers
7.8
AWS

Accounts & Access Basics

  • Account structure, Organizations and landing zones
  • Root account protection and billing alarms
  • Tagging strategy and resource naming
  • Service quotas and regional availability
7.9
AWS

Compute

  • EC2 instance families, AMIs, user data, key pairs
  • Elastic IPs, EBS volumes and snapshots
  • Auto Scaling groups, launch templates, scaling policies
  • Application Load Balancer, target groups, health checks
  • ECS and EKS as container platforms (introduction)
  • Right-sizing, reserved capacity and spot instances
7.10
AWS

Networking

  • VPC design, public and private subnets
  • Route tables, internet and NAT gateways
  • Security groups vs network ACLs
  • VPC endpoints and private service access
  • Route 53 hosted zones, records and routing policies
  • CloudFront distributions and caching behaviour
7.11
AWS

Storage & Databases

  • S3 buckets, storage classes, lifecycle, versioning
  • S3 access control, presigned URLs and static hosting
  • RDS: engines, parameter groups, backups, read replicas
  • Multi-AZ vs read replica; failover behaviour
  • DynamoDB: partition keys, indexes, capacity modes
  • ElastiCache for Redis
7.12
AWS

Serverless & Integration

  • Lambda: handlers, packaging, layers, limits, cold starts
  • API Gateway: REST and HTTP APIs, authorisers, stages
  • EventBridge, SQS queues and SNS topics
  • Step Functions for orchestration
  • Event-driven serverless patterns
7.13
AWS AI

AI & Data Services

  • Amazon Bedrock: model access, invocation, guardrails
  • Bedrock Knowledge Bases and managed RAG
  • OpenSearch and vector search options
  • SageMaker at an awareness level
  • Managed AI services vs self-hosted trade-offs
7.14
AWS

Observability & Cost Management

  • CloudWatch metrics, logs, alarms and dashboards
  • CloudTrail auditing and Config drift detection
  • Pricing models, budgets and Cost Explorer
  • Savings plans, right-sizing and waste hunting
7.15
Security

IAM in Depth

  • Users, groups, roles and instance profiles
  • Policy documents, conditions and permission boundaries
  • Least privilege, access analyser and credential hygiene
  • Cross-account access, federation and IRSA for Kubernetes
7.16
Security

Secrets, Keys & Encryption

  • Removing secrets from code, images and repos
  • AWS Secrets Manager and SSM Parameter Store
  • KMS, envelope encryption and key rotation
  • Encryption at rest and in transit; TLS everywhere
7.17
AppSec

Application & API Security

  • OWASP Top 10 with concrete Python examples
  • Injection, SSRF, IDOR and broken access control
  • OAuth 2.0 misuse and JWT hardening
  • Security headers, CORS and cookie flags
  • Dependency and container vulnerability scanning
7.18
AI Security

LLM & Agent Security

  • Prompt injection: direct and indirect
  • Data exfiltration through tools and retrieved content
  • Output sanitisation and untrusted-content boundaries
  • Tool permission scoping and approval gates
  • OWASP Top 10 for LLM applications
7.19
Compliance

Audit, Compliance & Review Readiness

  • Audit logging and tamper-evident trails
  • SOC 2, ISO 27001, GDPR / DPDP awareness
  • Threat modelling with STRIDE
  • Answering a customer security questionnaire
7.20
System Design

Scalability & Architecture Patterns

  • Requirements, constraints and capacity estimation
  • Latency, throughput, availability and consistency
  • Monolith, modular monolith and microservices
  • Service boundaries and API contracts
  • Vertical vs horizontal scaling; stateless design
7.21
Messaging

Messaging & Event-Driven Design

  • Queues vs topics vs streams
  • Apache Kafka: topics, partitions, consumer groups, offsets
  • RabbitMQ: exchanges, routing keys, dead-letter queues
  • Idempotency, ordering and delivery guarantees
  • Outbox pattern and event schema evolution
7.22
Reliability

Reliability & Protection Patterns

  • Caching layers and invalidation strategies
  • Read replicas, sharding and partitioning
  • High availability, redundancy and failover
  • Rate limiting, throttling and backpressure
  • Timeouts, retries with jitter and circuit breakers
7.23
AI at Scale

Designing Multi-Tenant AI Systems

  • Tenant isolation models and data separation
  • Model gateway, queueing and quota management
  • Streaming at scale and cost per request
  • Well-Architected Framework: all six pillars
  • Writing and defending an architecture decision record
⚙️

Module 08 · DevOps & Production

13 submodules — containers, Kubernetes, IaC, CI/CD, GitOps and production operations

8.1
Docker

Containers with Docker

  • Images, layers, containers and the build cache
  • Dockerfile best practice: multi-stage, non-root, slim bases
  • Volumes, networks, environment and runtime secrets
  • Docker Compose for multi-service local stacks
  • Registries: Docker Hub and Amazon ECR
  • Image scanning, signing and size reduction
8.2
Kubernetes

Kubernetes Core

  • Architecture: control plane, nodes, kubelet, etcd
  • Pods, ReplicaSets, Deployments and rollouts
  • Services, Ingress controllers and cluster DNS
  • ConfigMaps, Secrets and environment configuration
  • Namespaces, resource requests, limits and quotas
  • Liveness, readiness and startup probes
  • kubectl workflow and cluster debugging
8.3
Kubernetes

Kubernetes in Production

  • StatefulSets, Jobs and CronJobs
  • Horizontal Pod Autoscaler and Cluster Autoscaler
  • RBAC, service accounts and pod security
  • EKS on AWS: node groups, IRSA, add-ons
  • Persistent volumes and storage classes
8.4
Helm

Helm & Configuration Management

  • Chart structure, templates, values and helpers
  • Releases, upgrades, rollbacks and hooks
  • Environment-specific values and chart reuse
  • Publishing an internal chart repository
8.5
Terraform

Infrastructure as Code with Terraform

  • Providers, resources, variables, outputs, locals
  • State, remote backends and state locking
  • Modules, composition and reusable stacks
  • Workspaces and multi-environment layout
  • plan / apply / destroy discipline and drift handling
  • Importing existing infrastructure; CloudFormation awareness
8.6
CI/CD

CI/CD Pipelines

  • Pipeline stages: build, test, scan, package, deploy
  • GitHub Actions: workflows, jobs, matrices, caching
  • Reusable workflows, self-hosted runners, OIDC to AWS
  • Secrets and least-privilege credentials in pipelines
  • Jenkins and GitLab CI at an awareness level
  • Artefact versioning and immutable builds
8.7
GitOps

GitOps & Release Strategy

  • GitOps principles and the pull-based model
  • ArgoCD: applications, sync, drift detection, self-heal
  • Environment promotion: dev to staging to production
  • Trunk-based development and feature flags
  • Rollback and hotfix procedures
  • Change management on a customer's cluster
8.8
Go Live

Going Live

  • Production readiness checklist
  • Configuration, feature flags and environment parity
  • Zero-downtime deployment: rolling, blue-green, canary
  • Database migrations without downtime
  • Load testing with k6 / Locust and autoscaling validation
8.9
Monitoring

Monitoring & Metrics

  • The four golden signals and RED / USE methods
  • Prometheus: exporters, scraping, PromQL, recording rules
  • Instrumenting a Python service with custom metrics
  • Grafana dashboards for service, infra and LLM cost
  • Tracking token spend, latency and model error rates
8.10
Observability

Logging & Tracing

  • Structured JSON logging and correlation IDs
  • ELK / OpenSearch: ingest, index patterns, queries
  • Log levels, sampling, retention and PII redaction
  • Distributed tracing with OpenTelemetry
  • Tracing LLM and agent calls end to end
8.11
Incidents

Alerting & Incident Response

  • Alertmanager routing, grouping, silences, escalation
  • Alerting on symptoms, not causes; avoiding fatigue
  • On-call rotation, severity levels and comms templates
  • Incident timeline, mitigation and blameless postmortems
  • Writing runbooks a customer's team can follow
8.12
SRE & Cost

Reliability & Cost Operations

  • SLI, SLO and error budgets
  • Capacity planning and performance regression tracking
  • Backup, restore drills and disaster recovery
  • Cloud and token cost review; optimisation levers
8.13
Customer Facing

Handover & Customer Operations

  • Architecture and operations documentation
  • Training the customer's team; knowledge transfer
  • Support model, escalation paths and SLAs
  • Feeding customer learnings back into the product