Senior Staff AI Application Engineer

What matters most

• Architecting Framework-Agnostic Internal AI Platforms

  Serve as senior technical owner of the shared AI platform, creating durable abstractions and interfaces across agent frameworks (such as LangGraph and Bedrock AgentCore) and model providers so underlying tech can swap without rewriting applications.

• Automating Verification, Quality Gates, and Governance

  Enforce engineering, security, and compliance standards via automated CI/CD checks, machine-readable interface specifications, and evaluation gates that prevent non-deterministic regression before code enters production.

• Designing Long-Term Platform Contracts and Migration Paths

  Establish rigorous public interfaces, strict semantic versioning, and deprecation strategies across shared components, ensuring dozens of consumer applications avoid breaking changes and interface drift as the core evolves.

• End-to-End Hands-On Prototyping and Selective Harvesting

  Implement end-to-end applications spanning React front ends, Python back ends, and AI agents to validate platform capabilities, harvest reusable patterns into shared libraries, and unblock key business use cases.

Likely challenges to think through

• Balancing Framework Agnosticism with Feature Velocity

  Third-party agent frameworks and LLM APIs evolve rapidly, making stable abstraction layers prone to leaky interfaces or premature lowest-common-denominator limitations. Prepare to explain exact criteria for when to abstract a capability versus letting it sit in application space, using formal decision records.

• Enforcing Rigid Engineering Discipline Across Heterogeneous Teams

  Data scientists prioritizing fast experimentation often resist rigid static typing, schema contracts, and strict release gates. Prepare to demonstrate how to automate compliance via code generation, CI tooling, and templates that streamline developer experience rather than imposing manual friction.

• Implementing Automated Release Gates for Non-Deterministic AI Behavior

  Evaluating LLM applications and agent trajectories deterministically in automated release pipelines is difficult due to model variance and latency. Prepare concrete test harnesses, synthetic evaluation benchmarks, and regression metric thresholds that safely gate deployments.

Topics to prepare

• Durable Abstraction and Isolation Boundaries for Agent Frameworks

  The posting explicitly demands designing isolation boundaries so third-party technologies like agent frameworks and model providers are confined to replaceable components. Revise how to define common interfaces across contrasting frameworks (e.g., LangGraph vs. AWS Bedrock AgentCore or OpenAI Agents SDK) without leaking framework-specific mechanics. Practice by drafting an Architectural Decision Record (ADR) detailing an abstract agent runtime interface, defining what is exposed, what is private, and why specific capabilities were deliberately excluded.

• Evaluation-Driven Development and CI/CD Quality Gates for LLMs

  The role requires evaluation-driven development at depth and automated verification in the release path to prevent behavioural regression. Review methodologies for evaluating non-deterministic LLM pipelines (RAG retrieval quality, tool-calling correctness, and structured outputs). For revision, design a release-gate architecture diagram and test harness specification that scores candidate model outputs against baseline assertions and automatically halts deployment if quality metrics degrade.

• Platform Versioning, Backward Compatibility, and Safe Deprecation

  A core accountability is owning the platform's public interfaces and managing migration paths so dependent applications do not break as underlying components evolve. Revise API contract lifecycle management, semantic versioning principles, and structural compatibility enforcement (e.g., via OpenAPI schemas and automated contract tests). Formulate a concrete three-stage deprecation policy (announce, migrate, remove) for breaking changes in a shared Python/TypeScript library.

• Declarative Configuration vs. Executable Code Boundaries

  The posting explicitly highlights maintaining the boundary between declarative configuration (stating what) and executable code (implementing how) to avoid configuration turning into untyped, unmaintainable mini-languages. Revise schema validation strategies (such as Pydantic or JSON Schema) for config-driven user interfaces and agent execution workflows, defining clear rules for when logic must reside in code rather than parameters.

Skills to revise

• Strict Static and Structural Typing in Python (mypy/Pyright)

  The posting explicitly requires expert Python with strict static and structural typing. Implement an abstract agent base class and tool execution interface in Python using Protocols (typing.Protocol), generics, and strict mypy/Pyright verification. Ensure the implementation handles structured outputs and tool definitions with complete compile-time type safety and zero typing errors under strict mode.

• Developing Framework-Agnostic Agent Implementations

  The job requires demonstrable experience running the same agent logic unmodified across distinct frameworks (such as LangGraph and AWS Bedrock AgentCore). Build a simple goal-oriented agent with tool calling and RAG retrieval using an abstract interface, then implement two interchangeable driver adapters (e.g., one with LangGraph and one using native SDKs) that execute identical prompt workflows and return standardized responses.

• Automated Contract Testing and OpenAPI Code Generation

  The posting specifies OpenAPI schema design, generated clients, and contract-testing across CI/CD pipelines. Write an OpenAPI 3.1 specification for an AI inference orchestration service, set up automated client generation in TypeScript, and configure a GitHub Actions workflow that executes spectral linting and contract validation to fail builds on breaking schema changes.

• Reviewing Cloud Infrastructure and Access Boundaries (Terraform)

  While not authoring infrastructure directly, the posting explicitly mandates fluent reading and review of Terraform execution plans and boundary-level IAM access policies. As an exercise, review a sample Terraform plan provisioning AWS Lambda, Amazon Aurora, S3, and Amazon Bedrock, identifying least-privilege violations, unconstrained IAM wildcard actions, and missing OpenTelemetry tracing configs.

• Prepare a Platform Architecture and Abstraction Retrospective

  Prepare a structured walkthrough of a real shared library, framework, SDK, or developer platform you owned that other teams depended on. Explicitly cover an instance where an early abstraction choice proved flawed, the measurable cost to consumers, and the concrete technical strategy used to correct and migrate the interface without breaking dependent production systems.

• Build a Cross-Framework AI Agent Abstraction Prototype

  Construct a working prototype demonstrating a durable, framework-independent agent contract that runs the same core agent logic unmodified across two runtimes (such as LangGraph and AWS Bedrock AgentCore or OpenAI Agents SDK). Validate that agent tool-calling, state transitions, and evaluation outputs remain consistent across both backends to showcase isolation boundary design.

• Design an Evaluation-Driven CI/CD Quality Gate Specification

  Draft a CI/CD pipeline architecture document specifying automated quality evaluations for non-deterministic LLM and RAG workflows. Include defined test suites for retrieval accuracy, structured output validation, latency/cost thresholds, and an automated policy that halts deployment if behavioral degradation is detected.

• Formulate a Shared Interface and Semantic Versioning Protocol

  Draft a mock platform interface specification using strict typing (mypy/Pyright) and OpenAPI 3.1 schema definitions. Detail a practical versioning and deprecation plan (announce, migrate, remove) that demonstrates how to publish breaking schema updates while preventing version divergence and interface drift across downstream applications.

• Conduct a Mock Infrastructure Review for Cloud Boundaries and Least Privilege

  Inferred preparation suggestion: Practice reviewing declarative Terraform plans and IAM policies for AWS services like Lambda, Aurora, S3, and Bedrock. Document concrete feedback identifying overly permissive wildcards, resource execution boundaries, and missing OpenTelemetry observability traces without taking on direct infrastructure authoring.

• Draft Strategic Architectural and Organizational Questions for the Team

  Prepare senior-level questions inquiring about the existing division between the Chief Data and Analytics Office and adjacent infrastructure or security functions, current patterns of version drift among internal data science consumers, and the platform's initial priorities across commercial, supply chain, or manufacturing domains.