Capstone β€Ί Capstone Build I: Foundation β€Ί Day 351

Day 351: Choosing and Scoping Your Capstone

Day 351 of 365 β€” Choosing and Scoping Your Capstone

Select, scope, and define a defensible production-grade Capstone AI project that synthesizes all 50 weeks of engineering discipline: data ingestion, vector retrieval, agent tool execution, automated evals, containerization, observability, and security hardening.

Course
Capstone
Category
Capstone Build I: Foundation
Reading time
β‰ˆ 35 min
Practical time
β‰ˆ 55 min
Lesson duration
1h 30m
Last verified
2026-08-30

Hands-on lab for this lesson

Lab files on GitHub: https://github.com/ai-roadmap-365/ai-roadmap-365.github.io/tree/main/labs/sections/capstone/day-351-choosing-and-scoping-your-capstone

  1. Get the hands-on files. Clone the labs repository once (you can reuse this clone for every lesson). This works on macOS, Linux, and Windows (PowerShell or WSL):
    git clone https://github.com/ai-roadmap-365/ai-roadmap-365.github.io.git
    cd ai-roadmap-365.github.io
  2. Open this lesson's lab. Move into the directory for this specific day. Every lab lives at the same predictable path β€” section / subsection / week / day:
    cd labs/sections/capstone/day-351-choosing-and-scoping-your-capstone
  3. Read the lab guide. Open `README.md` in that directory. It lists the exact commands, what each does, the expected output, and how to check your work β€” read it before running anything.
  4. Run it and check your work. Follow the README's "How to run" section: run the example first to see the finished result, then complete the numbered exercises in `starter/`, then run the tests. The tests pass (exit 0) only when your work is correct.
    bash tests/run_tests.sh   # or the test command named in the lab README

You can also open the lab as a local page (works offline, shows the file tree and expected output).

Learning objectives

By the end of this lesson you will be able to:

Prerequisites

Why this matters

Over the past 50 weeks (Days 1 to 350), you have mastered the complete spectrum of modern AI engineering:

  1. Programming Fundamentals & Python Architecture (Weeks 1–14)
  2. Data Engineering, SQL, Vector Mathematics & Embeddings (Weeks 15–28)
  3. Core Machine Learning & Deep Learning Foundations (Weeks 29–38)
  4. Large Language Models, Prompting & Transformers (Weeks 39–43)
  5. Advanced RAG, Knowledge Graphs & Vector Search (Weeks 44–46)
  6. Agentic Workflows, Tool Use & Multi-Agent Teams (Week 47)
  7. Containers, Cloud Deployments, MLOps & Production AI (Weeks 48–49)
  8. Securing AI Systems, PII Vaults & Red Teaming (Week 50)

The Capstone Project (Weeks 51 & 52) is not a toy tutorial or an abstract research exercise. It is your opportunity to build, evaluate, deploy, secure, and showcase a fully realized, production-grade Artificial Intelligence product that proves your end-to-end engineering excellence to employers, clients, and technical peers.

Choosing and scoping your project correctly on Day 351 is the single most critical predictor of success.

Capstone Project Archetypes and Pillars showing 3 Candidate Archetypes (Enterprise RAG Copilot, Autonomous Multi-Agent System, Real-Time Multimodal Assistant) and 6 Required Engineering Pillars

The idea in plain language

Think of scoping your Capstone like commissioning an architectural skyscraper:

Your Capstone must be a complete, defensible vertical slice: from raw data ingestion to hardened cloud serving, automated evaluation, and live interactive UI.

Historical background

Diagram: how the bar for an AI portfolio project moved between 2015 and today

Over the last decade of software and AI engineering education, project failure modes have evolved:

1. The Algorithm-Only Era (2015–2020)

Students trained PyTorch models in Jupyter notebooks, measuring test accuracy on clean Kaggle datasets. These projects lacked APIs, frontends, error handling, or deployment infrastructure.

2. The Wrapper Demo Era (2023–2024)

With the rise of commercial LLMs, developers built superficial single-file Streamlit wrappers making raw OpenAI API calls. These lacked custom data layers, evaluations, security firewalls, or cost controls.

3. The Modern Production AI Era (2025–Present)

Modern engineering teams expect full-lifecycle AI systems: hybrid vector retrieval, deterministic agentic tool execution, CI/CD automated evals, containerized serving, OpenTelemetry observability, and proactive security guardrails.

What it is β€” and what it is not

Let us establish clear boundaries for the Capstone:

What the Capstone Is:

Diagram: what belongs in a capstone and what does not

What the Capstone Is Not:

Diagram: comparing capstone project archetypes by what each demonstrates

+-------------------------------------------------------------------------------+
|                    CAPSTONE PROJECT ARCHETYPE COMPARISON                      |
+-------------------+-----------------------+-----------------------------------+
| Archetype         | Core AI Complexity    | Real-World Production Focus       |
+-------------------+-----------------------+-----------------------------------+
| 1. Enterprise RAG | Hybrid BM25 + Vector, | High retrieval accuracy, grounded |
|    Copilot        | Cross-Encoder Rerank  | citations, low hallucination rate |
| 2. Autonomous     | ReAct loop, tool      | Deterministic execution, state    |
|    Agent Platform | calling, memory store | recovery, sandbox tool safety     |
| 3. Real-Time      | Fast streaming LLM,   | Sub-second latency budget,        |
|    Assistant      | multimodal input      | token streaming, multi-turn state |
+-------------------+-----------------------+-----------------------------------+

Why it was created and what problems it solves

The structured scoping process on Day 351 prevents three catastrophic project pitfalls:

1. Eliminating Scope Creep via SMART Boundaries

By establishing quantitative SLAs upfront (e.g. p95 TTFT <= 400ms, Faithfulness >= 0.90, Monthly Token Cost <= $25), you prevent uncontrolled feature bloat.

Diagram: how an unbounded project grows and how a written scope stops it

2. De-risking Integration Bottlenecks Early

Building an end-to-end walking skeleton on Day 351 ensures that frontend, backend, vector database, and LLM APIs communicate before investing in complex business logic.

Diagram: a two-week capstone milestone cadence

3. Establishing Portfolio-Ready Engineering Evidence

A structured project with automated evaluation benchmarks, Dockerized deployment, and security manifests provides undeniable technical proof of seniority.

Diagram: what a portfolio reviewer looks for in a capstone

How it works

Let us inspect the complete Two-Week Capstone Execution Roadmap:

[WEEK 51: FOUNDATION & WORKING VERTICAL SLICE]
  β”œβ”€β”€ Day 351: Scope Definition, SMART Constraints, & Feasibility Scoring
  β”œβ”€β”€ Day 352: Architecture Specification & System Design Document
  β”œβ”€β”€ Day 353: Data Ingestion, Chunking Pipeline, & Vector Storage
  β”œβ”€β”€ Day 354: Core AI Reasoning, Structured Outputs, & Fast Router
  β”œβ”€β”€ Day 355: Agent Tool Calling, Sandbox Integration, & State Management
  β”œβ”€β”€ Day 356: Automated Evaluation Suite (RAG Triad, LLM-as-a-Judge)
  └── Day 357: Milestone 1 Review & Course Correction
           β”‚
           β–Ό (Working End-to-End Vertical Slice)
[WEEK 52: HARDENING, DEPLOYMENT, OBSERVABILITY & DELIVERY]
  β”œβ”€β”€ Day 358: Responsive UI, Streaming Chat, & Error Feedback
  β”œβ”€β”€ Day 359: Docker Containerization, Health Probes, & Cloud Deployment
  β”œβ”€β”€ Day 360: OpenTelemetry Observability & Multi-Tenant Cost Attribution
  β”œβ”€β”€ Day 361: Security Hardening, PII Vault, & Red Team Fuzzing
  β”œβ”€β”€ Day 362: Technical Documentation, API Reference, & Video Demo
  └── Days 363-365: Portfolio Showcase, Retrospective, & Graduation

Two-Week Capstone Milestone Execution Timeline showing Week 51 Foundation (Days 351-357) and Week 52 Delivery (Days 358-365)

An everyday analogy

Think of scoping your Capstone like planning an expedition across a mountain range:

Examples in practice

Let us build an automated Capstone Project Scoping & Feasibility Scorer in Python that evaluates project charters against the 6 mandatory engineering pillars and calculates feasibility metrics:

import json
from typing import Dict, Any, List, Tuple

class CapstoneScopingValidator:
    def __init__(self, project_charter: Dict[str, Any]):
        self.charter = project_charter
        self.pillars = [
            "data_ingestion",
            "core_ai_reasoning",
            "automated_evals",
            "cloud_deployment",
            "observability",
            "security_hardening"
        ]

    def validate_pillars(self) -> Tuple[bool, List[str]]:
        missing = []
        for p in self.pillars:
            if p not in self.charter.get("engineering_pillars", {}):
                missing.append(f"Missing mandatory pillar: {p}")
            elif not self.charter["engineering_pillars"][p].get("enabled", False):
                missing.append(f"Pillar disabled: {p}")
        return len(missing) == 0, missing

    def evaluate_feasibility(self) -> Dict[str, Any]:
        score = 100.0
        warnings = []

        # Check SLAs
        slas = self.charter.get("slas", {})
        if "p95_latency_ms" not in slas or slas["p95_latency_ms"] > 1000:
            score -= 15.0
            warnings.append("p95 latency SLA missing or exceeding 1000ms threshold")

        if "min_eval_accuracy" not in slas or slas["min_eval_accuracy"] < 0.80:
            score -= 15.0
            warnings.append("Evaluation accuracy target missing or below 80%")

        # Check pillar coverage
        valid_pillars, missing_pillars = self.validate_pillars()
        if not valid_pillars:
            score -= 10.0 * len(missing_pillars)
            warnings.extend(missing_pillars)

        # Determine Feasibility Grade
        grade = "EXCELLENT" if score >= 85 else ("VIABLE" if score >= 70 else "AT_RISK")

        return {
            "project_name": self.charter.get("title", "Untitled Capstone"),
            "feasibility_score": max(0.0, score),
            "feasibility_grade": grade,
            "warnings": warnings,
            "is_approved_for_build": score >= 70.0
        }

if __name__ == "__main__":
    charter = {
        "title": "Enterprise Financial Analyst Assistant",
        "archetype": "enterprise_rag",
        "slas": {"p95_latency_ms": 450, "min_eval_accuracy": 0.88, "monthly_budget_usd": 30},
        "engineering_pillars": {
            "data_ingestion": {"enabled": True, "method": "hybrid_vector_bm25"},
            "core_ai_reasoning": {"enabled": True, "method": "fastapi_structured_llm"},
            "automated_evals": {"enabled": True, "method": "ragas_triad_suite"},
            "cloud_deployment": {"enabled": True, "method": "docker_compose_k8s"},
            "observability": {"enabled": True, "method": "opentelemetry_prometheus"},
            "security_hardening": {"enabled": True, "method": "pii_vault_prompt_waf"}
        }
    }
    validator = CapstoneScopingValidator(charter)
    print(json.dumps(validator.evaluate_feasibility(), indent=2))

Production Architecture Case Study: Capstone Project Charter Template

{
  "project_id": "CAPSTONE-2026-001",
  "title": "LexiGuard: Legal Contract Intelligence Copilot",
  "problem_statement": "Legal counsel spending 12+ hours manually reviewing 80-page commercial vendor agreements for liability indemnity clauses and regulatory compliance breaches.",
  "target_persona": "In-house Corporate Legal Counsel & Procurement Officers",
  "archetype": "enterprise_rag_with_agents",
  "architecture_summary": "FastAPI async backend with LangChain/LlamaIndex, Qdrant vector database, BGE-M3 hybrid embeddings, Mistral/GPT-4o inference, and Next.js responsive streaming UI.",
  "quantitative_slas": {
    "p95_first_token_latency_ms": 380,
    "min_rag_faithfulness_score": 0.92,
    "min_context_recall_score": 0.88,
    "max_cost_per_contract_review_usd": 0.15
  },
  "risk_mitigations": {
    "hallucination_risk": "Strict citation grounding with bounding box coordinate highlights",
    "data_privacy_risk": "Zero-knowledge PII token vault scrubbing party names and bank accounts before LLM ingress"
  }
}

Production Postmortem: The Enterprise Multi-Agent Scope Catastrophe

In Q3 2025, a global logistics enterprise embarked on an ambitious AI transformation project: an autonomous, multi-agent fleet optimization and supply chain copilot. The initial project proposal encompassed 14 interconnected capabilities:

  1. Natural language SQL querying across legacy ERP systems.
  2. Real-time GPS telematics streaming ingestion and spatial indexing.
  3. Multi-agent negotiation between automated carrier dispatchers and supplier bidding systems.
  4. Autonomous financial invoice generation and settlement via smart contracts.
  5. Voice-activated conversational interfaces for warehouse operators across 8 languages.

The Failure Cascade

Because the team did not enforce the Three Core User Workflows Rule, the architecture required 8 distinct external integrations before a single end-to-end user query could be completed. When integration testing commenced:

After 6 months of development and $1.2M in engineering overhead, the project was cancelled without a single production deployment.

The Capstone Remedy

The initiative was subsequently restructured as a focused, high-precision vertical slice: The Carrier Invoice Dispute Copilot. The engineering team scoped the system strictly around two deterministic capabilities:

By constraining the scope to a single high-value workflow, the team delivered a production-ready application in 3 weeks that resolved 85% of freight invoice discrepancies autonomously, saving $340,000 monthly.

+-------------------------------------------------------------------------------+
|                    CAPSTONE SCOPE TRIAGE & TRADE-OFF MATRIX                   |
+-------------------+-----------------------+-----------------------------------+
| Feature Dimension | High-Risk Scope Creep | Hardened Capstone Minimum Slice   |
+-------------------+-----------------------+-----------------------------------+
| Architecture      | 10 Multi-Agent Swarms | Single Orchestrator + 3 Sandboxed |
|                   | with autonomous loops | Deterministic Tool Functions      |
| Data Retrieval    | Real-time multi-modal | Curated Hybrid Dense + BM25       |
|                   | streaming database    | Vector Store with Reciprocal Rank |
| Authentication    | Multi-tenant OAuth2 + | Secure Bearer API Token +         |
|                   | biometric passkeys    | Role-Based Read-Only Permissions  |
| Deployment        | Multi-region active-  | Containerized Docker Pod with     |
|                   | active Kubernetes     | Automated Health Probes on PaaS   |
+-------------------+-----------------------+-----------------------------------+

Detailed Failure Mode Taxonomy: Capstone Scoping Hazards

+-------------------------------------------------------------------------------+
|                    CAPSTONE SCOPING FAILURE TAXONOMY                          |
+-------------------+-----------------------+-----------------------------------+
| Failure Mode      | Root Cause Analysis   | Architectural Mitigation          |
+-------------------+-----------------------+-----------------------------------+
| Unbounded Scope   | Attempting to build   | Restrict scope to single high-    |
| (Feature Creep)   | 5 disparate domains   | impact vertical user workflow     |
| Missing Baseline  | Postponing evaluation | Author evaluation test harness on |
| Evals             | until Week 52         | Day 356 before adding UI polish   |
| Hardcoded Mock    | Relying on hardcoded  | Deploy live vector DB & live LLM  |
| Pipelines         | JSON fixtures only    | inference in Walking Skeleton     |
| Ignoring Security | Skipping PII handling | Enforce prompt firewall and PII   |
| & Guardrails      | until post-launch     | token vault on Day 354            |
+-------------------+-----------------------+-----------------------------------+

Deep Architectural Breakdown: The 6 Mandatory Engineering Pillars

Every senior AI project must demonstrate complete competence across the 6 core pillars:

+-----------------------+-------------------------------------------------------+
| Engineering Pillar    | Concrete Implementation Artifact                      |
+-----------------------+-------------------------------------------------------+
| 1. Data Ingestion     | Automated document parser, semantic chunker, vector DB|
| 2. Core Reasoning     | Structured JSON schema output, fallback model router  |
| 3. Automated Evals    | RAG Triad test suite (Faithfulness, Recall, Relevancy)|
| 4. Cloud Deployment   | Multi-stage Dockerfile, health probes, cloud endpoint |
| 5. Observability      | Structured JSON logs, latency percentiles, token costs|
| 6. Security Hardening | Ingress prompt firewall, PII vault, canary exfil scan |
+-----------------------+-------------------------------------------------------+

Implications: security, privacy, performance, scalability, and cost

1. Cost Budgeting

Budget for cloud LLM API calls during development: keeping evals under 100 benchmark queries per run ensures total milestone testing costs remain under $10 for the entire build.

Diagram: an unbudgeted project compared with one with a cost and time box

2. Time-Boxed Milestones

Adhering strictly to the daily milestone schedule prevents late-stage deployment scrambles and guarantees a polished, stress-tested system on Graduation Day (Day 365).

Diagram: building a project layer by layer compared with a thin end-to-end slice

Alternatives: free, open source, and commercial

Tool / FrameworkTypeBest Suited ForKey Capabilities
Python Standard LibraryBuilt-inScoping & ValidationZero-dependency charter validation
PydanticOpen SourceSchema SpecificationType-safe project metadata models
Notion / JiraCommercial SaaSProject TrackingKanban milestone management
Mermaid.jsOpen SourceArchitecture DiagramsText-to-diagram specification
+-----------------------+-----------------------+-----------------------+
| Dimension             | Toy Tutorial Demo     | Production Capstone   |
+-----------------------+-----------------------+-----------------------+
| End-to-End Breadth    | 1 Script              | Complete 6-Pillar App |
| Evaluation Rigor      | Subjective Vibes      | Automated RAG Triad   |
| Deployment Readiness  | Localhost only        | Dockerized Cloud API  |
| Security Hardening    | None (Plaintext PII)  | PII Vault & Red Team  |
+-----------------------+-----------------------+-----------------------+

When to use it β€” and when not to

Enforce Full Scoping Rigor For:

Lightweight Scoping Applies To:

Diagram: when to apply full project scoping and when to keep it light

Production Checklist: Capstone Scoping & Charter Sign-Off

Diagram: the contents of a capstone charter

The AI connection

Knowledge check

  1. Why is a focused vertical slice superior to a broad, shallow prototype? A focused vertical slice proves end-to-end engineering excellence across the complete stack (data, reasoning, evals, deployment, security) rather than delivering superficial, unverified features.
  2. What are the 6 mandatory engineering pillars of the AI Capstone? Data Ingestion, Core Reasoning, Automated Evals, Cloud Deployment, Observability, and Security Hardening.
  3. How does quantitative feasibility scoring protect project timelines? It catches missing SLAs, excessive compute requirements, or disabled architectural pillars before code is written.

Hands-on exercise

In this lab, you will build and execute the Capstone Project Scoping & Feasibility Scorer in Python. Your implementation will:

  1. Define a structured Capstone Project Charter schema using Pydantic/Python dictionaries.
  2. Validate the presence and configuration of all 6 mandatory engineering pillars.
  3. Evaluate quantitative SLA feasibility (latency, accuracy, budget).
  4. Generate a comprehensive Project Scoping & Feasibility Audit Report.

Expected output

============================= test session starts ==============================
collected 5 items

tests/test_scoping.py .....                                              [100%]

============================== 5 passed in 0.02s ===============================
[SCOPING AUDIT] Validating Capstone Project Charter: "Enterprise RAG Assistant"
[PILLAR VERIFICATION] All 6 mandatory engineering pillars present and enabled.
[SLA AUDIT] p95 latency = 420ms (Target `<= 1000ms`) -> PASS
[SLA AUDIT] Min Eval Accuracy = 90.0% (Target >= 80.0%) -> PASS
[FEASIBILITY SCORE] Composite Score = 100.0 / 100.0 (Grade: EXCELLENT)
[APPROVAL] Project charter officially approved for Milestone 1 build.

Validate your work

Run the pytest test suite:

pytest tests/run_tests.sh

Troubleshooting

  1. Missing pillars: Ensure all 6 pillar keys (data_ingestion, core_ai_reasoning, automated_evals, cloud_deployment, observability, security_hardening) are present.
  2. SLA formatting: Verify that latency SLAs are numeric milliseconds and evaluation accuracy is a float between 0.0 and 1.0.

Common mistakes

Practice assignment

Add a Compute Resource Estimator calculating required GPU VRAM and monthly API costs based on expected queries per day.

Extension challenge

Implement an Automated Markdown Project Charter Exporter that formats the validated JSON charter into a GitHub-ready PROJECT_CHARTER.md document.

Quiz

Q1. What is the primary danger when selecting a capstone project scope?

  1. Scope creep, leaving an unfinished prototype
  2. Using open-source software
  3. Writing too many unit tests
  4. Using Python instead of C++
Show answer

Answer: A. Scope creep, leaving an unfinished prototype

A focused, deep, and fully verified vertical slice is vastly superior to a shallow, buggy demo.

Q2. Which set of core technical capabilities must every AI Capstone demonstrate?

  1. Only HTML and CSS styling
  2. Ingest, reason, evaluate, serve, observe, harden
  3. A PowerPoint presentation with zero working code
  4. Running on 100 GPUs simultaneously
Show answer

Answer: B. Ingest, reason, evaluate, serve, observe, harden

The capstone proves full-stack AI engineering competence across the entire lifecycle.

Q3. How does the SMART scoping framework apply to AI evaluation metrics?

  1. Setting vague goals such as 'the AI should just be smart'
  2. Disabling evaluation in production
  3. Specific, measurable targets with numbers and deadlines
  4. Relying solely on subjective vibes
Show answer

Answer: C. Specific, measurable targets with numbers and deadlines

SMART scoping grounds AI engineering in quantifiable SLAs and benchmarks.

Q4. Why is a 'walking skeleton' vertical slice built in Week 51 before adding advanced features?

  1. To make the code look longer
  2. To spend all cloud budget in one day
  3. Because Python requires it
  4. To flush out integration risk early
Show answer

Answer: D. To flush out integration risk early

A walking skeleton proves that the end-to-end pipeline connects successfully before adding complexity.

Q5. What is the output of the automated Capstone Scoping & Feasibility Scorer?

  1. A feasibility score and a project charter
  2. A binary executable
  3. A random number between 1 and 10
  4. An audio file
Show answer

Answer: A. A feasibility score and a project charter

The scoping tool validates technical balance, SLA realism, and risk mitigations.

Glossary

Capstone Project
A comprehensive end-to-end production AI system synthesizing all 50 weeks of technical curriculum.
Vertical Slice
A complete, working end-to-end implementation of a single core user workflow through all architectural layers.
Scope Creep
The uncontrolled expansion of project requirements without corresponding adjustments to time and resources.
Project Charter
A formal document defining the project problem statement, architecture, constraints, SLAs, and deliverables.
SMART Criteria
Specific, Measurable, Achievable, Relevant, and Time-bound metric targets.
Walking Skeleton
A minimal end-to-end system implementation connecting all architectural components with trivial logic.
Technical SLA
Service Level Agreements defining quantitative latency, throughput, accuracy, and cost limits.
Feasibility Audit
A quantitative evaluation verifying that required compute, data, and APIs are realistically accessible.

Sources and further reading


Kept in this browser, no account needed. Your progress page turns the whole record into one link you can bookmark or open on another device.