Forward Deployed Engineering

Configure Python, Git, Docker Desktop, and the VS Code terminal on Windows and verify each installation.

Call a REST API from Python and extract fields from successful and error responses.

Trace data through a search–generation–decision workflow and distinguish the roles of Tavily, Amazon Bedrock, and Jev.

Create a Boto3 session and client using region and credential configuration supplied at runtime.

Invoke an Amazon Bedrock model with Boto3 and parse its response into application data.

Call the Tavily search API and normalize its results into a consistent evidence structure.

Define Pydantic models for a user request, a cited evidence item, and a typed decision response.

Integrate Jev behind a Python adapter that returns a typed decision with probability and confidence data.

Apply a confidence threshold that either accepts a Jev decision or routes it for human review.

Compose Tavily search, Bedrock synthesis, and Jev decision steps into a local Python workflow.

Implement a FastAPI POST endpoint that accepts a typed request and returns the workflow result.

Map invalid input, missing configuration, timeouts, and downstream service failures to appropriate HTTP responses.

Design a PostgreSQL schema for requests, evidence sources, model outputs, decisions, and processing status.

Insert and query workflow records from Python using parameterized SQL and explicit transactions.

Explain how embeddings, metadata filters, and similarity search retrieve evidence from a vector database.

Create a Weaviate collection with text and metadata properties, then insert and retrieve an evidence object.

Combine PostgreSQL workflow records with evidence retrieved from Weaviate for a single API request.

Write pytest tests that replace Bedrock, Tavily, and Jev calls with deterministic test doubles.

Containerize the FastAPI application and run it locally with environment-based configuration.

Configure the AWS CLI for temporary sandbox credentials and verify the active account, role, and region.

Choose between Lambda and ECS Fargate for a workload using duration, scaling, packaging, networking, and cost constraints.

Grant a compute workload least-privilege access to Bedrock and other required AWS resources with an IAM policy.

Expose a Lambda handler through API Gateway and validate a request from entry point to response.

Push an application image to Amazon ECR and run it with an ECS Fargate task definition and service.

Implement a Step Functions state machine that sequences tasks and uses retry, catch, and timeout behavior.

Design a VPC layout with public and private subnets, routes, security groups, egress controls, and an appropriate AWS Network Firewall boundary.

Draw and explain the project architecture across API Gateway, Lambda or Fargate, Step Functions, Bedrock, PostgreSQL, Weaviate, Tavily, and Jev.

Provision an RDS for PostgreSQL instance in private subnets and verify connectivity from the selected compute service.

Store external API credentials in AWS Secrets Manager and retrieve them at runtime without exposing them in logs.

Add CloudWatch structured logs and correlate events from one request across the workflow.

Deploy the integrated research-and-decision workflow in the interview sandbox using a repeatable checklist.

Run acceptance tests for a successful request, low-confidence decision, provider timeout, and unavailable database.

Diagnose a failed deployment by separating application, IAM, networking, configuration, and service-quota causes.

Deliver a five-minute project demonstration and justify design choices for security, reliability, scaling, latency, and cost.