Palantir FDE (Forward Deployed Engineer) Complete Guide: Role, Skills, and Customer Handling Strategies

Example: Manufacturing Company Ontology

Object Types:
  - Factory: location, capacity, utilization rate
  - Production Line: product type, speed, defect rate
  - Product: SKU, cost, quality grade
  - Supplier: lead time, reliability score

Links:
  - Factory --has--> Production Line
  - Production Line --produces--> Product
  - Product --supplied-by--> Supplier

07:30 - Check email/Slack before commuting
        - Review overnight customer issues, triage urgent items

08:30 - Arrive at customer site
        - Standup with customer IT team (15 min)
        - Share monitoring results from yesterday's pipeline deployment

09:00 - Data pipeline development
        - Write PySpark Transform code
        - Work on new data source (SAP) integration

11:00 - Business user workshop
        - Discuss dashboard requirements with supply chain manager
        - Identify need for new Ontology object types

12:00 - Lunch (with customer team)
        - Build informal relationships, uncover hidden needs

13:30 - Workshop app development
        - Build user interface with React/TypeScript
        - Connect Ontology Actions

15:00 - Internal Palantir sync
        - Discuss feature requests with HQ product team
        - Share similar use cases with other FDEs

16:00 - Demo preparation
        - Prepare demo scenario showing this week's progress to executives

17:00 - Executive demo
        - Show VP-level the time savings from pipeline automation
        - Propose next quarter expansion

18:30 - Daily review and documentation
        - Record today's progress, blockers, and tomorrow's plan

-- Compute time-based cumulative revenue
SELECT
  order_date,
  customer_id,
  amount,
  SUM(amount) OVER (
    PARTITION BY customer_id
    ORDER BY order_date
    ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
  ) AS cumulative_revenue,
  LAG(amount, 1) OVER (
    PARTITION BY customer_id
    ORDER BY order_date
  ) AS prev_order_amount,
  RANK() OVER (
    PARTITION BY EXTRACT(MONTH FROM order_date)
    ORDER BY amount DESC
  ) AS monthly_rank
FROM orders;

-- Traverse org chart hierarchy (Recursive CTE)
WITH RECURSIVE org_hierarchy AS (
  -- Base case: top-level managers
  SELECT
    employee_id,
    name,
    manager_id,
    1 AS depth,
    CAST(name AS VARCHAR(1000)) AS path
  FROM employees
  WHERE manager_id IS NULL

  UNION ALL

  -- Recursive case: subordinates
  SELECT
    e.employee_id,
    e.name,
    e.manager_id,
    oh.depth + 1,
    CAST(oh.path || ' > ' || e.name AS VARCHAR(1000))
  FROM employees e
  INNER JOIN org_hierarchy oh ON e.manager_id = oh.employee_id
)
SELECT * FROM org_hierarchy ORDER BY depth, name;

# PySpark pattern used in Foundry Transforms
from transforms.api import transform, Input, Output
from pyspark.sql import functions as F
from pyspark.sql.window import Window

@transform(
    output=Output("/datasets/clean/daily_metrics"),
    raw_orders=Input("/datasets/raw/orders"),
    raw_products=Input("/datasets/raw/products"),
)
def compute(output, raw_orders, raw_products):
    orders_df = raw_orders.dataframe()
    products_df = raw_products.dataframe()

    # Clean + Join + Aggregate
    result = (
        orders_df
        .filter(F.col("status") == "completed")
        .join(products_df, on="product_id", how="inner")
        .groupBy(F.date_trunc("day", F.col("order_timestamp")).alias("order_date"))
        .agg(
            F.count("order_id").alias("total_orders"),
            F.sum("revenue").alias("total_revenue"),
            F.countDistinct("customer_id").alias("unique_customers"),
            F.avg("revenue").alias("avg_order_value"),
        )
        .withColumn(
            "revenue_7d_avg",
            F.avg("total_revenue").over(
                Window.orderBy("order_date").rowsBetween(-6, 0)
            )
        )
        .orderBy("order_date")
    )

    output.write_dataframe(result)

ETL vs ELT Comparison:

ETL (Extract-Transform-Load):
  Source --Extract--> Staging --Transform--> Clean --Load--> Data Warehouse
  Pros: Storage efficient after transformation
  Cons: Reprocessing needed when transform logic changes

ELT (Extract-Load-Transform):
  Source --Extract--> Data Lake --Load--> Raw Storage --Transform--> Views/Tables
  Pros: Raw data preserved, flexible reprocessing
  Cons: Higher storage costs

Foundry Approach (ELT preferred):
  Source --> Data Connection --> Raw Dataset --> Transforms --> Clean Dataset --> Ontology

Star Schema vs Ontology Comparison:

Star Schema (Traditional):
          dim_customer
              |
  dim_product -- fact_orders -- dim_date
              |
          dim_store

Ontology (Foundry):
  Customer --places--> Order --contains--> Product
      |                   |
      +--located-in-->  Store <--shipped-from-- Warehouse

Key Differences:
- Star Schema: Analytics-focused, static structure
- Ontology: Operations-focused, dynamic relationships, executable Actions
- Ontology Objects can define Actions in addition to Properties

// Foundry Workshop widget pattern example
interface SupplyChainDashboardProps {
  factoryId: string;
  dateRange: DateRange;
  onAlertDismiss: (alertId: string) => void;
}

interface FactoryMetrics {
  utilization: number;
  defectRate: number;
  throughput: number;
  alerts: Alert[];
}

const SupplyChainDashboard: React.FC<SupplyChainDashboardProps> = ({
  factoryId,
  dateRange,
  onAlertDismiss,
}) => {
  const [metrics, setMetrics] = useState<FactoryMetrics | null>(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    async function fetchMetrics() {
      setLoading(true);
      try {
        const factory = await OntologyClient.getObject("Factory", factoryId);
        const lines = await factory.getLinkedObjects("hasProductionLine");
        const calculated = computeMetrics(lines, dateRange);
        setMetrics(calculated);
      } catch (error) {
        console.error("Failed to fetch metrics:", error);
      } finally {
        setLoading(false);
      }
    }
    fetchMetrics();
  }, [factoryId, dateRange]);

  if (loading) return <Spinner />;
  if (!metrics) return <ErrorState message="Unable to load data" />;

  return (
    <DashboardLayout>
      <MetricCard title="Utilization" value={metrics.utilization} unit="%" />
      <MetricCard title="Defect Rate" value={metrics.defectRate} unit="%" />
      <MetricCard title="Throughput" value={metrics.throughput} unit="units/hr" />
      <AlertList alerts={metrics.alerts} onDismiss={onAlertDismiss} />
    </DashboardLayout>
  );
};

# Ontology Action definition example in Foundry
from ontology_sdk import action, OntologyObject

@action(
    name="create_maintenance_order",
    description="Create equipment maintenance work order",
    parameters={
        "equipment_id": "string",
        "priority": "enum(HIGH, MEDIUM, LOW)",
        "description": "string",
        "scheduled_date": "datetime",
    },
)
def create_maintenance_order(params, context):
    equipment = context.ontology.get("Equipment", params["equipment_id"])

    if equipment.status == "DECOMMISSIONED":
        raise ValueError("Cannot create maintenance order for decommissioned equipment")

    order = context.ontology.create("MaintenanceOrder", {
        "equipment": equipment,
        "priority": params["priority"],
        "description": params["description"],
        "scheduled_date": params["scheduled_date"],
        "status": "PENDING",
        "created_by": context.current_user,
    })

    assignee = find_available_technician(
        equipment.location,
        params["priority"],
        params["scheduled_date"],
    )
    order.assign_to(assignee)
    notify_stakeholders(order, assignee)

    return order

# AIP LLM + Ontology integration pattern
def aip_supply_chain_assistant(user_query, context):
    """
    Convert natural language queries to Ontology lookups
    """
    # 1. Intent classification
    intent = classify_intent(user_query)
    # e.g., "Which factory had the highest defect rate last week?"

    # 2. Generate Ontology query
    if intent == "factory_defect_analysis":
        factories = context.ontology.search(
            "Factory",
            filters=[
                ("metrics.defect_rate", ">", 0),
                ("metrics.date", ">=", last_week_start),
            ],
            order_by="metrics.defect_rate DESC",
            limit=5,
        )

        # 3. Generate natural language response via LLM
        response = generate_response(
            template="factory_analysis",
            data=factories,
            user_query=user_query,
        )
        return response

    # 4. When action execution is needed
    if intent == "create_action":
        action_plan = plan_action(user_query, context)
        return request_confirmation(action_plan)

Customer Scenario: Real-time quality management for a global manufacturer

Data Sources (20 factories worldwide):
  IoT Sensors --> Kafka --> Foundry Streaming
  MES Systems --> API Connector --> Foundry Batch
  SAP --> Magritte Sync --> Foundry Batch

Processing Layers:
  Raw Layer:        Original data (preserved)
  Clean Layer:      Cleaned/standardized (Transforms)
  Semantic Layer:   Ontology mapping
  Application Layer: Workshop apps, dashboards

Scale:
  - Daily data:         ~50TB
  - Real-time events:   ~100K events/sec
  - Ontology objects:   ~500M objects
  - Concurrent users:   ~5,000

Batch Processing (Transforms):
  Cadence: Hourly or daily
  Best for: Daily reports, weekly analytics, historical data reprocessing
  Technology: PySpark, SQL Transforms

Stream Processing (Foundry Streaming):
  Cadence: Real-time (sub-second)
  Best for: Anomaly detection, real-time alerts, live dashboards
  Technology: Kafka, Spark Streaming

Lambda Architecture (Palantir Pattern):
  Batch Layer:   Accurate historical analysis (latency acceptable)
  Speed Layer:   Real-time approximations (slight accuracy trade-off)
  Serving Layer: Unified batch + real-time results

Foundry Data Governance Essentials:

1. Access Control (RBAC + ABAC):
   - Organization --> Project --> Dataset --> Column level
   - Marking-based access control (PII, Confidential, etc.)

2. Data Lineage:
   - Automatic input/output tracking for all Transforms
   - Traceable from data source to final consumption

3. Audit Logging:
   - Records who accessed what data and when
   - Regulatory compliance evidence (GDPR, HIPAA)

4. Data Quality:
   - Health Checks: Automated quality monitoring
   - Expectations: Define and validate data rules

5-Day Domain Immersion Framework:

Day 1: Big Picture
  - Read industry overview reports (McKinsey, Gartner)
  - Analyze the customer's 10-K report
  - Compile glossary of 50 key terms

Day 2: Process Mapping
  - Understand 3-5 core business processes
  - Draw As-Is process diagrams
  - Formulate pain point hypotheses

Day 3: Data Landscape
  - Inventory all systems in use (ERP, CRM, MES, etc.)
  - Map data flow diagrams
  - Identify data quality issues

Day 4: Stakeholder Interviews
  - C-level: Strategic goals
  - Middle management: Operational challenges
  - Frontline workers: Daily frustrations

Day 5: Value Hypothesis
  - Identify 3 Quick Wins
  - Roadmap 2-3 medium-term projects
  - Estimate ROI (time savings, cost reduction, revenue increase)

Bad Example:
  Customer: "The data isn't coming in real-time"
  FDE: "Let me check the Kafka connector configuration" (jumping to tech solution)

Good Example:
  Customer: "The data isn't coming in real-time"
  FDE: "What's the reason you need this data in real-time?
        What decisions does it affect?"
  Customer: "When defects happen on the factory line, we need to
            stop within 30 minutes, but currently we don't find
            out until the next day"
  FDE: "So quality anomaly detection is the core need. For 30-minute
        alerting, which sensor data is most critical?"

Active Listening Techniques:

1. Reflecting:
   Customer: "It takes 8 hours every week to create this report"
   FDE: "So you're spending 8 hours per week on report creation"

2. Clarifying:
   "Of those 8 hours, which part takes the most time?"

3. Summarizing:
   "To summarize, data collection takes 3 hours, cleaning takes
    2 hours, and visualization takes 3 hours"

4. Emotional Recognition:
   "That process must be quite exhausting"

Open Questions - Exploration phase:
  "What's your biggest data-related challenge right now?"
  "What would the ideal state look like?"
  "What's the most frustrating part of this process?"

Closed Questions - Confirmation phase:
  "Do you need a daily trend chart on this dashboard?"
  "Would an hourly data refresh cycle be sufficient?"
  "Should approval authority be limited to team lead level?"

5 Why Technique - Root cause exploration:
  1. "Why are reports completed late?"
     --> "Because data collection takes too long"
  2. "Why does data collection take too long?"
     --> "Because we have to manually extract from 5 systems"
  3. "Why is it manual?"
     --> "Because the systems aren't connected to each other"
  4. "Why aren't they connected?"
     --> "Each department independently adopted their own systems"
  5. "Why did they adopt independently?"
     --> "There was no central data strategy"
  Root cause: Lack of data governance --> Core value proposition for Foundry

How to practice:
  - Never interrupt while the customer is speaking
  - Take notes and capture key points
  - Show you're listening through non-verbal cues (nodding, eye contact)
  - After they finish, repeat key points to confirm understanding

Example:
  Customer: "The dashboard we deployed last week is broken every morning.
            Our VP checks this dashboard first thing every morning,
            and I have to call IT every time to rebuild it.
            I'm really losing trust in this."

  FDE: "So the dashboard hasn't been displaying properly each morning,
       and you've had to contact IT every time before your VP's review.
       And this repeated situation has been impacting trust?"

Empathy Templates:
  - "I completely understand how frustrating that must be"
  - "Having that happen every morning must be really stressful"
  - "Being in that situation in front of your VP must have been difficult"

Note: Empathy is not agreement
  - Good: "I understand that situation was uncomfortable for you"
  - Bad: "Yes, our system is really terrible" (excessive self-deprecation)

Principles of a Genuine Apology:
  - Don't make excuses
  - Be specific about what you're apologizing for
  - Take responsibility

Good Apology:
  "I'm sincerely sorry for the dashboard stability issues causing
   daily inconvenience. We should have done more thorough testing
   before deployment."

Bad Apology:
  "I'm sorry, but the original data source had issues..."
  (An apology with excuses isn't an apology)

Resolution Template:

Immediate Action (within 24 hours):
  "I'll fix the dashboard refresh schedule error today.
   I'll verify correct operation before 7 AM tomorrow
   and update you with the results."

Short-term Improvement (within 1 week):
  "By end of this week, I'll add automated health checks
   to the dashboard so it auto-recovers when issues arise."

Long-term Prevention (within 1 month):
  "I'll build an automated testing pipeline for all dashboards
   before deployment to prevent this type of issue from recurring."

Key: Always specify concrete timelines and owners

Post-Incident Root Cause Analysis:

RCA Report Structure:
  1. Incident Summary: What happened
  2. Timeline: When it started and was resolved
  3. Impact Scope: Who was affected and how severely
  4. Root Cause: Why it happened
  5. Immediate Action: How it was resolved
  6. Prevention: How to prevent recurrence

Example:
  Root Cause: Nightly data pipeline was scheduled in UTC,
              so processing wasn't complete by 8 AM local time.
  Prevention: Reschedule to complete by 4 AM local time,
              add completion notifications, create monitoring dashboard.

L - Listen:
  Listen completely. Take notes and capture key points.

A - Acknowledge:
  "I understand the issue you've described.
   The core concern is that data loading speed is slower than expected."

S - Solve:
  "I can solve this two ways.
   First, query optimization can immediately double the speed.
   Second, adding a caching layer can provide an additional 3x improvement."

T - Thank:
  "Thank you for bringing this to our attention.
   This helps us provide a better experience for all users."

Step 1: Secure a Safe Space
  - Move to a 1-on-1 setting if possible
  - Avoid public embarrassment
  - On video calls, minimize participants

Step 2: Listen and Acknowledge Emotions
  - "It's completely understandable that you're upset"
  - Never respond defensively
  - Avoid "but" and "however"

Step 3: Establish Facts
  - Once emotions settle, confirm specific facts
  - "I want to understand precisely - could you walk me through
    what happened in order?"

Step 4: Present Immediate Options
  - Offer something actionable right away, even if small
  - "What I can do right now is A. B will be ready by tomorrow."

Step 5: Follow-up Management
  - Update before the promised time
  - Check in one week after resolution

Prevention Strategy:
  1. Agree on a clear SOW (Statement of Work) at project start
  2. MoSCoW prioritization: Must/Should/Could/Won't
  3. Define a change request process

Response Approach:
  Bad: "That's out of scope" (creates resistance)

  Good: "That's a great idea! Our current Phase 1 core goal is [X],
        and the feature you mentioned would be more effectively
        implemented in Phase 2. What if we successfully complete
        Phase 1 first, then prioritize it in the next phase?"

Key: Not "No" but "Yes, but later/differently"

Saying "No" Constructively:

Situation: Customer requests real-time (sub-second) analytics
          but data volume makes it technically infeasible

Bad: "That's impossible. The data is too large for real-time processing."

Good: "I understand the need for real-time analytics. With the current
      data volume (~50TB daily), sub-second response has technical
      limitations, but I'd like to propose two alternatives.

      Option 1: Real-time processing for only the top 5 critical KPIs
                --> Sub-second response achievable
      Option 2: Pre-aggregate all data every 5 minutes
                --> All KPIs available within 3 seconds

      Which direction would be more helpful for the business?"

Principle: Alternatives instead of impossibility, business impact instead of tech jargon

Situation: Customer has been delaying an architecture decision for 3 weeks

Nudging Strategies:

1. Set Deadlines:
   "If we can finalize by next Thursday, we can complete Phase 1 within Q2"

2. Cost Framing:
   "Each week of delay adds approximately X in operational costs"

3. Simplify Choices:
   "You've reviewed 10 options. I've narrowed it down to the 2 best
    fits for your situation. The difference between A and B is..."

4. Propose a Pilot:
   "Instead of deciding everything at once, what if we run a 2-week
    pilot with Option A and then decide based on results?"

5. Social Proof:
   "A company of similar size, X Corp, chose Option A and
    achieved 300% ROI within 3 months"

Situation: IT Director prioritizes security; Business Director wants speed

Facilitation Techniques:

1. Find Common Ground:
   "You both share the same goal of improving customer satisfaction, right?"

2. Visualize Each Position:
   Whiteboard both sides' requirements and concerns side by side

3. Make Trade-offs Explicit:
   "Prioritizing security delays launch by 2 weeks.
    Prioritizing speed means incomplete security review.
    A middle ground: apply core security controls in 1 week?"

4. Clarify Decision Authority:
   "Who is the final decision-maker?
    What are their criteria?"

5. Document Agreement:
   Formalize decisions in writing with all stakeholders' acknowledgment

RACI Matrix Example: Foundry Implementation Project

                    | Requirements | Data Integration | Testing | Go-Live |
--------------------|-------------|------------------|---------|---------|
Project Sponsor (VP)|      A      |        I         |    I    |    A    |
IT Director         |      C      |        A         |    A    |    R    |
Business Manager    |      R      |        C         |    R    |    C    |
FDE (Palantir)      |      C      |        R         |    R    |    R    |
Data Engineer       |      I      |        R         |    C    |    C    |

R = Responsible, A = Accountable
C = Consulted, I = Informed

High Power + High Interest:  Manage Closely (Key Players)
  --> CIO, VP of Operations
  Strategy: Weekly status reports, involve in decisions

High Power + Low Interest:   Keep Satisfied
  --> CEO, CFO
  Strategy: Monthly summary, involve only for major decisions

Low Power + High Interest:   Keep Informed
  --> Field analysts, data engineers
  Strategy: Weekly newsletter, Slack channel updates

Low Power + Low Interest:    Monitor
  --> General users
  Strategy: Quarterly updates, communicate as needed

What is a Champion:
  An internal advocate within the customer organization who actively
  promotes the value of Palantir/Foundry

Champion Identification Traits:
  - Actively asks questions and proposes ideas in meetings
  - Recommends Foundry usage to colleagues
  - Voluntarily provides feedback
  - Shares success stories with executives

Champion Development Strategy:
  1. Early Engagement: Build relationships from project start
  2. Exclusive Access: Share new features and roadmap first
  3. Skill Building: Provide advanced training
  4. Recognition: Formally acknowledge their contributions
  5. Networking: Connect them with Champions at other customer sites

Executive Sponsor Management Principles:

1. Their Time is Gold:
   - Keep meetings under 30 minutes
   - Convey only top 3 points
   - Use visual materials (charts, dashboards)

2. Communicate in Business Language:
   - Bad: "Spark cluster optimization improved query performance by 40%"
   - Good: "Report generation time dropped from 2 hours to 20 minutes,
            freeing 15 hours per week for the team to focus on analysis"

3. Report Risks Early:
   - The worse the news, the sooner it should be delivered
   - Always report problems paired with proposed solutions

4. Visualize Results:
   - Monthly ROI dashboard
   - Before/After comparison data
   - User satisfaction survey results

Weekly Update Email Structure:

Subject: [Project Name] Weekly Update - W12 (3/17-3/21)

1. Summary (3 lines max):
   Supply chain dashboard v2 deployed this week.
   Added filtering features based on user feedback.
   Inventory prediction model pilot starts next week.

2. Completed This Week:
   - Supply chain dashboard v2 production deployment (Done)
   - Training for 5 users conducted (Done)
   - SAP data integration testing (Done)

3. Next Week Plan:
   - Inventory prediction model pilot (3/24-3/28)
   - Executive demo preparation (3/28)

4. Risks/Blockers:
   - Waiting for SAP server access permissions (IT team approval needed)
   - Expected resolution: 3/25

5. Metrics:
   - Dashboard daily users: 45 (up 12 from last week)
   - Report generation time: 20 min (down 83% from previous 2 hours)

Slack Etiquette Guide:

DO:
  - Use threads actively (keeps channels organized)
  - Indicate urgency level (urgent/normal/FYI)
  - Specify expected response time for questions
  - Share outcomes for resolved issues

DON'T:
  - Mention people outside business hours (unless urgent)
  - Post the same message in multiple channels
  - Have long discussions in DMs when the team should see them
  - Send just "Hello" and wait (include your question immediately)

Recommended Channel Structure:
  palantir-general:    General communication
  palantir-technical:  Technical discussions
  palantir-urgent:     Urgent issues (notifications ON)
  palantir-demos:      Demo/presentation schedules

Effective Meeting Template:

Before Meeting:
  - Share agenda 24 hours in advance
  - Specify prep items per attendee
  - One-line meeting purpose summary

During Meeting:
  - Designate a timekeeper
  - Designate a note-taker
  - Allocate time per agenda item
  - Split inconclusive discussions into separate meetings

After Meeting (within 24 hours):
  - Share meeting notes
  - Action items: specify owner + deadline
  - Confirm next meeting date

FDE Demo Structure (15 minutes):

1 min: Hook
  "Last quarter, inventory shortages caused revenue losses of
   2 million. The solution I'll show today can reduce that by 80%."

3 min: Context
  "Let me first address 3 issues with the current inventory
   management process"
  (Visualize the customer's pain)

8 min: Live Demo
  - Always demo with real data (never dummy data)
  - Structure the flow around the customer's daily scenarios
  - "If situation A occurs..." scenario-based approach

2 min: Impact
  "With this dashboard, inventory shortage prediction moves
   3 days earlier, with estimated annual savings of 1.6 million"

1 min: Next Steps
  Present specific action items and timeline

Palantir FDE Interview Process:

Stage 1: Online Assessment (1-2 hours)
  - HackerRank-style coding test
  - 2-3 SQL + Python/Java problems
  - Data processing focus over pure algorithms

Stage 2: Phone Screen (45-60 min)
  - Technical interview: live SQL problem solving
  - Or brief system design discussion
  - "Why Palantir?" question almost guaranteed

Stage 3: Onsite (3-5 rounds, full day)

  Round 1: Coding (60 min)
    - Data processing problem in Python or Java
    - Based on real business scenarios
    - e.g., "Implement a logistics optimization algorithm"

  Round 2: SQL Deep Dive (60 min)
    - Complex query writing (Window Functions, CTEs)
    - Performance optimization discussion
    - Data modeling design

  Round 3: System Design (60 min)
    - Data pipeline architecture
    - Scalability and fault tolerance discussion
    - Foundry architecture understanding assessment

  Round 4: Case Study (60 min)
    - Customer scenario-based problem solving
    - "A manufacturer wants to reduce their defect rate"
    - Comprehensive evaluation of tech + business + communication

  Round 5: Behavioral (45 min)
    - STAR method answers
    - Customer experience, conflict resolution, leadership
    - Palantir values fit assessment

# Frequently tested pattern: Data Processing + Business Logic

# Problem: Supply Chain Delay Analysis
# Analyze order data to find the top 5 suppliers with worst delays
# and identify delay patterns by cause

import pandas as pd
from collections import defaultdict

def analyze_supply_chain_delays(orders_df):
    """
    Supply chain delay analysis function

    Parameters:
    - orders_df: DataFrame with columns
      [order_id, supplier_id, expected_date, actual_date,
       product_category, quantity, region]
    """
    # 1. Calculate delay days
    orders_df["delay_days"] = (
        pd.to_datetime(orders_df["actual_date"])
        - pd.to_datetime(orders_df["expected_date"])
    ).dt.days

    # 2. Filter delayed orders only
    delayed = orders_df[orders_df["delay_days"] > 0].copy()

    # 3. Supplier-level delay statistics
    supplier_stats = (
        delayed.groupby("supplier_id")
        .agg(
            total_delayed_orders=("order_id", "count"),
            avg_delay_days=("delay_days", "mean"),
            max_delay_days=("delay_days", "max"),
            total_affected_quantity=("quantity", "sum"),
        )
        .sort_values("avg_delay_days", ascending=False)
        .head(5)
    )

    # 4. Category-Region delay patterns
    pattern_analysis = (
        delayed.groupby(["product_category", "region"])
        .agg(
            delay_count=("order_id", "count"),
            avg_delay=("delay_days", "mean"),
        )
        .sort_values("delay_count", ascending=False)
    )

    # 5. Time-series delay trend
    delayed["month"] = pd.to_datetime(delayed["actual_date"]).dt.to_period("M")
    trend = (
        delayed.groupby("month")
        .agg(
            monthly_delays=("order_id", "count"),
            avg_monthly_delay=("delay_days", "mean"),
        )
    )

    return {
        "top_5_delayed_suppliers": supplier_stats,
        "delay_patterns": pattern_analysis,
        "monthly_trend": trend,
    }

-- Problem: Customer Segmentation
-- Classify customers into RFM segments based on last 90 days of purchases

WITH customer_rfm AS (
  SELECT
    customer_id,
    DATEDIFF(day, MAX(order_date), CURRENT_DATE) AS recency,
    COUNT(DISTINCT order_id) AS frequency,
    SUM(total_amount) AS monetary
  FROM orders
  WHERE order_date >= DATEADD(day, -90, CURRENT_DATE)
  GROUP BY customer_id
),
rfm_scores AS (
  SELECT
    customer_id,
    recency,
    frequency,
    monetary,
    NTILE(5) OVER (ORDER BY recency ASC) AS r_score,
    NTILE(5) OVER (ORDER BY frequency DESC) AS f_score,
    NTILE(5) OVER (ORDER BY monetary DESC) AS m_score
  FROM customer_rfm
)
SELECT
  customer_id,
  r_score,
  f_score,
  m_score,
  CASE
    WHEN r_score >= 4 AND f_score >= 4 AND m_score >= 4 THEN 'Champions'
    WHEN r_score >= 3 AND f_score >= 3 THEN 'Loyal Customers'
    WHEN r_score >= 4 AND f_score <= 2 THEN 'New Customers'
    WHEN r_score <= 2 AND f_score >= 3 THEN 'At Risk'
    WHEN r_score <= 2 AND f_score <= 2 THEN 'Lost'
    ELSE 'Others'
  END AS segment
FROM rfm_scores
ORDER BY monetary DESC;

Case Study Response Framework (BRIDGE):

B - Business Understanding
  "Let me first understand the customer's business.
   What are the key KPIs and the biggest current challenges?"

R - Requirements Gathering
  "To summarize the specific needs:
   1. Reduce defect rate from 3% to under 1%
   2. Cut detection time from 24 hours to 30 minutes
   3. Automate decision-making"

I - Investigation (data/tech environment)
  "What systems are currently in use,
   and what data is being collected?"

D - Design (solution architecture)
  "Using Foundry, I'd propose this design:
   Phase 1: Data integration (2 weeks)
   Phase 2: Real-time monitoring (3 weeks)
   Phase 3: Prediction model (4 weeks)"

G - Go-Live Plan
  "Run a pilot at 1 factory for 4 weeks,
   validate results, then expand to all factories"

E - Expansion
  "After initial success, expansion areas include:
   supplier quality management, predictive maintenance, demand forecasting"

STAR Response Template:

Question: "Tell me about a time a customer expressed dissatisfaction"

S (Situation):
  "At my previous company, I managed a data migration project
   for a global bank. The IT Director strongly expressed
   dissatisfaction about project delays."

T (Task):
  "My role was to identify the delay cause, restore customer trust,
   and get the project back on track."

A (Action):
  "1. I listened to the customer for 30 minutes, noting key concerns
   2. Within 24 hours, I delivered an RCA report and revised plan
   3. I introduced daily progress reports for transparency
   4. I brought in additional resources for parallel workstreams"

R (Result):
  "We recovered the delay within 2 weeks and completed on the original
   schedule. Customer satisfaction scored 4.8 out of 5, and we
   subsequently won 3 additional projects."

Strong Answer Structure:

1. Connect to Mission:
   "I deeply resonate with Palantir's mission to help the world's
   most important institutions. It's not just building software -
   it's about solving real-world problems."

2. FDE Role Appeal:
   "The FDE role at the intersection of technology and business
   perfectly matches my strengths. It's not just writing code -
   it's directly solving customer problems and seeing the
   value with my own eyes."

3. Connect to Personal Experience:
   "My experience at [previous role] directly communicating with
   customers while building technical solutions aligns perfectly
   with the FDE's core competencies."

Key Points:

1. Acknowledge AI Ethics Importance:
   "As AI is increasingly used in decision-making,
    fairness, transparency, and accountability are critical."

2. Understand Palantir's Approach:
   "Palantir advocates for Human-in-the-loop AI,
    where AI recommends but humans make final decisions."

3. Your Position:
   "The power of technology demands responsible use.
    As an FDE, I believe part of my role is guiding
    customers to use AI ethically."

Focus: SQL + Python + Data Engineering Basics

Week 1-2: SQL Mastery
  - LeetCode SQL 50 problems
  - Intensive Window Functions study
  - CTE and Recursive Queries practice
  - 2-3 problems daily

Week 3-4: Python Data Processing
  - Pandas essentials (merge, groupby, pivot, apply)
  - PySpark basics (DataFrame API)
  - Data cleaning patterns (null handling, type casting, deduplication)

Week 5-6: ETL/ELT Pipelines
  - Apache Airflow basics
  - Data warehouse concepts (Star Schema, Snowflake)
  - Build a simple ETL project

Week 7-8: Data Modeling
  - Normalization vs. denormalization
  - Dimensional Modeling (Kimball methodology)
  - Practice Ontology thinking (object-relationship design)

Focus: React/TypeScript + API + System Design

Week 9-10: React/TypeScript
  - Advanced React Hooks
  - TypeScript essentials (interfaces, generics, utility types)
  - Dashboard component building exercises

Week 11-12: Backend API
  - REST API design principles
  - Python FastAPI or Java Spring Boot
  - Auth patterns (OAuth, RBAC)

Week 13-14: System Design
  - Data pipeline architecture
  - Real-time vs. batch processing
  - Scalability patterns (partitioning, caching, queues)

Week 15-16: Cloud/Infrastructure
  - AWS/GCP core services
  - Docker/Kubernetes basics
  - CI/CD pipelines

Focus: Communication + Business + Palantir Platform

Week 17-18: Customer Handling Skills
  - HEARD/LAST framework practice drills
  - De-escalation role plays
  - Active Listening training

Week 19-20: Presentations/Demos
  - Storytelling structure learning
  - Technical demo practice (with real data)
  - Timing practice (15 min, 30 min, 60 min)

Week 21-22: Domain Knowledge
  - Deep dive into 1-2 target industries
  - Read industry reports (McKinsey, Deloitte)
  - Understand industry KPIs, processes, regulations

Week 23-24: Palantir Platform Study
  - Read Foundry official documentation thoroughly
  - YouTube: Palantir Tech Talks
  - Engage in community forums

Focus: Interview Practice

Week 25-26: Coding Interview Practice
  - SQL: 2 advanced problems daily
  - Python: Data processing problem focus
  - 2-3 system design mock interviews

Week 27-28: Case Study Practice
  - Apply BRIDGE framework
  - Mock interviews with peers (customer role play)
  - Prepare 3-5 industry-specific cases

Week 29-30: Behavioral Interview Practice
  - Prepare 10 STAR responses
  - Refine "Why Palantir" answer
  - Prepare for Ethical AI questions

Week 31-32: Final Review
  - Full mock interview (5 rounds)
  - Shore up weak areas
  - Confidence management, condition optimization

Purpose: Demonstrate Ontology design + data pipeline + dashboard skills

Tech Stack:
  - Python (PySpark) + SQL
  - React/TypeScript (dashboard)
  - PostgreSQL + Apache Spark

Implementation:
  1. Supply Chain Ontology Design
     - Object Types: Supplier, Order, Product, Warehouse
     - Links: supplies, contains, stored-in
     - Properties + Actions definition

  2. ETL Pipeline
     - CSV/API data sources --> Clean --> Analytics dataset
     - Apply PySpark Transforms patterns
     - Include data quality checks

  3. Dashboard
     - Real-time supplier performance monitoring
     - Delay prediction alerts
     - Drill-down analysis capability

GitHub Repo Should Include:
  - README: Explain design decision process
  - Architecture diagrams
  - Demo video (2-3 minutes)

Purpose: Demonstrate business analysis + customer communication skills

Presentation Format:
  - 3 industries (Manufacturing, Finance, Healthcare), 1 case each
  - 10-15 slides per case

Case 1: Global Manufacturer Quality Management
  - Problem: Defect rate 3% --> Target 1%
  - Data Analysis: Identify defect patterns
  - Foundry Solution Design
  - ROI: Annual savings of 500K

Case 2: Bank AML Monitoring
  - Problem: Fraud detection accuracy 60%
  - Data Analysis: Transaction pattern network
  - Foundry Solution Design
  - ROI: 50% false positive reduction

Case 3: Hospital Patient Flow Optimization
  - Problem: ER wait time 4 hours
  - Data Analysis: Patient pathway optimization
  - Foundry Solution Design
  - ROI: 50% wait time reduction

Purpose: Demonstrate real customer handling ability on video

3 Scenarios (5-7 minutes each):

Scenario 1: Angry Customer De-escalation
  - Setup: Dashboard outage causes failed executive report
  - FDE Role: Apply HEARD framework
  - Result: Immediate action + prevention plan presented

Scenario 2: Scope Creep Management
  - Setup: Third additional requirement request
  - FDE Role: Constructive No + Phase separation proposal
  - Result: Current scope agreement + future roadmap

Scenario 3: Executive Demo
  - Setup: 15-minute ROI demo for CFO
  - FDE Role: Storytelling-based presentation
  - Result: Phase 2 budget approval secured

Recording Tips:
  - Record role plays with a friend/colleague
  - Include self-analysis after each scenario
  - Explain "why I chose this approach"