Forward Deployed Engineer (FDE) Interview Prep

Forward Deployed Engineer (FDE) preparation roadmap

Follow these concepts in order. Each opens its guide, interview QA, and practice MCQs while keeping this role as your study context.

1. 1

   Translating Requirements into Architecture

   Turning a specific customer's stated needs and constraints into a concrete, deployable system design.

2. 2

   Proof-of-Concept Design

   Scoping a POC narrowly enough to prove the riskiest assumption, without building a miniature version of the whole system.

3. 3

   Vendor & Technology Selection Tradeoffs

   Evaluating build-vs-buy and vendor options against a customer's actual constraints, not feature checklists.

4. 4

   Total Cost of Ownership (TCO) Estimation

   Estimating the real cost of a proposed architecture, including the operational costs that don't show up on a vendor's price sheet.

5. 5

   Integration Patterns

   The standard ways two systems exchange data — sync API calls, async messaging, batch, and webhooks — and when each fits.

6. 6

   Technical Stakeholder Presentations

   Presenting an architecture to both technical and non-technical stakeholders in the same room, credibly.

7. 7

   Scalability Fundamentals

   Production scalability fundamentals for technical interviews: bottlenecks, scaling, load balancing, autoscaling, capacity, overload control, and failure behavior.

8. 8

   Caching Strategies

   Production caching for technical interviews: placement, read/write patterns, freshness, stampedes, HTTP caching, observability, failure recovery, and decision tradeoffs.

9. 9

   Database Scaling (Sharding & Replication)

   Splitting data across machines (sharding) and copying it across machines (replication) — solving two different scaling problems.

10. 10

    Message Queues & Async Processing

    Decoupling a slow or unreliable step from the request path by handing it to a queue and processing it separately.

11. 11

    CAP Theorem & Consistency Models

    Why a distributed system can't have perfect consistency, availability, and partition tolerance all at once — and what real systems trade off.

12. 12

    API Design & REST Fundamentals

    Designing HTTP APIs that are predictable to call and safe to retry — resource modeling, status codes, versioning, and idempotency.

13. 13

    API Authentication & Authorization

    Verifying who's calling an API (authentication) and what they're allowed to do (authorization) — API keys, OAuth, and JWTs.

14. 14

    Webhooks & Asynchronous API Integration

    Handling work that can't complete within a single request/response cycle — inbound webhooks and long-running async job APIs.

15. 15

    URL Shortener Design

    Designing a URL shortener: unique keys, redirect semantics, cache TTLs, click accounting off the GET path, and open-redirect abuse.

16. 16

    Core Data Structures

    Lists, tuples, dicts, and sets — their underlying implementations and when each is the right choice.

17. 17

    Comprehensions & Generators

    Concise, often faster ways to build sequences — and the lazy-evaluation alternative that avoids materializing them at all.

18. 18

    OOP & Data Classes

    Classes, inheritance, and the @dataclass shortcut for the common case of a class that's mostly just data.

19. 19

    Decorators & Context Managers

    Wrapping a function's behavior without changing its code, and guaranteeing setup/teardown runs even when something fails.

20. 20

    Concurrency (GIL, Threading, Asyncio)

    Why Python threads don't parallelize CPU work, and the two real ways around it: multiprocessing and asyncio.

21. 21

    SQL Fundamentals

    SELECT, WHERE, and JOIN — retrieving and combining rows from relational tables.

22. 22

    Aggregations & GROUP BY

    Collapsing many rows into one summary row per group — counts, sums, and averages — plus the HAVING clause that filters groups.

23. 23

    Window Functions

    Per-row calculations across a related set of rows — running totals, rankings, and row-over-row comparisons — without collapsing rows like GROUP BY does.

24. 24

    Schema Design & Normalization

    Structuring tables to avoid redundant, inconsistent data — and knowing when to deliberately break the rules for performance.

25. 25

    Indexing & Query Performance

    Why some queries are instant and others scan the whole table — and how an index (usually a B-tree) changes that.

26. 26

    Transactions & Isolation Levels

    ACID guarantees, and the isolation-level trade-off between correctness and concurrent throughput.

27. 27

    NoSQL, Graph & Key-Value Data Stores

    When a relational database isn't the right fit — document, key-value, graph, and vector stores, and how to choose between them.

28. 28

    ETL vs. ELT

    Transform-before-load versus load-then-transform, and why modern warehouses shifted the order.

29. 29

    Batch vs. Streaming Processing

    Processing data in scheduled chunks versus continuously as it arrives — and the latency/complexity tradeoff.

30. 30

    Data Warehousing & Modeling

    Star and snowflake schemas, and the fact/dimension split that makes analytical queries fast.

31. 31

    Data Pipeline Orchestration

    Scheduling and sequencing interdependent pipeline steps as a DAG, with retries and backfills.

32. 32

    Data Quality & Validation

    Catching bad data before it reaches downstream consumers — schema checks, freshness, and anomaly detection.

33. 33

    Distributed Data Processing

    How frameworks like Spark parallelize work across a cluster — partitioning, shuffling, and their costs.

34. 34

    Cloud Networking Fundamentals

    VPCs, subnets, and security groups — the building blocks every other cloud topic assumes.

35. 35

    IAM & Security Fundamentals

    The principle of least privilege, and how roles/policies enforce it instead of relying on long-lived credentials.

36. 36

    Infrastructure as Code

    Defining infrastructure in version-controlled configuration instead of clicking through a console — reproducible, reviewable, and diffable.

37. 37

    High Availability & Disaster Recovery

    Designing for component failure as the expected case, and the RTO/RPO trade-off that shapes disaster-recovery strategy.

38. 38

    CI/CD Pipeline Design

    Continuous integration and continuous delivery — automating the path from commit to a shippable build.

39. 39

    Containerization & Orchestration

    Packaging an app with its dependencies via containers, and how Kubernetes schedules and manages them at scale.

40. 40

    Deployment Strategies (Blue-Green, Canary, Rolling)

    Different ways to roll a new version out safely, trading off speed, blast radius, and infrastructure cost.

41. 41

    Configuration Management

    Keeping infrastructure and application configuration consistent, versioned, and reproducible across environments.

42. 42

    GitOps

    Using a Git repository as the single source of truth for infrastructure and deployment state.

43. 43

    Secrets Management in Pipelines

    Keeping credentials and keys out of source control and pipeline logs, while still letting automation use them.

44. 44

    SLIs, SLOs & Error Budgets

    The vocabulary reliability is measured in, and how an error budget turns 'be reliable' into a concrete number.

45. 45

    Monitoring, Logging & Tracing

    The three pillars of observability, and what question each one is actually good at answering.

46. 46

    Incident Management & Postmortems

    Running an incident from detection to resolution, and writing a blameless postmortem that actually prevents a repeat.

47. 47

    Capacity Planning & Load Testing

    Knowing how much traffic a system can take before it does, through modeling and deliberate load testing.

48. 48

    Chaos Engineering

    Deliberately injecting failure into a system to verify it actually survives what you assume it survives.

49. 49

    On-Call & Alerting Design

    Designing alerts that page for what actually needs a human, and structuring on-call sustainably.

50. 50

    LLM Fundamentals

    The core mechanics of how LLMs work and the practical parameters engineers actually tune: attention, tokenization, sampling, structured output, and cost/latency trade-offs.

51. 51

    Prompt Engineering & Prompt Management

    Designing reliable prompts and treating them as versioned, tested production artifacts rather than one-off strings.

52. 52

    Retrieval-Augmented Generation (RAG)

    Grounding an LLM's output in retrieved external documents instead of relying purely on its trained-in knowledge.

53. 53

    Advanced RAG & Retrieval Quality

    The retrieval-quality techniques that separate a working RAG demo from a production system that reliably surfaces the right context.

54. 54

    LLM Agents & Tool Use

    Letting an LLM decide which actions to take — calling tools, APIs, or other models — rather than just generating text.

55. 55

    Multi-Agent Systems & Orchestration

    Coordinating multiple specialized LLM agents to handle work that's too complex or too poorly-decomposed for a single agent loop.

56. 56

    Agent Memory & Context Management

    Giving agents state across turns and sessions despite a fixed, finite context window.

57. 57

    Fine-Tuning & Adaptation

    Adapting a pretrained LLM's behavior via further training, and how that differs from prompting or RAG.

58. 58

    LLM Evaluation

    Measuring whether an LLM-based system actually works, given that outputs are open-ended and hard to score automatically.

59. 59

    LLM Observability & Monitoring

    Monitoring, logging, and tracing LLM and agent systems in production — the specific signals and tooling that apply on top of general observability practice.

60. 60

    LLMOps: Deployment, Versioning & Cost Management

    Safely shipping changes to prompts, models, and RAG configuration in production, and keeping the resulting system's cost under control.

61. 61

    Troubleshooting LLM, RAG & Agent Systems

    A practical diagnostic playbook for the specific ways LLM, RAG, and agent systems fail in production.

62. 62

    Agent Frameworks, Orchestration & MCP

    Stateful agent orchestration frameworks (LangGraph and peers) and MCP, the emerging standard protocol for connecting models to tools and data.

63. 63

    AI Security, Governance & Responsible AI

    The security and governance concerns specific to LLM systems: prompt injection, data leakage, access control over retrieved content, and responsible-use practices.