Phase 9: Career, Portfolio & Interview Prep · 160 min · Python · Portfolio case study assembly
The Problem
You've spent this course carrying one feature through four separate, serious pieces of work: an opportunity assessment that sized the bet and made a build/buy/model-selection call (Phase 2), a full PRD that specified probabilistic behavior, guardrails, and a cost model (Phase 4), an evaluation plan with a rubric and sample scoring (Phase 5), and a responsible AI review with a consequence-scan, regulatory classification, and guardrail decisions (Phase 7). Each one, on its own, is solid evidence of a specific skill. Stapled together as four separate PDFs in a folder, they're not a portfolio — they're homework.
The gap between "four completed exercises" and "the single artifact a hiring manager actually wants to see" is exactly what Lesson 1's research pointed at: project-led portfolios work because they let someone evaluate real judgment directly, but that only works if the judgment is visible as one continuous story, not four disconnected files a reader has to mentally stitch together themselves. This capstone is that stitching — and it's deliberately the last thing you build in this course, because it's the first thing a hiring manager will actually read.
What "assembled" actually means
Assembly is not compression — it's not fitting four documents into fewer pages. It's building a narrative arc where each project's output becomes the input to the reasoning in the next, made explicit on the page:
- Opening: the opportunity, in one paragraph — what the feature is, who it's for, and the specific number or finding from your Phase 2 opportunity assessment that justified pursuing it (not "AI seemed promising," but the actual sizing logic and the build/buy/model-selection call you made and why).
- The PRD's key decisions, not the full document — pull 2-3 decisions that actually show judgment: how you specified acceptable probabilistic behavior, the guardrail you chose and the tradeoff behind it, the cost projection and what it constrained. Link to or attach the full PRD as backup; the case study itself shows the reasoning, not the whole spec.
- The eval plan's real teeth — the rubric you built, one worked example of scoring an actual output against it, and (this is often the most differentiating part of a portfolio) an honest account of a borderline case your rubric didn't resolve cleanly at first, and what you changed.
- The responsible AI review's headline finding — the consequence-scan's most significant finding, the regulatory classification, and the overall ship/mitigate/redesign call, stated with the same directness Phase 7's
overall_recommendation() produces — a real decision, not a hedge. - Closing: what you'd do next — the honest state of the feature if it were real (would you actually ship it as specified, what would you want to validate first, what's the single biggest open risk) — this is where you demonstrate you understand the work isn't "done," it's at a specific, articulable stage.
The connective tissue between projects IS the evidence, not the projects themselves
A hiring manager who reads "the opportunity assessment identified self-employed applicants as underserved by existing underwriting; the PRD's guardrail decision specifically routes low-confidence scores for that segment to mandatory human review; the eval rubric includes a per-segment scoring pass specifically because of that guardrail; the responsible AI review's ethical KPI directly measures whether that guardrail is working" is reading a single, coherent judgment chain across four phases of work. A hiring manager who reads four summaries that never reference each other is reading four homework assignments. The explicit cross-references are the actual differentiator — go back through your four projects now and find at least three real connections like this before you write the narrative.
Two candidates both submit case studies covering the same kind of AI feature. Candidate A's case study is 20 pages long and covers every detail of all four projects exhaustively. Candidate B's case study is 9 pages, covers the same four projects, but every section explicitly states what alternative was considered and rejected and why. Which is the stronger portfolio artifact, per this course's standard, and why?
This course's case-study standard (stated in the lab rubric) explicitly favors documents that surface judgment and tradeoffs over documents that are merely exhaustive. A hiring manager skimming a portfolio is looking for evidence of decision-making — what was considered, what was rejected, and why — not maximum word count. Candidate A's 20 pages could easily be dense description with no visible reasoning; Candidate B's 9 pages, if every section names a rejected alternative and its rationale, demonstrates exactly the judgment an AI PM interview is designed to test. Length is a proxy for neither quality nor rigor on its own.
Building the mock interview presentation
The case study document is written for someone to read alone; the presentation outline is built for you to talk through it live, which is a different skill (Lesson 4's case-interview material, applied to your own work instead of a hypothetical prompt). A strong outline runs roughly 10-15 minutes if actually presented, structured as: a 90-second framing of the opportunity and why it mattered, 3-4 minutes on the PRD's hardest decision and the alternative you rejected, 3-4 minutes on the eval plan and the borderline case, 3-4 minutes on the responsible AI review's finding and what it changed about the design, and a close naming the single thing you'd want to learn first if this were real. Practice this out loud at least once, the same way Lesson 2's product-sense practice recommended — an interviewer who asks you to "walk me through your strongest project" is functionally asking for this presentation, cold, and having rehearsed it is the difference between a confident 12 minutes and a rambling 20.
A candidate's capstone case study document has four separate, well-written sections — one per project — but each section never references findings from the other three, and the document ends after the fourth section with no synthesis. What is the single highest-leverage change to make before using this in a portfolio?
The lesson's core point is that four well-written but disconnected sections read as four homework assignments, not one coherent case study — the actual differentiating evidence is the explicit connective tissue between phases (a finding in one project changing a decision in another) plus a closing synthesis that shows the candidate understands the feature's real, current state. Adding length or reordering sections doesn't address the structural gap; only making the cross-project reasoning visible does.
Build
Build it
The code artifact lesson_09_07_capstone_case_study.py assembles summaries of the four prior projects into one case study document and a separate presentation outline:
ProjectSummary — a compact summary of one prior project (Phase 2/4/5/7), including its artifact filename and its single most important finding or decisionCrossReference — an explicit link between two projects' findings (the connective tissue the callout emphasizes)CapstoneCaseStudy — the full container: four project summaries, cross-references, and a closing synthesisrender_case_study() — produces the assembled markdown case study documentrender_presentation_outline() — produces a separate, timed mock-interview presentation outline- A worked example: the AI loan pre-approval feature, consistent with the running example from Phase 7, assembled end to end with real cross-references
"""
lesson_09_07_capstone_case_study.py
Project: Full AI Product Case Study (Capstone). Assembles summaries of
the four prior course projects (opportunity assessment, PRD, eval plan,
responsible AI review) into one coherent portfolio case study document,
plus a separate, timed mock interview presentation outline — the final
deliverable of the course.
References: Institute of AI PM
(https://www.institutepm.com/knowledge-hub/ai-pm-side-projects),
Product Teacher
(https://www.productteacher.com/articles/breaking-into-ai-product-management),
Aakash Gupta (https://www.news.aakashg.com/p/become-an-ai-pm-no-experience).
Usage:
python lesson_09_07_capstone_case_study.py
No external dependencies, no network calls, no API keys required.
"""
from __future__ import annotations
from dataclasses import dataclass, field
from enum import Enum
class ProjectPhase(Enum):
OPPORTUNITY_ASSESSMENT = "Phase 2: AI Opportunity Assessment"
FULL_PRD = "Phase 4: Full AI Feature PRD"
EVAL_PLAN = "Phase 5: Evaluation Plan & Rubric"
RESPONSIBLE_AI_REVIEW = "Phase 7: Responsible AI Review"
@dataclass
class ProjectSummary:
phase: ProjectPhase
artifact_filename: str
headline_finding_or_decision: str
one_paragraph_summary: str
@dataclass
class CrossReference:
from_phase: ProjectPhase
to_phase: ProjectPhase
description: str # how a finding in one shaped a decision in the other
@dataclass
class CapstoneCaseStudy:
feature_name: str
feature_one_liner: str
projects: list[ProjectSummary]
cross_references: list[CrossReference]
current_status: str # e.g. "Would ship with the stated mitigation" / "Would not ship as specified"
biggest_open_risk: str
next_thing_to_validate: str
def has_minimum_cross_references(self, minimum: int = 3) -> bool:
return len(self.cross_references) >= minimum
def render_case_study(case: CapstoneCaseStudy) -> str:
lines = [
f"# Case Study: {case.feature_name}",
"",
case.feature_one_liner,
"",
"## Project Summaries",
"",
]
for p in case.projects:
lines += [
f"### {p.phase.value}",
"",
f"**Artifact:** `{p.artifact_filename}`",
f"**Headline finding/decision:** {p.headline_finding_or_decision}",
"",
p.one_paragraph_summary,
"",
]
lines += ["## How the Projects Connect", ""]
if case.cross_references:
for xr in case.cross_references:
lines.append(f"- **{xr.from_phase.value} -> {xr.to_phase.value}:** {xr.description}")
else:
lines.append("No cross-references recorded — this is a gap to close before using this case study.")
lines += [
"",
"## Current Status and Next Steps",
"",
f"**Status:** {case.current_status}",
f"**Biggest open risk:** {case.biggest_open_risk}",
f"**What I'd validate first:** {case.next_thing_to_validate}",
]
return "\n".join(lines)
def render_presentation_outline(case: CapstoneCaseStudy) -> str:
lines = [
f"# Mock Interview Presentation Outline: {case.feature_name}",
"",
"Target total time: ~12-15 minutes",
"",
"## 1. Framing (90 seconds)",
"",
case.feature_one_liner,
f"Opportunity finding: {case.projects[0].headline_finding_or_decision}",
"",
"## 2. The Hardest PRD Decision (3-4 minutes)",
"",
case.projects[1].headline_finding_or_decision,
"",
"## 3. The Eval Plan and a Borderline Case (3-4 minutes)",
"",
case.projects[2].headline_finding_or_decision,
"",
"## 4. The Responsible AI Finding and What It Changed (3-4 minutes)",
"",
case.projects[3].headline_finding_or_decision,
"",
"## 5. Close: Status and Biggest Open Question (1-2 minutes)",
"",
f"{case.current_status} The biggest open question I'd want to resolve first: {case.next_thing_to_validate}",
]
return "\n".join(lines)
# ── Worked example ───────────────────────────────────────────────────────────
# The AI loan pre-approval feature, consistent with the running example
# used across Phase 7's lessons.
def build_example() -> CapstoneCaseStudy:
projects = [
ProjectSummary(
phase=ProjectPhase.OPPORTUNITY_ASSESSMENT,
artifact_filename="opportunity_assessment.md",
headline_finding_or_decision="Self-employed applicants are underserved by the existing rules-based underwriting engine, which is a large enough segment to justify a build (not buy) decision using a fine-tuned model over the incumbent vendor's black-box API.",
one_paragraph_summary="Sizing analysis showed the existing process rejected self-employed applicants at a disproportionate rate relative to their default rate, indicating a solvable model problem rather than an inherent risk difference — the opportunity is closing that gap while maintaining underwriting standards.",
),
ProjectSummary(
phase=ProjectPhase.FULL_PRD,
artifact_filename="ai_feature_prd.md",
headline_finding_or_decision="Guardrail decision: any application from a self-employed applicant scoring near the auto-deny threshold routes to mandatory human underwriter review, rather than relying on the model's confidence score alone — a direct response to the opportunity assessment's finding.",
one_paragraph_summary="The PRD specifies acceptable probabilistic behavior (a confidence band, not a single threshold), a cost model showing the human-review guardrail adds under 3% to per-application cost, and this specific segment-targeted guardrail as the PRD's key differentiating decision.",
),
ProjectSummary(
phase=ProjectPhase.EVAL_PLAN,
artifact_filename="eval_plan_and_rubric.md",
headline_finding_or_decision="The eval rubric includes a mandatory per-segment scoring pass (not just an aggregate score) specifically for self-employed applicants, added after an early borderline case revealed the aggregate-only rubric would have missed a segment-specific miscalibration.",
one_paragraph_summary="A golden set of 60 applications, scored on both aggregate accuracy and segment-specific false-positive rate; the borderline case that changed the rubric involved an application the model confidently denied that a human reviewer would have approved, which the original rubric's aggregate scoring didn't flag as a problem.",
),
ProjectSummary(
phase=ProjectPhase.RESPONSIBLE_AI_REVIEW,
artifact_filename="responsible_ai_review.md",
headline_finding_or_decision="Overall recommendation: REDESIGN — a failing false-positive-parity KPI for self-employed applicants (9-point gap vs a 5-point target) combined with a High EU AI Act tier and oversight that wasn't being meaningfully exercised.",
one_paragraph_summary="The consequence-scan's ethical KPI directly measures whether the PRD's human-review guardrail is actually closing the gap identified in the opportunity assessment — it isn't yet, which is the review's central, actionable finding.",
),
]
cross_references = [
CrossReference(
ProjectPhase.OPPORTUNITY_ASSESSMENT,
ProjectPhase.FULL_PRD,
"The opportunity assessment's finding (self-employed applicants underserved) directly produced the PRD's specific human-review guardrail for that segment, rather than a generic guardrail.",
),
CrossReference(
ProjectPhase.FULL_PRD,
ProjectPhase.EVAL_PLAN,
"The PRD's segment-specific guardrail is only meaningful if measured — this is why the eval rubric added a mandatory per-segment scoring pass instead of relying on an aggregate score.",
),
CrossReference(
ProjectPhase.EVAL_PLAN,
ProjectPhase.RESPONSIBLE_AI_REVIEW,
"The eval plan's per-segment metric became the responsible AI review's ethical KPI, which is what revealed the guardrail isn't yet closing the gap — the review's headline finding traces directly back to a metric the eval plan introduced.",
),
]
return CapstoneCaseStudy(
feature_name="AI Loan Pre-Approval Assistant",
feature_one_liner="An AI-assisted pre-approval system aimed at closing a documented underwriting gap for self-employed applicants without lowering underwriting standards.",
projects=projects,
cross_references=cross_references,
current_status="Would not ship as currently specified — the responsible AI review's REDESIGN call stands until the false-positive-parity gap closes and human oversight is demonstrably real, not nominal.",
biggest_open_risk="The human-review guardrail may be functioning as a rubber stamp rather than a real check, which is exactly what the failing KPI and oversight finding suggest — this needs to be fixed before the feature is revisited for launch.",
next_thing_to_validate="Whether a redesigned review flow (e.g., surfacing the specific factors driving a low score, not just a binary recommendation) increases genuine override behavior, measured directly rather than assumed.",
)
if __name__ == "__main__":
case = build_example()
print(render_case_study(case))
print()
print("=" * 60)
print()
print(render_presentation_outline(case))
print()
print(
f"Cross-references: {len(case.cross_references)} "
f"(minimum of 3 met: {case.has_minimum_cross_references()})"
)
print(
"Takeaway: every project's headline finding traces into the next — "
"the opportunity assessment's gap produces the PRD's guardrail, the "
"guardrail produces the eval plan's per-segment metric, and that "
"metric produces the responsible AI review's central finding. That "
"chain, made explicit, is the actual capstone deliverable."
)