AI-Enabled Technology Leadership

Configure and verify a local workspace for Python, TypeScript, containers, and Git.

Use a feature-branch and pull-request workflow to make a traceable code change.

Implement typed Python data models for a capstone domain object.

Write an automated unit test for a Python service function.

Implement a typed TypeScript function that consumes a JSON response.

Inspect an HTTP request and response to diagnose an API integration problem.

Load environment-specific configuration without committing secrets.

Record a technical decision in a concise architecture decision record.

Model the platform’s core resources using REST semantics.

Implement a FastAPI endpoint from an OpenAPI contract.

Validate API input and return consistent error responses.

Design a normalized PostgreSQL schema for users, documents, conversations, and approvals.

Write an indexed SQL query for a common platform access pattern.

Use a database transaction to preserve a cross-table invariant.

Implement a Server-Sent Events endpoint that emits progress for a long-running task.

Apply a cache-aside pattern with explicit invalidation to a read-heavy endpoint.

Partition the capstone into bounded services with explicit responsibilities.

Choose between synchronous and asynchronous communication for a service interaction.

Apply CAP and consistency trade-offs to a capstone data operation.

Define a versioned event contract for document ingestion or agent-task processing.

Publish and consume a versioned event using Python and Amazon SQS.

Make an event consumer idempotent under duplicate delivery.

Model a multi-service approval workflow as a saga.

Implement a circuit breaker around one synchronous dependency and verify its open-state behavior.

Classify representative use cases as supervised, unsupervised, reinforcement, or generative learning and justify each classification.

Trace how tokens, embeddings, attention, and generation interact during transformer inference.

Compare candidate language models using quality, latency, privacy, context, and cost criteria.

Construct a prompt that produces output conforming to a specified schema.

Calculate the approximate token cost and latency budget for an LLM interaction.

Call an LLM API from a FastAPI service with controlled generation parameters.

Create a small evaluation set with expected properties rather than exact reference wording.

Score model responses with task-specific quality and safety criteria.

Select a document chunking strategy based on document structure and query type.

Generate embeddings for document chunks and store them with relevant metadata.

Implement metadata- and authorization-filtered similarity search using PostgreSQL vector capabilities.

Compare semantic, keyword, and hybrid retrieval on representative queries.

Construct a grounded generation prompt from retrieved evidence.

Attach verifiable source citations to a generated answer.

Measure retrieval quality with recall-oriented cases and recall-at-k.

Diagnose whether a poor RAG answer originates in ingestion, retrieval, or generation.

Create a threat model covering identities, data flows, LLM inputs, retrieved content, and planned agent tools.

Enforce authenticated API access using standards-based tokens.

Apply role- and resource-based authorization to one API capability.

Retrieve an application secret from AWS Secrets Manager at runtime.

Implement and test one mitigation for a direct or indirect prompt-injection attack against the RAG flow.

Configure timeouts and bounded retries for a remote dependency.

Trace one request across API handling, retrieval, event processing, and model calls.

Define a service-level objective and an actionable alert for a critical user journey.

Decide whether a use case requires a deterministic workflow or an autonomous agent.

Define a constrained tool schema for an enterprise action.

Implement a single-agent tool-calling loop with bounded iterations.

Persist the minimum task state needed to resume an interrupted agent run.

Expose one approved enterprise capability through a Model Context Protocol server.

Connect an agent client to an MCP tool under explicit permission boundaries.

Insert human approval before an agent performs a consequential action.

Evaluate an agent run for task success, tool correctness, cost, and unsafe behavior.

Decompose the web interface into reusable Next.js components.

Create a responsive page shell that meets basic keyboard-navigation requirements.

Build a typed, authenticated frontend client from the platform’s API contract.

Represent loading, success, empty, and failure states for an AI request.

Render grounded answers with usable citations and uncertainty cues.

Consume the Server-Sent Events stream to display progress for a long-running task.

Implement an approval interface for a consequential agent action.

Write a component test for a critical user interaction.

Map platform components to appropriate AWS compute, data, messaging, identity, and observability services.

Build a minimal production-style backend image and publish its versioned artifact to Amazon Elastic Container Registry.

Deploy and expose the backend on Amazon EKS using supplied Deployment, Service, and Ingress manifests.

Deploy the Next.js frontend with managed AWS hosting and configure its production API endpoint.

Express one AWS environment component as reusable Terraform configuration.

Configure a GitHub Actions pipeline to test and build a service on each change.

Promote a versioned release through a controlled deployment step.

Execute a Kubernetes rollback after detecting a failed release.

Assess organizational readiness across data, technology, talent, process, risk, and adoption dimensions.

Choose build, buy, or partner for an AI capability using explicit decision criteria.

Design a cross-functional AI product operating model with clear decision rights.

Translate responsible-AI risks into lifecycle controls and accountable owners.

Create an adoption scorecard covering usage, user value, quality, risk, and economics.

Model the unit economics and scaling sensitivities of the proposed AI service.

Create a 30–60–90-day roadmap that sequences technical delivery, governance, stakeholder engagement, and workforce adoption.

Craft an executive narrative that connects strategic intent, evidence, trade-offs, and the requested decision.

Demonstrate a deployed end-to-end journey from authenticated query to cited answer.

Demonstrate an approval-controlled agent journey using an MCP-connected tool.

Execute an automated end-to-end acceptance test spanning the API, UI, and event-processing path.

Inject a controlled dependency failure and document the platform’s observed recovery behavior.

Run the capstone evaluation suite and determine whether retrieval, generation, agent, latency, and cost thresholds are met.

Apply a production-readiness checklist and prioritize the most important release blockers.

Assemble a concise architecture dossier from the accumulated diagrams and decision records, including AWS portability trade-offs.

Deliver a time-boxed executive capstone pitch covering the investment case, risks, operating model, and transformation roadmap.