Phase 9: Career, Portfolio & Interview Prep · 40 min · Portfolio planning frameworks · Python

Building an AI PM Portfolio

A resume says you're interested in AI. A portfolio proves you can ship it responsibly.

What you will learn

Explain why project-led portfolios outperform resume-led ones for AI PM career transitions
Distinguish the three highest-leverage AI PM portfolio project types and what each demonstrates
Select the right project type given a candidate's specific background gap
Score a draft portfolio project against the criteria a hiring manager actually uses

The Problem

Two candidates apply for the same AI PM role. Candidate A's resume says "Led cross-functional team shipping AI-powered recommendation feature; passionate about responsible AI" — a claim a hiring manager has read four hundred times this quarter, phrased almost identically each time, and has no way to verify in a 30-minute screen. Candidate B's resume links to a three-page write-up: a real opportunity assessment for a recommendation feature, a PRD with a documented cost/latency tradeoff decision, an eval rubric with sample scoring, and a one-page responsible AI review flagging a specific fairness risk and how they'd mitigate it. The hiring manager can read Candidate B's actual reasoning in ten minutes and knows, concretely, how they think under uncertainty. Candidate A gets a screen call to find out if the resume is real. Candidate B often skips straight to a case study round built around their own project.

This isn't a hypothetical difference in interview outcomes — it's the specific, repeated finding behind why project-led portfolios outperform resume-led ones for people transitioning into AI PM roles, whether from traditional PM, from a technical role, or from outside product entirely. A portfolio doesn't just supplement a resume; for a transitioning candidate with no "AI PM" title yet, it's often the only evidence a hiring manager can actually evaluate.

The three highest-leverage project types

Not all portfolio projects carry equal weight. Research on what AI PM hiring managers actually respond to converges on three project shapes, each demonstrating a different, specific signal:

Model comparison analysis — take a real product decision (which model to use for a specific feature) and work it end to end: define the evaluation criteria, run the same task against 2-3 models (via playgrounds or APIs, no fine-tuning required), score them against your rubric, and write a recommendation with the tradeoffs stated explicitly (cost, latency, quality, context window — the Phase 2 decision matrix). This demonstrates technical fluency and decision judgment simultaneously — the two things a resume bullet can claim but never prove.
User research to opportunity solution tree — start from real or realistic user interviews (5-8 is enough), synthesize them into problems worth solving, and build an opportunity solution tree that shows the reasoning path from "users said X" to "we should build Y, not Z." This demonstrates the discovery skill from Phase 2 — the ability to find a real opportunity, not just execute a predetermined one.
Working prototype + PRD with documented trade-offs — build (or wire together, using no-code/low-code tools if you're not writing code yourself) a working AI feature prototype, paired with a real PRD that documents the hallucination-handling approach, the cost model, and at least one deliberate scope cut and why. This demonstrates you can turn ambiguous AI behavior into a concrete, buildable spec — the hardest and most AI-specific PM skill.

One deep project beats three shallow ones
A hiring manager spends roughly ten minutes on a portfolio before deciding whether to dig deeper. Three thin projects (a paragraph each, no real trade-off analysis) read as padding; one project taken all the way through — real criteria, a real recommendation, a documented tradeoff you'd actually defend if pushed — reads as evidence. If you have limited time before you start applying, the highest-leverage move is almost always depth on one project from the list above over breadth across three.

Choosing the right project for your background gap

The right project type depends on what a hiring manager will doubt about you specifically, not on which one sounds most impressive. A candidate moving from a non-technical traditional PM background has the most to prove on technical fluency, so a model comparison analysis directly addresses the doubt a resume alone can't. A candidate moving from a data science or ML engineering background has the opposite gap — hiring managers will wonder if they can do product work, not technical work — so a user-research-to-opportunity-tree project, which demonstrates discovery and prioritization rather than technical depth, closes the actual gap. A candidate with some AI feature experience already, looking to demonstrate end-to-end ownership, benefits most from the working-prototype-plus-PRD project, since it's the one that most resembles what the job actually is.

A candidate has five years of traditional PM experience at a non-AI SaaS company and no hands-on experience with LLMs or ML tooling. They have about 15 hours total before they plan to start applying. Which portfolio project should they prioritize, and why?

The highest-leverage project for a given candidate directly addresses the specific gap a hiring manager will doubt, not the skill they already have the most existing evidence for. This candidate's resume already implies discovery and prioritization skill from five years of traditional PM work — what it doesn't prove is technical fluency with AI/ML specifically, which is exactly what a model comparison analysis demonstrates directly. With only 15 hours, one project taken to real depth (per the lesson's callout) beats three shallow ones, and a prototype without a PRD skips the documented-reasoning part that's actually the differentiator — a demo alone doesn't show tradeoff judgment.

What makes a portfolio project actually land

The difference between a portfolio project that gets read and one that gets skimmed past isn't production polish — it's whether the reasoning is visible. A hiring manager wants to see the moment you chose between two real options and why, not just the option you ended up with. Concretely: state the alternatives you considered and rejected, not just your final recommendation; put a number on the tradeoff where you can (cost delta, latency delta, an eval score gap) rather than a qualitative "Model A felt better"; and be honest about a limitation or an open question you didn't resolve — a project that claims perfect confidence reads as less credible than one that names a real remaining uncertainty and how you'd close it.

Two candidates each submit a model comparison analysis. Candidate A's write-up says "I tested three models and Model B performed best overall, so I recommend Model B." Candidate B's write-up says "I tested three models against a 20-question rubric weighted toward factual accuracy; Model B scored 8% higher on accuracy but costs 3x more per call and adds 400ms of latency — I recommend Model B only if the feature's latency budget allows it, otherwise Model A is the better tradeoff." Which one reads as stronger evidence of AI PM judgment, and why?

This is exactly the "visible reasoning" criterion from the lesson: Candidate B quantifies the tradeoff (8% accuracy gain, 3x cost, 400ms latency) and ties the final recommendation to a real product constraint (the feature's latency budget) instead of an unqualified "best overall" claim. That's evidence of the judgment a hiring manager can't get from a resume bullet. A confident-sounding but unquantified claim (Candidate A) reads as less credible, not more decisive — "performed best overall" hides exactly the tradeoff information a real product decision depends on.

Build

Build it

The code artifact lesson_09_01_portfolio_planner.py implements a portfolio project planner and scorer:

ProjectType — the three highest-leverage project shapes, with what each demonstrates
CandidateBackground — a candidate's existing strengths and the specific gap a hiring manager would doubt
recommend_project_type() — matches a background gap to the highest-leverage project type
PortfolioProjectDraft — a draft project scored against real hiring-manager criteria (visible reasoning, quantified tradeoffs, honest limitations, real recommendation)
score_draft() and render_portfolio_plan() — scoring logic and a markdown planning report
A worked example: the traditional-PM-background candidate from the checkpoint, scored on a draft model comparison analysis

"""
lesson_09_01_portfolio_planner.py

An AI PM portfolio project planner and scorer. Matches a candidate's
background gap to the highest-leverage project type (model comparison
analysis, user research to opportunity solution tree, working prototype
+ PRD), and scores a draft project against the criteria that actually
determine whether a hiring manager reads past the first page.

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).

Usage:
    python lesson_09_01_portfolio_planner.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 ProjectType(Enum):
    MODEL_COMPARISON = "Model comparison analysis"
    OPPORTUNITY_TREE = "User research to opportunity solution tree"
    PROTOTYPE_PLUS_PRD = "Working prototype + PRD with documented trade-offs"

PROJECT_DEMONSTRATES = {
    ProjectType.MODEL_COMPARISON: "Technical fluency and decision judgment under a real cost/latency/quality tradeoff",
    ProjectType.OPPORTUNITY_TREE: "Discovery skill: finding a real opportunity from user evidence, not executing a predetermined one",
    ProjectType.PROTOTYPE_PLUS_PRD: "End-to-end ownership: turning ambiguous AI behavior into a concrete, buildable spec",
}

@dataclass
class CandidateBackground:
    name: str
    existing_strength: str
    doubted_gap: str  # what a hiring manager would doubt about this candidate
    hours_available: int

def recommend_project_type(background: CandidateBackground) -> tuple[ProjectType, str]:
    """Matches the candidate's doubted gap to the project type that most directly closes it."""
    gap = background.doubted_gap.lower()
    if "technical" in gap or "fluency" in gap or "ml" in gap or "llm" in gap:
        return ProjectType.MODEL_COMPARISON, (
            f"{background.name}'s doubted gap is technical fluency — a model comparison "
            "analysis directly demonstrates hands-on judgment with real models and metrics."
        )
    if "product" in gap or "discovery" in gap or "prioritiz" in gap:
        return ProjectType.OPPORTUNITY_TREE, (
            f"{background.name}'s doubted gap is product/discovery skill — an opportunity "
            "solution tree demonstrates finding and prioritizing real user problems."
        )
    return ProjectType.PROTOTYPE_PLUS_PRD, (
        f"{background.name}'s doubted gap is end-to-end ownership — a working prototype "
        "plus PRD most closely resembles the actual day-to-day of the role."
    )

@dataclass
class PortfolioProjectDraft:
    project_type: ProjectType
    title: str
    has_visible_reasoning: bool  # states alternatives considered and rejected
    has_quantified_tradeoff: bool  # a real number, not just a qualitative claim
    names_a_real_limitation: bool  # honest about an unresolved question
    has_concrete_recommendation: bool  # ends in a real decision, not "it depends"

def score_draft(draft: PortfolioProjectDraft) -> tuple[int, list[str]]:
    """Scores a draft out of 4 and lists specific gaps to close."""
    checks = {
        "States alternatives considered and rejected, not just the final choice": draft.has_visible_reasoning,
        "Quantifies at least one tradeoff (cost/latency/eval-score delta), not just a qualitative claim": draft.has_quantified_tradeoff,
        "Names a real, unresolved limitation rather than claiming full confidence": draft.names_a_real_limitation,
        "Ends in a concrete recommendation, not an 'it depends' non-answer": draft.has_concrete_recommendation,
    }
    score = sum(1 for v in checks.values() if v)
    gaps = [k for k, v in checks.items() if not v]
    return score, gaps

def render_portfolio_plan(background: CandidateBackground, draft: PortfolioProjectDraft) -> str:
    project_type, rationale = recommend_project_type(background)
    score, gaps = score_draft(draft)
    lines = [
        f"# Portfolio Plan — {background.name}",
        "",
        f"**Existing strength:** {background.existing_strength}",
        f"**Doubted gap:** {background.doubted_gap}",
        f"**Hours available:** {background.hours_available}",
        "",
        f"## Recommended project type: {project_type.value}",
        "",
        rationale,
        "",
        f"What this demonstrates: {PROJECT_DEMONSTRATES[project_type]}",
        "",
        f"## Draft scoring: {draft.title}",
        "",
        f"**Score: {score}/4**",
        "",
    ]
    if gaps:
        lines.append("Gaps to close before this draft is portfolio-ready:")
        lines += [f"- {g}" for g in gaps]
    else:
        lines.append("All four criteria met — this draft is ready for a portfolio.")
    return "\n".join(lines)

# ── Worked example ───────────────────────────────────────────────────────────
# The traditional-PM-background candidate from the lesson's checkpoint.

def build_example() -> tuple[CandidateBackground, PortfolioProjectDraft]:
    background = CandidateBackground(
        name="Jordan (5 yrs traditional SaaS PM)",
        existing_strength="Discovery, prioritization, and stakeholder management from 5 years of SaaS PM work",
        doubted_gap="Technical fluency with LLMs/ML — no hands-on AI feature experience yet",
        hours_available=15,
    )
    draft = PortfolioProjectDraft(
        project_type=ProjectType.MODEL_COMPARISON,
        title="Model selection for an AI-assisted support-ticket triage feature",
        has_visible_reasoning=True,
        has_quantified_tradeoff=True,
        names_a_real_limitation=False,  # first draft, hasn't added this yet
        has_concrete_recommendation=True,
    )
    return background, draft

if __name__ == "__main__":
    background, draft = build_example()
    print(render_portfolio_plan(background, draft))
    print()
    print(
        "Takeaway: the recommendation targets Jordan's specific doubted gap "
        "(technical fluency), not their existing strength — and the draft "
        "scores 3/4, with one concrete, fixable gap identified rather than a "
        "vague 'needs more polish' note."
    )

Unlock the full lesson

You've read the first 2 sections. The rest of this lesson covers Check Yourself — plus a hands-on lab, quiz, and project artifact.

Create a free account — the opening phases of 29 of 35 courses are free, no credit card.

Key terms in this lesson

Latency