← All work
AI · Internal ToolingAI product case study2026AI Copilot · Product Discovery

Juno PM Prioritization Copilot

An evidence backed AI copilot that helps PMs prioritize with confidence.

A self-directed AI product management case study. Juno is a design and evaluation specification; not a deployed production system, and there is no live usage data.

Juno PM Prioritization Copilot — An evidence backed AI copilot that helps PMs prioritize with confidence.

Executive summary

Problem
PMs were hand synthesizing support tickets, interviews, Jira, Slack and sales notes into prioritization calls with no traceable evidence trail behind the recommendation.
My bet
If recommendations are grounded in retrievable internal evidence and every claim is attributable, PMs will trust the synthesis enough to use it; while keeping the decision.
What I designed
A Level 1 copilot: hybrid RAG retrieval, source attributed recommendations, and a hard fail safe that refuses to recommend and escalates to a PM when evidence is thin.
How I'd validate it
An evaluation stack rather than a launch metric; accept / edit / reject signals, human review against strategy, and automated guardrails that fail unsupported claims.

Success measures

Design outcome; no live usage data. The evaluation stack below defines how quality would be measured once built.

Autonomy level
Level 1Copilot; the PM decides
Grounding rule
Top 10Attributed evidence segments per recommendation
Fail safe
EscalateNo recommendation when evidence is insufficient

The work

01 · The problem

Product signals were everywhere. Prioritization confidence was not.

Product Managers were working across fragmented customer, business, product, and technical signals. Support tickets, customer interviews, Jira issues, Slack discussions, sales feedback, and product documentation all contained useful evidence, but synthesizing them into a defensible prioritization recommendation required significant manual effort. The challenge was not a lack of information; it was turning fragmented information into traceable, evidence backed product judgment.

  1. 01Fragmented signals
  2. 02Evidence retrieval
  3. 03Strategic comparison
  4. 04Prioritization recommendation
  5. 05PM decision

02 · What I learned

Trust required more than a smart answer.

The central product insight was that PMs would not trust a recommendation simply because it sounded intelligent. Juno needed to show where evidence came from, how signals related to strategy, and where uncertainty remained. The product had to optimize for both recommendation quality and decision transparency.

Trust requirementJuno design response
Evidence traceabilitySource attribution and evidence snippets
Strategic relevanceCompare signals against product strategy
ConfidenceSurface evidence strength and confidence
Hallucination preventionDo not recommend when sufficient evidence is unavailable
Human controlPM reviews, adjusts, accepts, rejects, or reruns analysis
Juno recommends. The Product Manager decides.

03 · The product decision

A grounded copilot, not an autonomous roadmap manager.

I chose a copilot model in which Juno retrieves and synthesizes evidence, compares signals against strategy, scores opportunities, and generates recommendations; but the Product Manager retains authority over prioritization and roadmap decisions.

Juno canJuno cannot
Retrieve relevant evidenceAutonomously update the roadmap
Synthesize customer and business signalsMake unsupervised product decisions
Compare opportunities against strategyAllocate engineering resources
Generate evidence backed recommendationsApprove product launches
Produce draft prioritization outputsCommit engineering teams

04 · How Juno works

From fragmented signals to evidence backed recommendations.

The workflow separates signal collection, retrieval, strategic comparison, and recommendation generation; with the PM as the final reviewer at every cycle.

  1. 1. Collect signals

    Support tickets, customer interviews, Jira issues, sales feedback, Slack discussions, and product documentation.

  2. 2. Retrieve evidence

    Find relevant internal evidence using the RAG knowledge base.

  3. 3. Compare against strategy

    Evaluate customer impact, revenue impact, technical risk, and strategic priority.

  4. 4. Generate recommendation

    Produce opportunity summary, priority score, supporting evidence, source attribution, and recommended action.

  5. 5. PM reviews and decides

    Accept, adjust, reject, or rerun the analysis.

PM copilot workflow

Surface, handshake and AI layers with a human in the loop feedback path.

05 · Data and trust design

Grounded retrieval was a product requirement, not just a technical choice.

Design decisionJuno approach
RetrievalHybrid semantic and keyword search
Evidence windowRelevant customer signals from the last 90 days plus active Jira backlog and current product documentation
Context controlRetrieve the Top 10 most relevant evidence segments
GroundingInclude source links and evidence snippets
Decision contextCustomer impact, revenue impact, technical risk, and strategic alignment
Fail safeIf evidence is insufficient, Juno must state that it cannot make a prioritization recommendation and escalate the decision to a Product Manager
AutonomyCopilot model with PM review before action

06 · Trust and evaluation

I designed evaluation around trust, traceability, and usefulness.

  1. User feedback

    Track whether PMs accept, edit, or reject recommendations. Measure how much of Juno's output is changed before approval.

  2. Human evaluation

    Evaluate whether recommendations align with strategy. Verify that claims, risks, and recommendations are traceable to internal evidence.

  3. Automated guardrails

    Check for source attribution and required evidence. Fail outputs that introduce unsupported claims or cannot meet evidence requirements.

07 · Interactive prototype

Review a Juno recommendation the way a PM would.

This interactive prototype demonstrates the proposed Juno copilot experience developed as part of this self-directed case study. Signals, tickets and interviews shown are fictional.

Analyze a set of product signals, open the evidence Juno retrieved, then accept, reorder or reject each proposed priority; every decision is written to a traceable history.

What you can explore

  1. Analyze the signals. Turn 162 raw signals into a first draft ranking with confidence scores.
  2. Open the evidence. See the support tickets, interviews, Jira issues and sales notes behind each recommendation.
  3. Read the reasoning. Check severity, frequency, strategic alignment and what evidence is still missing.
  4. Decide as the PM. Accept, move up or reject a recommendation and watch the final roadmap and decision history update.
Explore Interactive Prototype
lilianadeiwa.live

Project artifacts

  • AI strategy one pager

    Available on request

  • RAG & data strategy spec

    Available on request

  • Eval stack plan

    Available on request

What I'd do next

The most important AI product decision here wasn't the model or the retrieval strategy; it was autonomy. What I'd validate next: whether accept / reject feedback actually improves brief quality over time, or whether senior PM rubric scoring remains the truer signal.

Next case study

StreamLine Spotlight

Curing decision fatigue with human curated discovery.