Software, AI, and Fullstack Engineering

Define validated API request and response contracts with Pydantic models.

Organize FastAPI endpoints into routers with injected dependencies.

Implement asynchronous PostgreSQL access with SQLAlchemy.

Create and apply versioned database migrations with Alembic.

Model a knowledge-source record and its ingestion state as relational tables.

Return consistent HTTP errors through centralized exception handling.

Write isolated API tests with pytest and dependency overrides.

Inspect an endpoint contract and response using the generated OpenAPI documentation.

Explain how tokens, context windows, temperature, and output limits affect an LLM request.

Distinguish text generation, embedding, retrieval, and classification within an AI application.

Call a free-tier language-model API from the FastAPI backend.

Constrain an LLM response to a validated structured-output schema.

Implement retry behavior with exponential backoff for transient model-provider failures.

Handle provider rate limits without exposing internal errors to the client.

Implement a provider interface that allows one model service to be replaced with another.

Calculate whether a test workload fits within a model provider's free-tier quota.

Validate an uploaded knowledge-base file by type, size, and filename.

Extract text from a PDF document while preserving page metadata.

Convert HTML or Markdown support content into normalized plain text.

Split normalized content into chunks with source and position metadata.

Compare two chunking configurations using representative support documents.

Generate vector embeddings for a batch of text chunks.

Make repeated ingestion of the same source idempotent.

Record and expose ingestion progress and failure states.

Interpret cosine similarity as a measure for ranking embedding vectors.

Create a pgvector-backed schema for chunks, embeddings, and searchable metadata.

Store generated embeddings and their source metadata in PostgreSQL.

Implement top-k semantic retrieval for a customer question.

Restrict retrieval results using organization and source metadata filters.

Combine PostgreSQL full-text search with vector similarity in a hybrid query.

Apply a lightweight reranking step to retrieved candidates.

Write retrieval tests using questions with known relevant sources.

Construct a RAG prompt that separates system rules, retrieved evidence, and the user question.

Generate an answer using only retrieved knowledge-base evidence.

Map claims in a generated answer to source citations returned by the retrieval layer.

Implement an insufficient-evidence response when retrieval confidence is low.

Select recent conversation messages within a fixed context budget.

Rewrite a context-dependent follow-up message as a standalone retrieval query.

Stream generated answer tokens from FastAPI to the browser.

Capture a trace containing the query, retrieved chunks, prompt version, and model response.

Persist customer conversations and messages without mixing organization data.

Classify a support message into a validated intent taxonomy.

Assign an urgency level from explicit support-policy criteria.

Generate a concise structured summary of a customer conversation.

Apply deterministic rules to decide when a conversation requires human handoff.

Create API endpoints for an agent to list and update escalated tickets.

Record an agent's correction to an AI classification or answer.

Use recorded agent feedback to identify a concrete improvement to a prompt or retrieval rule.

Generate TypeScript API types from the backend's OpenAPI contract.

Build a knowledge-source upload view that displays ingestion progress.

Implement a chat interface that renders streamed responses incrementally.

Render answer citations as links to their source document and location.

Add answer-feedback controls and submit their data to the backend.

Build an agent inbox for reviewing and resolving escalated conversations.

Present recoverable UI states for timeouts, rate limits, and failed ingestion.

Verify keyboard navigation and accessible status announcements in AI-driven views.

Create a small version-controlled evaluation set of support questions and expected sources.

Calculate retrieval recall at k on the evaluation set.

Score generated answers with a documented rubric for correctness, groundedness, and citation quality.

Run a repeatable evaluation and compare two retrieval or prompt configurations.

Diagnose one failed evaluation by tracing it to ingestion, retrieval, prompting, or generation.

Test the application against prompt-injection attempts embedded in uploaded content.

Validate an authentication token and enforce organization-level authorization in FastAPI.

Prevent sensitive customer data and secrets from appearing in application logs.

Containerize the FastAPI service with a reproducible production build.

Configure continuous integration to run formatting, type checks, and automated tests.

Deploy the frontend, API, and pgvector database within documented free-tier constraints.

Add structured request logging with a correlation identifier across the API workflow.

Create a production smoke test for upload, retrieval, answer generation, and handoff.

Write an architecture document explaining key choices, limitations, and scaling trade-offs.

Record a concise product demonstration that proves the capstone's core workflow.

Explain the system's RAG pipeline, evaluation results, security controls, and personal implementation decisions in a mock technical interview.