chore: sync content to repo (#10024)

Co-authored-by: nilbuild <4921183+nilbuild@users.noreply.github.com>
2026-09-24 15:00:31 +08:00 · 2026-05-27 13:36:43 +02:00
parent c812044859
commit e491a5c575
88 changed files with 268 additions and 0 deletions
@@ -0,0 +1,3 @@
+# Agent Architectures
+ 
+Agent architectures define how an AI agent is structured: how it reasons, selects tools, manages memory, and decides when to stop. Common patterns include ReAct (reason + act), plan-and-execute, and tree-of-thought. Choosing the right architecture depends on how much control the application needs over model behavior and how tolerant the customer is of unpredictable agent outputs.
@@ -0,0 +1,3 @@
+# AI Agents
+ 
+AI agents are systems where an LLM is given tools, memory, and a goal, and can take a sequence of actions to complete a task rather than just responding to a single prompt. Agents can call APIs, search the web, write and run code, read files, and more. FDEs are increasingly asked to build agent-based systems for customers, where the challenge is making them reliable enough to run in production rather than just in a demo.
@@ -0,0 +1,3 @@
+# AI Engineering
+ 
+AI engineering involves building software systems that use machine learning models and large language models (LLMs) as components. This includes selecting models, integrating them via APIs, engineering prompts, managing context, and deploying AI features in production. For FDEs, AI engineering is often the core of the engagement to deliver a working AI-powered feature within the customer's existing environment.
@@ -0,0 +1,3 @@
+# AI Governance
+ 
+AI governance refers to the policies, processes, and controls that ensure AI systems behave safely, fairly, and in compliance with regulations and organizational standards. This includes defining acceptable use, managing model risk, ensuring transparency, and monitoring for harmful or biased outputs. Enterprise customers increasingly require AI governance frameworks before they will deploy AI features in production.
@@ -0,0 +1,3 @@
+# Airflow
+ 
+Apache Airflow is an open-source workflow orchestration platform for scheduling and monitoring data pipelines. Pipelines are defined as Directed Acyclic Graphs (DAGs) in Python, where each node is a task. Many enterprise data teams use Airflow to manage their pipelines, and FDEs may need to add new DAGs, debug failures, or integrate new data sources into an existing Airflow setup.
@@ -0,0 +1,3 @@
+# API Security
+ 
+API security covers the practices and controls needed to protect APIs from unauthorized access and abuse. This includes authentication, authorization, rate limiting, input validation, and protection against common attacks. When building APIs, it's important to follow the customer's security standards and design endpoints that are not vulnerable to misuse, especially when those APIs expose AI capabilities.
@@ -0,0 +1,3 @@
+# APIs Design
+ 
+API design is the process of defining how services communicate with each other through well-structured interfaces. Good API design involves choosing the right protocol (REST, GraphQL, gRPC), defining clear resource models, handling errors consistently, and versioning carefully.
@@ -0,0 +1,3 @@
+# Authentication
+ 
+Authentication is the process of verifying the identity of a user or system. Common mechanisms include username/password, API keys, OAuth 2.0 tokens, and JWTs. In customer environments, FDEs typically need to integrate with an existing identity provider rather than build authentication from scratch, which requires understanding how common auth flows work and how to connect new services to them securely.
@@ -0,0 +1,3 @@
+# AWS
+ 
+Amazon Web Services (AWS) is the largest cloud platform by market share, offering services across compute (EC2, Lambda), storage (S3), databases (RDS, DynamoDB), networking, and AI/ML tooling. A large proportion of customer environments run on AWS, making it one of the most common cloud platforms an FDE will need to work within.
@@ -0,0 +1,3 @@
+# Azure
+ 
+Microsoft Azure is Microsoft's cloud platform with particularly strong adoption in enterprise environments, especially those using Microsoft products like Active Directory, Office 365, and .NET.
@@ -0,0 +1,3 @@
+# Backend
+ 
+Backend development refers to the server-side logic of a web application, including handling requests, running business logic, interacting with databases, and returning responses. Backend systems are typically built with Python, Node.js, Java, or Go, connected to databases and external services. FDEs who can build solid backend systems can own the full delivery of a feature rather than handing off at the API boundary.
@@ -0,0 +1,3 @@
+# Build your Agent
+ 
+You have learned the concepts. Now build one. Pick a real task, something you actually want automated, and build an agent that can do it: define the tools, write the orchestration logic, handle failures, and test it against inputs that are likely to break it. It does not matter if the first version is rough. Getting hands-on with a real agent exposes the gaps that no amount of reading covers, and what you learn from debugging a misbehaving agent is exactly the knowledge you will need when doing it inside a customer environment.
@@ -0,0 +1,3 @@
+# Building Eval Pipelines
+ 
+Evaluation pipelines are automated systems for measuring the quality of an AI model or application across a set of test cases. They run inputs through the system, compare outputs to expected results or use a judge model, and surface quality metrics. Eval pipelines give customers a way to measure whether AI features are working, which makes it easier to iterate and build confidence in the system over time.
@@ -0,0 +1,3 @@
+# Business Acumen
+ 
+Business acumen is the ability to understand how an organization operates, what its priorities are, how it makes money, and where technology can create real value. Being able to connect engineering decisions to business outcomes is what makes FDEs different from traditional software engineers.
@@ -0,0 +1,3 @@
+# C++
+ 
+C++ is a high-performance, statically typed language that gives developers fine-grained control over memory and system resources. It is used in systems programming, game engines, embedded software, and performance-critical applications. While less common in typical web or AI deployments, some customer environments in hardware, robotics, or real-time systems will require at least reading and navigating C++ codebases.
@@ -0,0 +1,3 @@
+# Choosing your Model Provider
+ 
+Different LLM providers offer models with different tradeoffs in capability, cost, latency, context length, and licensing terms. Common providers include OpenAI, Anthropic, Google, and Meta, as well as providers of open-source models like Hugging Face. FDEs need to be able to evaluate and recommend the right model for a customer's use case, considering not just benchmark performance but also data privacy requirements, cost at scale, and the customer's existing cloud agreements.
@@ -0,0 +1,3 @@
+# Claude Code
+ 
+Claude Code is a terminal-based AI tool built by Anthropic. It is designed to reason through complex code problems, explain unfamiliar codebases, and help with debugging. It works best when you need to understand what a piece of code is doing before modifying it; give it a specific problem and it will walk through it step by step.
@@ -0,0 +1,3 @@
+# Cloud Platforms
+ 
+Cloud platforms provide on-demand access to computing resources, including servers, storage, networking, databases, and managed services. Almost every customer environment runs on one or more cloud providers, so FDEs need to be comfortable operating across at least one of the major platforms, understanding how to deploy services, manage permissions, and navigate the ecosystem of managed offerings.
@@ -0,0 +1,3 @@
+# Codex
+
+Codex is OpenAI's code-focused model, trained on large amounts of public code, and the model that powers GitHub Copilot. It can generate code from natural language descriptions, complete functions, and assist with documentation. It is one of the foundational tools in the AI-assisted coding ecosystem that FDEs may use or encounter in customer engineering teams.
@@ -0,0 +1,3 @@
+# Communication
+ 
+Clear communication is one of the most important skills in a customer-facing engineering role. It involves explaining technical concepts to non-technical audiences, writing clearly in documentation and updates, facilitating meetings effectively, and adapting the level of detail to the context and audience.
@@ -0,0 +1,3 @@
+# Complete App with Observability
+ 
+Take a complete application and make it production-ready by adding the operational layer it needs: structured logging, distributed tracing, error tracking, performance metrics, and alerts. This is the step most people skip when building for themselves, but it is the step that separates a demo from something a customer can actually rely on. Go through the experience of adding observability from scratch, then break something intentionally and use those tools to find it. That exercise alone will change how you think about building systems.
@@ -0,0 +1,3 @@
+# Complete Apps
+ 
+This is where everything connects. Take an idea and build it fully, from the database schema to the API to the frontend. No mocking, no placeholders, no "this would normally connect to X." The point is to experience what it feels like to own a full system: making decisions at every layer, dealing with the friction between them, and ending up with something that actually works. Building complete apps on your own is the best way to develop that instinct before you are doing it under customer pressure.
@@ -0,0 +1,3 @@
+# Computer Science
+ 
+Computer science covers the foundational principles behind how software and computing systems work. This includes programming, algorithms, data structures, system design, and software architecture. These fundamentals matter because FDEs often need to quickly evaluate a customer's existing systems, identify bottlenecks, and make sound architectural decisions.
@@ -0,0 +1,3 @@
+# Containers
+ 
+Containers are a lightweight way to package an application along with its dependencies and configuration so it runs consistently across environments. Unlike virtual machines, containers share the host operating system kernel, making them fast to start and efficient to run. Containerizing an application is often the first step toward making it deployable in a customer's cloud environment.
@@ -0,0 +1,3 @@
+# CSS
+ 
+CSS, or Cascading Style Sheets, controls the visual appearance of HTML elements on a web page. It handles layout, colors, typography, spacing, animations, and responsive design. Modern CSS includes Flexbox, Grid, and custom properties. Being fluent in CSS is key to produce clean, presentable demos and prototypes.
@@ -0,0 +1,7 @@
+# Cursor
+
+ Cursor is a code editor built on top of VS Code with AI assistance integrated throughout. It is particularly useful for navigating and editing large codebases you did not write yourself, which makes it well-suited for working with AI-generated code. You can select any part of the code and ask it to explain, fix, or rewrite it without having to read every line around it.
+
+Visit the following resources to learn more:
+
+- [@article@Claude Code vs Cursor: Which AI Coding Tool To Choose](https://roadmap.sh/vibe-coding)
@@ -0,0 +1,3 @@
+# Data Engineering
+ 
+Data engineering involves building and maintaining the systems that collect, store, process, and move data at scale. This includes designing pipelines, working with data warehouses, and ensuring data quality for downstream consumers like analysts and ML systems. FDEs working with enterprise customers often find that data access, transformation, and availability are the first real blockers to building anything useful with AI.
@@ -0,0 +1,3 @@
+# Data Pipelines
+ 
+A data pipeline is a series of steps that move and transform data from one place to another, usually from source systems into a warehouse or processing layer. Pipelines can be batch-based (running on a schedule) or streaming (processing data in real time). Building reliable pipelines means handling failures, schema changes, and data quality issues, all of which are common realities in customer environments.
@@ -0,0 +1,3 @@
+# Data Privacy & Compliance
+ 
+Data privacy ensures personal or sensitive data is handled according to applicable laws and organizational policies, including GDPR, CCPA, HIPAA, and others. For AI systems, this includes what data is sent to third-party model APIs, what is stored, and how long it is retained.
@@ -0,0 +1,3 @@
+# Data Structures & Algorithms
+ 
+Data structures are ways of organizing data in memory, such as arrays, linked lists, trees, graphs, and hash maps. Algorithms are step-by-step procedures for solving problems, like sorting, searching, or traversal. Knowing these well means being able to evaluate performance characteristics of code, debug inefficiencies in customer systems, and reason clearly about solutions to technical problems.
@@ -0,0 +1,3 @@
+# DevOps & CI/CD
+ 
+DevOps is a set of practices that combine software development and IT operations to shorten delivery cycles and ship software more reliably. CI/CD automates the process of testing, building, and deploying code. Understanding the customer's CI/CD setup is often necessary for FDEs to integrate new work into their delivery pipeline without disrupting existing processes.
@@ -0,0 +1,3 @@
+# Discovery & Scoping
+ 
+Discovery and scoping is the phase of a customer engagement where the team identifies the problem to solve, understands the current state of the customer's systems and processes, and defines what success looks like. It involves asking the right questions, identifying constraints, and setting realistic expectations before any building begins. Getting this phase right determines whether the rest of the engagement goes smoothly or runs into avoidable problems.
@@ -0,0 +1,3 @@
+# Docker
+ 
+Docker is the leading platform for building, shipping, and running containers. A Dockerfile defines the steps to build a container image, and Docker provides tools to run those images locally or push them to a registry for deployment. Docker is the standard way to package work so it runs reliably in customer environments regardless of local differences in setup.
@@ -0,0 +1,3 @@
+# Enterprise Workflow
+ 
+Enterprise workflows are the processes and systems through which large organizations operate, including approvals, handoffs, integrations with existing tools, and compliance requirements. Building for enterprise environments requires understanding these workflows and designing solutions that fit within them.
@@ -0,0 +1,3 @@
+# Frontend Apps
+ 
+Put the frontend skills together and build something that lives entirely in the browser. A weather dashboard, a personal finance tracker, a Pomodoro timer, a markdown editor. Use mock data or a public API if you need data, but keep the focus on the frontend itself: how you structure components, manage state, handle routing, and make the interface feel responsive and usable. The goal is to get comfortable making frontend decisions on your own, without a backend to hide behind.
@@ -0,0 +1,3 @@
+# Frontend
+ 
+Frontend development refers to the part of web development concerned with what users see and interact with in a browser. It covers HTML for structure, CSS for styling, and JavaScript for interactivity. FDEs who can build functional frontends are more self-sufficient in customer engagements, able to deliver end-to-end demos and working prototypes without depending on a separate frontend team.
@@ -0,0 +1,3 @@
+# Full Stack
+ 
+Full stack development refers to working across both the frontend and backend of a web application. A full stack developer understands how the client-side and server-side interact and can build across all layers.
@@ -0,0 +1,3 @@
+# GCP
+ 
+Google Cloud Platform (GCP) is Google's cloud offering, known for strong data and analytics services like BigQuery and AI/ML infrastructure like Vertex AI. It is often the preferred choice for data-intensive workloads and organizations using Google Workspace.
@@ -0,0 +1,3 @@
+# Gemini
+
+Gemini CLI is Google's command-line AI tool for developers. It assists with code generation, explanation, and refactoring directly in the terminal. It is a practical option if you are already working within Google's ecosystem or want a powerful AI assistant without switching away from your existing terminal workflow.
@@ -0,0 +1,3 @@
+# Git & GitHub
+ 
+Git is a distributed version control system that tracks changes to code over time and allows multiple people to collaborate on the same codebase. GitHub adds features like pull requests, code review, issue tracking, and CI/CD integrations on top of Git. FDEs regularly work inside customer repositories, contribute to shared codebases, and need to follow existing branching and review conventions from day one.
@@ -0,0 +1,3 @@
+# GitHub Actions
+ 
+GitHub Actions is a CI/CD and automation platform built into GitHub. Workflows are defined in YAML files and triggered by events like pushes, pull requests, or schedules. They can run tests, build container images, and deploy to cloud environments.
@@ -0,0 +1,3 @@
+# Go
+ 
+Go is a statically typed, compiled language developed by Google, designed for simplicity and performance. It is commonly used for building backend services, command-line tools, and cloud infrastructure components. FDEs working in cloud-native or infrastructure-heavy customer environments will often encounter Go-based tooling and services.
@@ -0,0 +1,3 @@
+# GraphQL
+ 
+GraphQL is a query language and runtime for APIs that lets clients request exactly the fields they need, rather than consuming fixed endpoints with predefined shapes. This makes APIs more flexible and reduces over-fetching, especially in frontend-heavy applications. Some customer stacks use GraphQL, and understanding it makes it easier to integrate with or extend their data layer.
@@ -0,0 +1,3 @@
+# HTML
+ 
+HTML, or HyperText Markup Language, is the standard language for structuring content on the web. It defines the elements of a page such as headings, paragraphs, links, forms, and images. It forms the foundation that CSS and JavaScript build on. Understanding HTML is necessary for any frontend work and for reading or modifying web-based customer interfaces.
@@ -0,0 +1,3 @@
+# Inference Optimization
+ 
+Inference optimization refers to techniques for making model predictions faster and cheaper without significantly reducing quality. Common approaches include quantization, distillation, response caching, and request batching. Inference costs can become a real issue quickly, and knowing how to optimize without degrading the user experience is a practical skill FDEs should have.
@@ -0,0 +1,3 @@
+# Introduction
+ 
+A Forward Deployed Engineer works directly at the intersection of software engineering and customer delivery. The role involves embedding with customers or clients to build, deploy, and adapt technical solutions in close collaboration with their teams, rather than working from a centralized product org. It requires both technical depth and the ability to operate in ambiguous, fast-moving environments where the requirements are rarely fully defined upfront.
@@ -0,0 +1,3 @@
+# Java / Scala
+ 
+Java is a statically typed, object-oriented language that runs on the Java Virtual Machine (JVM) and is widely used in enterprise systems, backend services, and Android development. Scala is also a JVM language that blends object-oriented and functional styles, commonly used with Apache Spark. Many enterprise customers, especially in finance or large tech organizations, run significant infrastructure on the JVM.
@@ -0,0 +1,3 @@
+# JavaScript / TypeScript
+ 
+JavaScript is the programming language of the web, running natively in browsers and on servers via Node.js. TypeScript is a superset of JavaScript that adds static type annotations, which help catch errors early and improve code maintainability. Together, they cover a large portion of the customer codebases and frontend work that an FDE is likely to encounter.
@@ -0,0 +1,3 @@
+# JavaScript
+ 
+JavaScript is the scripting language that runs in web browsers, giving web pages dynamic behavior. It handles user interactions, DOM manipulation, API requests, and more. On the server side, JavaScript runs via Node.js. Understanding JavaScript well means being able to work across the full web stack.
@@ -0,0 +1,3 @@
+# Kubernetes
+ 
+Kubernetes is an open-source container orchestration system that automates the deployment, scaling, and management of containerized applications. It handles scheduling containers across a cluster, managing service discovery, load balancing, rolling updates, and self-healing. Many enterprise customers run Kubernetes in production, and FDEs need to know enough to deploy and operate services within existing clusters.
@@ -0,0 +1,3 @@
+# Latency and Cost Optimization
+ 
+Latency and cost optimization in AI systems involves reducing the time and money needed to serve model predictions. Strategies include choosing smaller or faster models, caching responses for repeated queries, batching requests, and routing simpler inputs to cheaper models. These tradeoffs become very real when a customer starts using an AI feature at scale and the initial architecture no longer holds up economically.
@@ -0,0 +1,3 @@
+# Linux
+ 
+Linux is an open-source operating system used widely in servers, cloud environments, and developer workstations. Most production software runs on Linux, so being comfortable navigating a Linux system, managing processes, reading logs, and configuring services is a practical necessity for anyone building and deploying in real customer environments.
@@ -0,0 +1,3 @@
+# LLM Fundamentals
+ 
+Large language models (LLMs) are machine learning models trained on large amounts of text data that can generate, summarize, classify, and reason about language. They work by predicting the most likely next tokens given a context window of input. Understanding how LLMs work, including their limitations around hallucination, context length, and latency, helps FDEs build more reliable systems around them and set realistic expectations with customers.
@@ -0,0 +1,3 @@
+# Managed ML Services
+ 
+Major Cloud providers offer services that abstract away the infrastructure for training, deploying, and serving machine learning models. Examples include AWS SageMaker, Google Vertex AI, and Azure Machine Learning. For FDEs building AI features inside customer cloud environments, these services can significantly reduce the time needed to get a model into production.
@@ -0,0 +1,3 @@
+# MCP
+ 
+The Model Context Protocol (MCP) is an open standard for connecting AI models to external tools and data sources through a unified interface. Instead of building custom integrations for every tool, developers implement MCP servers that expose tools and resources in a standardized way. MCP can simplify connecting AI agents to a customer's existing systems and internal APIs.
@@ -0,0 +1,3 @@
+# Memory & State Management
+ 
+Memory refers to how information is stored and retrieved across steps in a conversation or task. Short-term memory lives in the context window, while long-term memory requires external storage like a database or vector store. Managing state well is important when building agents for customer workflows that span multiple steps, sessions, or users.
@@ -0,0 +1,3 @@
+# MLOps
+ 
+MLOps applies DevOps principles to machine learning systems, covering the processes and tooling needed to reliably build, deploy, monitor, and update ML models in production. This includes versioning data and models, automating training pipelines, serving inference at scale, and detecting degradation over time. FDEs building AI features for customers increasingly need MLOps knowledge to ensure those features stay reliable after handoff.
@@ -0,0 +1,3 @@
+# Model Deployment
+ 
+Model deployment is the process of making a trained machine learning model available to serve predictions in a production environment. This involves packaging the model, setting up an inference server, exposing an API, and ensuring the system can handle required throughput and latency.
@@ -0,0 +1,3 @@
+# Multi-Agents
+ 
+Multi-agent systems involve multiple AI agents working together, where each agent has a specific role or capability, and they coordinate to complete a larger task. One agent might plan the work while others execute specific subtasks. This pattern becomes relevant for complex customer workflows where a single agent would struggle to manage all the context and steps reliably.
@@ -0,0 +1,3 @@
+# Node.js
+ 
+Node.js is a JavaScript runtime built on Chrome's V8 engine that lets developers run JavaScript on the server side. It uses a non-blocking, event-driven architecture well suited for I/O-heavy workloads like APIs and real-time applications. Many customer web stacks include Node.js services, and being able to read, debug, and extend them is a practical advantage.
@@ -0,0 +1,3 @@
+# NoSQL Databases
+ 
+NoSQL databases store data in formats other than traditional relational tables, such as documents, key-value pairs, graphs, or wide columns. Examples include MongoDB, Redis, Cassandra, and DynamoDB. Customer environments often include NoSQL stores for specific use cases like caching, session management, or high-throughput writes, so knowing how these systems work helps FDEs navigate and extend existing architectures.
@@ -0,0 +1,3 @@
+# Observability
+ 
+Observability refers to the ability to understand the internal state of a system based on its external outputs, through logging, metrics, and distributed tracing. For AI-powered systems, observability also involves monitoring model outputs, tracking prompt and response quality, and detecting unexpected behavior in production.
@@ -0,0 +1,3 @@
+# PostgreSQL
+ 
+PostgreSQL is a powerful, open-source relational database system that supports advanced features like JSONB storage, full-text search, window functions, and custom data types. It is a widely used database in both startups and large organizations, and knowing it well means being able to work effectively with a large portion of customer backend stacks without a steep learning curve.
@@ -0,0 +1,3 @@
+# Product Feedback Loop
+ 
+A product feedback loop is the cycle of shipping something, collecting feedback from users or stakeholders, and using that input to improve future iterations. This usually means working closely with the customer to observe how the delivered product is actually being used, identifying gaps between expectation and reality, and feeding those observations back into the build process while still on the engagement.
@@ -0,0 +1,3 @@
+# Prompt Engineering
+ 
+Prompt engineering is the practice of crafting inputs to language models in a way that produces more accurate, useful, or reliable outputs. Techniques include zero-shot and few-shot prompting, chain-of-thought reasoning, role assignment, and structured output formatting. Strong prompt engineering skills often determine whether a customer demo works convincingly or falls apart on edge cases.
@@ -0,0 +1,3 @@
+# Prompt Management
+ 
+Prompt management involves organizing, versioning, testing, and iterating on the prompts used in production AI systems. As customer applications grow and include more AI-powered features, managing prompts across different use cases becomes complex. Good prompt management practices ensure that changes to prompts do not introduce regressions and that improvements can be tracked and rolled back if needed.
@@ -0,0 +1,3 @@
+# Prompt Versioning
+ 
+Prompt versioning is the practice of treating prompts like code, tracking changes over time with version control. This makes it possible to roll back to previous versions, compare outputs across versions, and understand what changed when behavior shifted. When handing AI systems to customers, prompt versioning is part of making those systems maintainable after the engagement ends.
@@ -0,0 +1,3 @@
+# Python
+ 
+Python is a general-purpose programming language known for its readable syntax and broad ecosystem. It is widely used in web development, data engineering, scripting, automation, and AI/ML workloads. For FDEs, Python is especially useful because it lets you move fast, prototype quickly, and work across a wide range of customer environments without heavy setup.
@@ -0,0 +1,3 @@
+# RAGs
+ 
+Retrieval-Augmented Generation (RAG) is a pattern where relevant documents or data are fetched from a knowledge source and injected into a model's context before generating a response. This gives the model access to customer-specific or up-to-date information without requiring fine-tuning. RAG is one of the most common patterns FDEs implement when building AI features on top of a customer's proprietary data.
@@ -0,0 +1,3 @@
+# React
+ 
+React is a JavaScript library for building user interfaces using a component-based model. Each component manages its own state and rendering logic, and components are composed to build complete interfaces. React is one of the most common frontend frameworks in production (especially for building AI-powered apps), so familiarity with it makes it easier to contribute to or extend existing customer frontends quickly.
@@ -0,0 +1,3 @@
+# Regression Testing
+ 
+Regression testing for AI systems involves running a set of test cases against a model or prompt to verify that a change has not degraded behavior relative to a previous baseline. Unlike traditional software tests, AI regression tests often use example inputs and expected output properties evaluated by another model or human review.
@@ -0,0 +1,3 @@
+# Requirements Gathering
+ 
+Requirements gathering is the process of collecting and documenting what a system needs to do, both functionally and from a non-functional standpoint (performance, security, reliability). Good requirements come from talking with stakeholders, observing real workflows, and surfacing unstated assumptions before they become costly changes mid-build.
@@ -0,0 +1,3 @@
+# ROI & AI Impact
+ 
+Understanding return on investment (ROI) for AI projects means being able to quantify how an AI system creates value, whether through cost savings, productivity improvements, revenue growth, or risk reduction. It also means being honest about what AI can realistically deliver. FDEs who can frame AI work in business terms help customers build confidence in the investment and avoid overselling what the technology can do.
@@ -0,0 +1,3 @@
+# Roles & Responsibilities
+ 
+An FDE handles a wide range of tasks across the software lifecycle, from discovery and scoping to building and shipping working software inside customer environments. They often act as the technical lead on engagements, translating business requirements into real systems while communicating tradeoffs to non-technical stakeholders. Unlike a traditional software engineer, the role blends customer-facing work with hands-on building.
@@ -0,0 +1,3 @@
+# Security
+ 
+Cybersecurity encompasses a set of techniques for protecting applications, data, and infrastructure from unauthorized access, misuse, or attack. For AI systems, there are additional concerns like prompt injection, model abuse, and unintended data leakage through model outputs.
@@ -0,0 +1,3 @@
+# Shell / Bash
+ 
+Bash is a command-line shell and scripting language available on most Unix-like systems. Shell scripts let you automate repetitive tasks, manage files, configure systems, and chain together command-line tools. Being fluent in Bash allows FDEs to move fast in terminal environments, debug deployment issues quickly, and write lightweight automation without reaching for a heavier tool.
@@ -0,0 +1,3 @@
+# Software Architecture
+ 
+Software architecture is the high-level structure of a software system, including how components are organized, how they interact, and what principles guide those design decisions. Common patterns include layered architecture, microservices, event-driven design, and domain-driven design. FDEs need to quickly understand a customer's architecture and make decisions that fit within it, or clearly articulate why a different approach is needed.
@@ -0,0 +1,3 @@
+# Spark
+ 
+Apache Spark is a distributed computing framework for processing large datasets in parallel across a cluster. It supports batch processing, streaming, SQL queries, and machine learning through a unified API. Customers with large-scale data operations often use Spark as part of their data infrastructure, and knowing it makes it possible to work with or extend their existing pipelines.
@@ -0,0 +1,3 @@
+# SQL
+ 
+SQL, or Structured Query Language, is the standard language for interacting with relational databases. It is used to create, read, update, and delete records, and to define the structure of tables and their relationships. FDEs regularly need to query customer databases, understand data models, and sometimes debug or optimize slow queries as part of investigating production issues.
@@ -0,0 +1,3 @@
+# Stakeholder Management
+ 
+Stakeholder management is the practice of identifying the people affected by a project, understanding their interests and concerns, and keeping them informed and aligned throughout delivery. It includes managing expectations, handling conflicting priorities, escalating blockers, and building trust over time.
@@ -0,0 +1,3 @@
+# System Design
+ 
+System design is the process of defining the components, data flows, and infrastructure needed to build a scalable and reliable system. It involves decisions around databases, caching, load balancing, APIs, and service boundaries. For FDEs, system design often happens under time pressure and with incomplete information, so knowing common patterns well makes it possible to move quickly without making costly mistakes.
@@ -0,0 +1,3 @@
+# Technical Scoping & Sequencing
+ 
+Technical scoping involves breaking a project into discrete tasks, estimating their complexity, and identifying dependencies. Sequencing means ordering those tasks logically, starting with the highest-risk or most uncertain parts. A well-scoped and sequenced project is easier to track and deliver on time, and gives the customer visibility into what is being built and in what order.
@@ -0,0 +1,3 @@
+# Technical Writing
+ 
+Technical writing is the practice of producing clear, accurate, and useful documentation for software systems. This includes API docs, architecture decision records, runbooks, onboarding guides, and design documents. Technical writing is especially important because good documentation is often what allows a customer to operate and extend a system after the engagement ends, without needing to call the FDE back for every question.
@@ -0,0 +1,3 @@
+# Terraform
+ 
+Terraform is an open-source infrastructure-as-code tool by HashiCorp that lets engineers define cloud resources in configuration files and provision or update them automatically. It works across multiple cloud providers and is the standard tool for managing infrastructure in a repeatable, version-controlled way. FDEs who can write Terraform can provision and tear down customer environments faster and more reliably than doing it manually through cloud consoles.
@@ -0,0 +1,3 @@
+# Tools & Functions
+ 
+Tools and functions are the mechanisms through which AI agents interact with the outside world. A tool might query a database, call an external API, run a code interpreter, or search the web. In practice, tools are defined as schemas the model can invoke, and the application handles executing the actual function and returning the result. Designing good tool interfaces is a significant part of making agents reliable.
@@ -0,0 +1,3 @@
+# Tradeoffs: Scope, Speed, Quality
+ 
+Every project involves tradeoffs between scope (how much is built), speed (how fast it is delivered), and quality (how well it holds up over time). Reducing scope can speed things up without sacrificing quality. Cutting corners on quality can speed things up in the short term but creates problems later. FDEs need to understand and communicate these tradeoffs clearly, helping customers make informed decisions rather than just agreeing to everything and delivering less than expected.
@@ -0,0 +1,3 @@
+# Vector DBs
+ 
+Vector databases store high-dimensional vector embeddings and support efficient similarity search. They are a core component of RAG systems and semantic search applications, where the goal is to find content semantically similar to a query rather than matching keywords exactly.
@@ -0,0 +1,3 @@
+# Vibe Coding
+ 
+Vibe coding refers to using AI-assisted tools to write, edit, and iterate on code through natural language interaction, often at a higher level of abstraction than traditional coding. Instead of writing every line manually, the developer describes intent and guides the AI to produce working code, reviewing and refining the output. Vibe coding tools can significantly accelerate the productivity of FDEs, enabling them to work under tight delivery timelines.