I’ve spent countless cycles guiding teams through the maze of dashboards, SQL pulls, and ad‑hoc analyses—only to watch truly meaningful patterns emerge far too late. Automated insights are the next frontier in product analytics: a shift from manual exploration to AI that proactively surfaces what matters most. When we let the system do the heavy lifting, we accelerate discovery, reduce bias, and give product trios the clarity to act.
Finding causal connections in product data involves exhaustive searches and tests. We trained our AI to find “aha” moments in minutes instead of weeks.
Here’s what that means in practice for product management: the platform continuously scans events, cohorts, and segments; prioritizes signals linked to activation, conversion, and retention; and highlights likely causes behind meaningful movements in your core KPIs. Instead of sifting through endless funnels and cohorts, I get ranked hypotheses I can validate with targeted A/B testing and minimum detectable effect (MDE) guardrails.
This approach turns analytics into action. Automated insights reduce time-to-learning, tighten our discovery loops, and make continuous discovery tangible—especially when we’re aligning roadmaps, designing experiments, and refining onboarding. Whether you’re using tools like Amplitude analytics or instrumenting a unified analytics platform, the value is the same: faster, clearer paths to customer impact.
I’ve seen teams unlock retention analysis breakthroughs by spotting counterintuitive patterns—like a specific feature combination or an overlooked step in onboarding—well before they would have surfaced through manual analysis. With AI workflows scanning the noise and elevating the signal, we can focus on decisions: ship or iterate, scale or sunset, double down or pivot. That’s empowered product teams in action.
If you’re building for product-led growth, this is the leverage you’ve been waiting for. Automated insights transform how we prioritize, test, and communicate strategy—bringing us from gut feel and lagging indicators to explainable, causal narratives we can stand behind. The outcome is simple: more confident bets, less waste, and a faster path to durable product-market fit.
Inspired by this post on Amplitude – Best Practices.
I’ve been working to remove the friction between product questions and product answers. The most impactful step so far: connecting Amplitude analytics directly into ChatGPT via OpenAI’s MCP. This turns everyday conversations into decision-grade insights—no dashboards to hunt, no SQL to write, and no analytics queue to wait on.
Connect Amplitude data directly to the tools your team uses every day. OpenAI’s MCP connector eliminates traditional barriers to product data.
In practice, this means I can ask ChatGPT natural-language questions like, “Where are users dropping in our activation funnel this week?” or “Which cohorts are driving retention lift post-onboarding?” and get grounded answers from Amplitude—fast. It’s a step-change for product-led growth because the insights live where we already think and plan.
Here’s how I apply it day to day: I’ll prompt ChatGPT to compare week-over-week activation for new SMB signups across regions, diagnose drop-offs by step, and summarize A/B testing outcomes with guardrails like minimum detectable effect considerations. When we’re shaping strategy, I’ll pull a retention analysis and cohort breakdown to inform bet sizing and roadmap tradeoffs—all without pulling the team into a BI bottleneck.
Governance remains non-negotiable. I scope the MCP tools to a least-privilege data slice, apply privacy-by-design rules to exclude PII, and log every query for auditability. Clear data governance and AI risk management policies ensure we maintain trust while accelerating discovery. Tight context window management keeps prompts focused and reduces noise.
Operationally, the setup is straightforward: define the MCP tool spec for Amplitude, map canonical events and metrics (activation, retention, conversion, and product-qualified lead stages), and test with a retrieval-first pipeline so responses reliably cite the right source of truth. We standardize metric definitions across product, growth, and customer success to avoid semantic drift.
The impact on empowered product teams is immediate. Continuous discovery becomes a daily habit rather than a quarterly ritual; questions move from “I’ll get back to you” to “Let’s check right now.” For product managers working with LLMs, this is the connective tissue that makes ChatGPT a true ChatGPT connector for analytics—an on-demand, unified analytics platform that supports faster iteration and sharper decision-making.
If you’ve been waiting to make analytics truly ambient, this is the moment. Start small with a single funnel or cohort, validate governance, and expand to your core lifecycle metrics. The payoff is a shared understanding of what’s working, what’s not, and where to focus next—delivered in the flow of work.
Inspired by this post on Amplitude – Best Practices.
Your AI pilot works in the demo. Then it reaches a live workflow and slows down: the data is incomplete, nobody owns the exceptions, reviewers apply different standards, and the team cannot prove whether the result improved revenue, cost, speed, or retention.
The gap is not model quality alone. Scalable growth requires an operating system around the model: a constrained business outcome, a mapped workflow, approved data, explicit decision rights, measurable quality, controlled releases, and a path for handling failure. Build those pieces around one valuable use case, and AI can become a repeatable business capability instead of a collection of pilots.
Choose the growth constraint before the AI use case
Do not begin with a broad instruction to “find an AI use case.” That framing encourages teams to start with a model capability and search for somewhere to place it. Start with a constrained business problem instead.
The unit of investment should be a decision or task inside a customer or employee journey. “Build a churn copilot” is too broad. “Before a renewal review, summarize approved usage and CRM signals, identify the evidence of risk, and propose an action for the customer success manager to review” is narrow enough to test.
Most growth-oriented opportunities fit into four useful lanes:
Revenue: improve qualification, conversion, expansion, cross-sell, or win-back decisions. Measure the commercial event, not the number of AI recommendations generated.
Efficiency: reduce the cost, handling time, rework, or backlog associated with a repetitive process. Good candidates have high task volume and outputs that can be checked without recreating the work.
Speed: shorten a discovery, delivery, or release cycle. If the workflow serves software delivery, deployment frequency can be relevant, but it is not evidence of customer or commercial value by itself.
Activation and retention: make onboarding, guidance, or support more contextual. Measure whether customers reach the intended product behavior and continue receiving value, not whether they clicked an AI-generated tooltip.
What business metric should move, and what is its current baseline?
Which person, decision, and moment in the workflow create that movement?
Does the task occur often enough to justify a reusable solution?
Are the required inputs available, current, and approved for this purpose?
Can a reviewer distinguish an acceptable result from an unacceptable one?
What happens when the system is wrong, and can the action be reversed?
Who owns the outcome after the launch team moves on?
My test is blunt: if you cannot name the workflow event, the owner, the baseline, and the failure consequence, you do not yet have an implementation candidate. You have a discovery question. Fund the learning needed to answer it before funding scale.
Convert the use case into a controlled workflow
An AI feature becomes operational when its behavior is defined inside the surrounding work. That means understanding what happens before the model is called, what the model may do, how its output is checked, and what happens next.
Name the trigger. Specify the event that starts the workflow, such as a support request, renewal review, onboarding milestone, invoice submission, or product release.
Identify the inputs. Record each system, document, field, permission, and freshness requirement. Separate required evidence from optional context.
Expose the decisions. Write down the classifications, judgments, calculations, and approvals a person currently makes. Hidden judgment is where apparently simple automations tend to break.
Specify the output. Define its schema, audience, channel, timing, and acceptable evidence. “Produce a helpful answer” is not a specification.
Map exceptions. Include missing records, contradictory inputs, unsupported requests, low-confidence cases, policy conflicts, and unavailable downstream systems.
Assign each step to code, retrieval, an LLM, or a person. The workflow should use the simplest reliable mechanism for each job.
Define the handoff. State who reviews the result, what they can change, when the workflow must stop, and where failures are recorded.
Use each form of automation for the work it can control
Use deterministic code for exact calculations, validation rules, permissions, routing, and other behavior that should produce the same answer from the same inputs. Use an LLM where language is ambiguous, inputs are unstructured, or the task requires drafting, summarizing, extracting, or classifying meaning.
Keep a person in the path when the consequence is material, the action is difficult to reverse, or the definition of a correct result remains contested. Human review is not a permanent excuse for weak quality, however. The reviewer needs defined criteria, enough context to make a decision, and an easy way to correct and categorize the failure.
Write an execution contract, not just a prompt
A production instruction set should define more than tone and role. Treat it as an execution contract containing:
the objective and the business context;
the permitted inputs and authoritative evidence;
the decision criteria the system must apply;
the required output structure;
the actions it may and may not take;
the conditions that require refusal or escalation;
the way uncertainty should be represented;
examples of acceptable, unacceptable, and edge-case behavior.
For an agentic workflow, increase authority in deliberate stages: observe, draft, recommend, act after approval, and only then act within defined limits. Do not jump from a convincing chat demonstration to autonomous execution. Agentic AI needs explicit guardrails and verifiable quality before it can safely take work out of a human queue.
Measure business value, workflow performance, and AI quality separately
A dashboard that reports requests, tokens, or generated answers tells you that the feature was used. It does not tell you whether the business improved. You need separate measures because an AI system can look healthy at one layer while failing at another.
Measurement layer
What to track
What it reveals
Business outcome
Conversion, expansion, cost per completed outcome, cycle time, activation, or retention
Whether the investment affects the growth constraint it was chosen to address
Workflow performance
Completion, rework, exception, escalation, abandonment, and end-to-end latency
Whether the surrounding process can absorb and use the AI output
AI quality
Correctness, evidence support, instruction adherence, output validity, and appropriate refusal
Whether the system behaves acceptably across expected and difficult cases
Risk and operations
Unauthorized data exposure, prohibited actions, overrides, incidents, rollback events, and unresolved failures
Whether growth is being purchased with unacceptable operational or trust costs
Build the measurement path before the rollout:
Capture the baseline. Measure the existing workflow using the same outcome definition you will use after launch. Otherwise, a faster AI step can hide slower review, higher rework, or shifted labor elsewhere.
Create a representative evaluation set. Use permitted examples from normal, difficult, and failure-prone cases. Define the expected result and the critical errors for each case.
Weight failures by consequence. Formatting errors, unsupported factual claims, privacy failures, and unauthorized actions should not disappear into one average score.
Run offline evaluations before exposure. Test the complete combination of instructions, model, retrieval, tools, and output validation. A model score alone does not represent the production system.
Release behind a feature flag. Start with a controlled cohort, preserve the ability to roll back, and compare outcomes. Use A/B testing when assignment and outcome measurement are credible; use a phased rollout when they are not.
Record versions. Log the model, instructions, retrieval configuration, tools, and policy version associated with each result so a regression can be traced.
Turn failures into future tests. Categorize meaningful production failures and add them to the evaluation set before the next release.
Do not scale because the demo is impressive or employees like the interface. Require four decisions:
The business outcome is moving in the intended direction, or there is credible evidence that the workflow is producing the leading behavior tied to it.
Quality remains acceptable across normal cases, edge cases, and high-consequence failures.
Total cost per successful outcome is viable after model usage, retrieval, storage, human review, escalation, rework, and operations are included.
The operating owner can detect, contain, and learn from failures without depending on the original project team.
If a pilot fails one of these gates, the decision is not automatically to cancel it. Narrow the scope, change the workflow, improve the evidence, or stop. What matters is that expansion is earned by measured behavior rather than assumed from adoption.
Scale through guardrails, reusable components, and clear ownership
Governance should make routine decisions faster. When every team has to rediscover which data is permitted, which evaluation is sufficient, and who can approve a release, governance becomes a sequence of meetings. When those expectations are encoded in a standard launch record, teams know the path before they build.
Create a minimum launch record for every workflow
the business outcome, baseline, and accountable owner;
the workflow boundary, users, and authorized actions;
the approved data sources, access controls, retention rules, and prohibited data;
the evaluation set, acceptance criteria, and critical failure classes;
the human review and escalation conditions;
the logging, monitoring, feature flag, and rollback plan;
the model, retrieval, tool, and vendor dependencies;
the incident owner and the method for notifying affected internal teams or customers when appropriate.
If a workflow touches personal data, confidential customer content, employment decisions, payments, security actions, or contractual commitments, involve the appropriate privacy, security, legal, financial, or people owner before live use. The downside is not limited to a poor answer. The workflow can expose restricted data or take an action the business cannot easily reverse.
Assign ownership beyond launch
Four responsibilities must be explicit, even when one person holds more than one:
Business outcome ownership: decides whether the workflow is worth continuing based on the target metric and economics.
Workflow ownership: manages exceptions, reviewer behavior, process changes, and user feedback.
Technical ownership: controls releases, versions, integrations, reliability, monitoring, and rollback.
Risk ownership: defines the policy boundary and approves material changes to data, authority, or exposure.
This prevents a common operating failure: the product team treats launch as completion, while the operations team inherits a changing probabilistic system without the tools or authority to manage it.
Standardize the recurring parts, not every local process
Once working use cases expose recurring needs, turn those needs into shared capabilities. Useful candidates include identity and permissions, governed retrieval connectors, evaluation tooling, instruction and model versioning, observability, feature flags, rollback controls, and cost attribution.
Keep the final workflow close to the business team that understands the customer, exceptions, and outcome. Centralize the controls and infrastructure that should be consistent. This creates leverage without forcing every function into the same process.
Usually, no. Start with the minimum secure infrastructure required for a valuable workflow. Standardize a component when several use cases need the same capability or when inconsistency creates material risk. Data access, identity, logging, and release controls may need early consistency; a broad internal platform without proven workflows can become an expensive set of assumptions.
How do you know a pilot is ready to scale?
A pilot is ready when it improves the intended business or workflow outcome, stays within quality and risk boundaries, has viable cost per successful outcome, and can be operated without daily intervention from its builders. Usage and positive comments are supporting signals, not a scale decision.
Where should a human remain in the loop?
Keep human approval where consequences are high, actions are difficult to reverse, evidence is incomplete, or acceptable judgment cannot yet be specified. Remove or reduce review only when evaluations and production monitoring show that the remaining risk is understood and controlled. A reviewer who merely clicks approve without adding judgment is not a guardrail; it is latency disguised as governance.
For your next AI proposal, require a one-page charter containing the outcome, workflow boundary, owner, baseline, approved data, evaluation set, failure policy, release plan, and full cost model. If a line is blank, fund discovery to resolve it. If the charter is complete, release the smallest useful workflow behind a control, learn from real failures, and widen its authority only when the evidence earns it.
Your team has more plausible work than capacity. Sales has a customer commitment, support sees recurring friction, engineering sees reliability debt, and executives want a differentiator. Every item can be defended. That is exactly why ranking features is the wrong first move.
An outcome-led system changes what earns priority. You first decide which customer behavior, product condition, or business result needs to change. Then you compare opportunities and solution bets by how credibly they can cause that change. The roadmap becomes a record of choices, evidence, and trade-offs rather than a queue controlled by the loudest request.
Prioritize the change before you prioritize the work
An output is something the team delivers. An outcome is an observable change the team intends to cause. Launching an onboarding flow is an output. Increasing the share of new customers who complete setup successfully is an outcome. The distinction matters because a team can deliver the first without achieving the second.
A usable outcome needs more than a metric name. It should identify who is affected, what behavior or condition should change, why that change matters, how it will be observed, and which guardrails must remain healthy. If you cannot describe how the world should be different after the work succeeds, the item is not ready to compete for priority.
Use an outcome card before accepting solution proposals:
Decision context: the strategic problem that makes a choice necessary.
Target population: the customer segment, user role, or workflow affected.
Current state: the observed behavior, baseline signal, or product condition.
Desired movement: the direction of change and, when the evidence supports it, a meaningful target.
Strategic connection: how the change supports growth, retention, trust, efficiency, or another declared priority.
Guardrails: the signals that must not be harmed while the primary outcome improves.
Review trigger: the evidence or constraint change that would cause leadership to reconsider the outcome.
Do not invent a precise target when no baseline exists. The first commitment may need to be instrumentation, observation, or a small test that establishes the current state. False precision makes an outcome look settled while hiding the most important uncertainty.
The following layers prevent strategy, outcomes, opportunities, bets, and outputs from collapsing into one roadmap item:
Layer
Decision question
Illustrative setup example
Strategic intent
Why does this area matter?
Make first use dependable for new customers.
Outcome
What observable change should occur?
Increase the share of new administrators who finish setup without support.
Opportunity
What unmet need or obstacle prevents that change?
Administrators cannot tell which permissions are required.
Bet
What intervention might address the opportunity?
Test guided permission configuration.
Output
What would the team actually deliver?
Release the validated setup change.
This separation gives you several places to change course. If the bet fails but the opportunity remains important, try another solution. If evidence shows the opportunity was misdiagnosed, investigate another obstacle. If the outcome no longer supports strategy, stop the entire branch. Without these layers, leaders often preserve a feature commitment long after its original reasoning has failed.
A company-level result such as revenue can be valid, but it may be too distant for a product team to manage directly. Connect it to customer behavior and product signals the team can influence. Pair each primary signal with a guardrail: setup completion with setup errors, faster resolution with customer-reported quality, or increased usage with reliability. A metric can improve through the wrong mechanism, so success needs a boundary as well as a direction.
Translate strategy into a decision boundary teams can use
Outcome-led leadership does not mean selecting a metric and disappearing. Leadership owns the strategic context, the outcome boundary, the investment constraints, and the conflicts that individual teams cannot resolve. The team needs room to investigate opportunities, compare solutions, and stop weak bets without asking permission at every step.
Training teams in discovery while leaders continue to manage through feature requests, static roadmaps, and approval gates teaches the organization that customer evidence is secondary. Teams may perform interviews and experiments, but they will still optimize for getting a predetermined feature approved and shipped.
A clear outcome statement can act as a decision boundary:
For [target segment] in [specific situation], improve [behavior or product condition], observed through [primary signal], because [strategic reason], while protecting [guardrails]. Explore opportunities within [scope and constraints] without assuming [requested solution].
The last clause is important. A feature hidden inside an outcome statement is still a feature mandate. Improve adoption of the new dashboard assumes the dashboard is the answer. Help account owners notice and act on performance risks leaves room to discover whether a dashboard, alert, workflow change, or no new interface is the better intervention.
Build a driver tree when the connection between strategy and team behavior is unclear:
Place the business result at the top.
Identify customer behaviors or product conditions that may contribute to it.
Attach observable product signals to those drivers.
Map the customer opportunities that could change each driver.
Mark every unproven connection as an assumption, not a fact.
The tree is not proof of causality. It is a visible model of the current reasoning. That visibility helps teams choose what to validate and helps leaders see where a confident roadmap rests on a weak connection.
Before assigning an outcome, leadership should answer four practical questions:
Why does this outcome deserve investment ahead of the alternatives?
Which constraints are fixed, and which are merely preferences?
Which decisions can the team make without another approval?
What evidence would cause leadership to change the outcome or its investment?
A team cannot genuinely own an outcome when every solution needs executive approval, critical dependencies remain unresolved, or performance is judged only by shipping. That arrangement gives the team accountability without authority. The leadership task is to remove those contradictions before asking the team to move a metric.
Prioritize opportunities with evidence, then shape the portfolio
Use an eligibility gate before a ranking formula
I prefer a gate before a rank. It prevents a polished request with a confident sponsor from competing against a well-understood opportunity merely because both have feature names and effort estimates.
A candidate should become eligible for prioritization only when its decision brief covers:
Outcome relevance: the specific outcome it could affect.
Target evidence: the segment, situation, and observed problem behind it.
Mechanism: the reason this intervention might change the outcome.
Measurement: the primary signal, guardrails, and method of learning.
Critical assumption: the belief most likely to invalidate the bet.
Constraint fit: the technical, operational, and sequencing limits that matter.
Opportunity cost: the work, learning, or outcome investment that would be displaced.
Reversibility: the cost of changing course if the assumption proves wrong.
If a candidate cannot name its outcome or target population, return it to intake. That does not mean it lacks value. It means the organization does not yet have enough information to compare it honestly.
Scoring models can help expose disagreement, but arithmetic should not make weak evidence look objective. Record the reasoning behind each score. Ask which uncertain input has the greatest effect on the ranking. If a small change to that input reverses the decision, investigate the assumption before committing substantial capacity.
Compare opportunities before comparing solutions. Several feature requests may be different guesses about the same customer obstacle. Combining them at the opportunity level can reveal a smaller or more effective intervention. Conversely, two similar-looking features may serve different segments and outcomes, which means one score should not flatten them into a false equivalence.
Use the Kano Model to balance protection, improvement, and exploration
Outcome relevance tells you why an opportunity matters. The Kano Model adds a customer-expectation lens by separating capabilities into must-haves, satisfiers, and delighters.
Must-haves protect the baseline. When they are missing or broken, trust and satisfaction suffer even if the product has innovative features.
Satisfiers create more value as their performance improves. Compare the expected incremental outcome movement with the effort and risk required.
Delighters create unexpected value and differentiation. Treat them as hypotheses worth testing, not as compensation for a broken baseline.
Run the classification by segment and context. A capability can be essential for an advanced customer and irrelevant to a new user. Ask how the target customer would feel if the capability existed and how that same customer would feel if it did not. Pairing these functional and dysfunctional questions is more informative than collecting positive reactions to a proposed feature in isolation.
Do not translate the categories into equal allocations. The right portfolio depends on product maturity, strategic intent, and the condition of the core experience. Make the allocation explicit instead: which investments protect required value, which improve an outcome customers already care about, and which explore future differentiation?
Revisit the classification after meaningful releases or market changes. A delighter can become an expected baseline, so yesterday’s differentiator may no longer justify the same investment. Usage, experiments, interviews, retention patterns, and support evidence should update the portfolio rather than merely confirm the original roadmap.
Run leadership reviews that force choices, not status reports
An outcome-led roadmap can still become output-led in the review meeting. If leaders ask only about delivery dates, scope, and percentage complete, teams will optimize for those signals. Separate the conversations that answer different questions:
Outcome review: Is the customer behavior or product condition moving, for which segment, and with what guardrail effects?
Discovery review: What changed in the team’s understanding of the opportunity, mechanism, or critical assumption?
Commitment review: Which bet should start, continue, change, or stop, and what does that choice displace?
These conversations can share a meeting, but they should not share one vague status label. On track can mean delivery is proceeding to plan while the underlying evidence is weakening. Healthy delivery and healthy product reasoning are different states.
Use a compact review board with the outcome and segment, current signal relative to baseline, strongest new evidence, largest unresolved assumption, active bet, decision required, and displaced work. Feature completion belongs in the delivery portion of the review. It should not stand in for evidence that the outcome is becoming more likely.
Leaders should repeatedly ask:
What did the team learn that it did not believe before?
Which evidence supports or weakens the proposed mechanism?
Is the outcome still right even if the current solution is wrong?
What is the smallest next commitment that resolves the most consequential uncertainty?
What will stop or move if this work receives priority?
Does the team need a decision, a constraint removed, or simply space to continue?
Set decision conditions before attachment to a solution grows. Continue a bet when the evidence strengthens its mechanism. Change the bet when the outcome and opportunity remain valid but the solution does not. Move to another opportunity when the original problem is weaker than expected. Reconsider the outcome when its strategic premise or target segment changes. Stopping a bet is not abandoning outcome ownership; it is one of the ways outcome ownership becomes real.
Stakeholder requests need the same discipline. Translate each requested feature into an intake record that identifies the affected customer, the situation, the observed problem, the evidence, the desired behavior change, the timing constraint, and any alternatives already tried. A request earns evaluation, not an automatic roadmap position.
A useful escalation rule is simple: anyone asking to add committed work must identify what should leave, or explain which outcome or constraint has changed. This turns hidden priority overrides into visible strategy decisions. Seniority may change who has decision rights, but it should not erase opportunity cost.
Before changing the entire organization, use a pilot team to surface decision bottlenecks, incentive conflicts, stakeholder friction, and policy barriers. Track where the team still needs feature approval, where evidence loses to hierarchy, and where another function is rewarded for behavior that undermines the outcome. Those blockers are leadership work. Scaling the workflow without resolving them only distributes the same conflict more widely.
Key takeaways for your next prioritization review
Prioritize an observable customer, product, or business change before ranking proposed outputs.
Give each outcome a target population, baseline signal, strategic connection, guardrails, and review trigger.
Separate outcomes, opportunities, solution bets, and outputs so a failed solution does not preserve itself as a permanent commitment.
Use an evidence gate before scoring, and expose the assumption that could reverse the ranking.
Balance Kano must-haves, satisfiers, and delighters deliberately instead of treating every request as the same kind of value.
Make leadership reviews decide what starts, changes, stops, or gets displaced.
Convert stakeholder urgency into evidence, constraints, and explicit opportunity cost.
At your next roadmap review, take the highest-ranked feature and rewrite it as an outcome statement. Require competing bets to name their evidence, critical assumption, guardrails, and displaced work. If the team cannot do that yet, commit to resolving the uncertainty rather than pretending the feature is ready.
At the following review, ask what changed in the customer signal or the team’s belief before asking what shipped. That question reveals whether your operating system actually rewards outcomes or merely uses outcome language around a feature queue.
Product analytics isn’t a specialist’s sport—it’s a team capability. In my role leading product teams, I’ve seen designers, engineers, marketers, and customer success partners uncover insights that shape strategy, accelerate product-led growth, and improve outcomes for customers. When we demystify the basics and bring analytics into everyday decisions, we build truly empowered product teams.
Here’s the core promise of this approach: "Learn the product analytics fundamentals of funnels, retention, and conversion drivers so that anyone can confidently answer key product questions." That line has guided how I teach product managers to think—start with the essentials, tie them to real customer behaviors, and make the work repeatable across the organization.
I start with funnels because they tell a story—the journey from discovery to value. A simple example: track the path from sign-up to user activation to the first value event. This reveals where onboarding succeeds or stalls, what friction blocks adoption, and which moments are ripe for optimization. With tools like Amplitude analytics or Pendo, we can break down conversions by segment, channel, or feature usage to isolate where improvements matter most.
Next comes retention analysis, the clearest signal that we’re building something customers choose to return to. Cohort analysis shows who comes back and when; retention curves show where value compels a second, third, and tenth use. Tie retention to activation milestones and the outcomes customers achieve—not just logins—and you’ll quickly spot whether your product discovery assumptions hold up in the wild. A unified analytics platform makes these insights discoverable and repeatable across teams.
Conversion drivers round out the picture. Once the funnel is clear and retention is stable, I look for the behaviors and experiences that predict success: feature combinations, time-to-value, message timing, or supportive content. Whether in Amplitude analytics or Pendo, correlating these drivers with outcomes lets us prioritize roadmaps with confidence. Pair this with continuous discovery—qualitative interviews, in-product feedback, and rapid experiments—and you’ll move from interesting data to decisive actions.
This is how we build empowered product teams: by making analytics a daily habit rather than a quarterly report. We bring insights into roadmap reviews, design critiques, and sprint planning; we celebrate learning from experiments as much as shipping features; and we hold ourselves accountable to customer outcomes, not just output. When everyone can interpret funnels, discuss retention, and isolate conversion drivers, we make smarter bets faster.
If you’re getting started, keep it simple. Define a clear activation metric, instrument the top of your funnel, and track a small number of cohorts. Share a weekly readout with highlights, surprises, and questions to investigate. Over time, stitch insights into narratives that drive product-led growth—and, most importantly, help customers achieve what they came for.
Product analytics isn’t just for analysts. It’s a shared language for product discovery, onboarding excellence, user activation, and long-term retention. When we practice it together, we build better products and stronger teams.
Inspired by this post on Amplitude – Best Practices.
I love real-world AI that ships, scales, and actually solves painful customer problems. This story checks every box. As a product leader who has brought agentic AI to production environments, I was captivated by how a small, focused team at Perk took a no-code voice AI prototype and turned it into a system that reliably makes 10,000+ calls per week to prevent failed hotel payments.
What happens when you combine a real customer problem, a no-code prototype, and a team willing to listen to every single call?
Steven Payne (Product Manager), Gabriel Stock (Senior Engineering Manager), and Philipe Steiff (Senior Software Engineer) from Perk share how they built a voice AI agent that calls hotels to verify virtual credit card payments, preventing travelers from arriving to find their rooms unpaid. This is a textbook example of linking operational pain to a high-leverage AI solution.
What started as a hackathon experiment in Make.com became a production system handling over 10,000 calls per week across multiple languages. Along the way, the team learned hard lessons about prompt engineering for voice (numbers, pronunciation, and a very "Karen-like" first version), how to break a single monolithic prompt into structured conversation stages, and why listening to actual calls beats any amount of theorizing.
From a product management perspective, this approach aligns perfectly with eval-driven development and continuous discovery. Structure the problem, instrument aggressively, ship safely, then listen—deeply—to real interactions. In my own teams, I’ve seen that nothing accelerates iteration on agentic AI like closing the loop between qualitative call reviews and quantitative evals.
They built a working prototype without writing a single line of backend code.
They structured the call into discrete stages (IVR, booking confirmation, payment) to improve reliability.
They created two eval systems: one for call success classification, another for conversational behavior.
They scaled from five calls a day to tens of thousands per week while maintaining quality.
This is a detailed look at building AI for real-time human interaction—where the stakes are high and the feedback is immediate.
Guests: Steven Payne, Product Manager, Perk; Gabriel Stock, Senior Engineering Manager, Perk; Philipe Steiff, Senior Software Engineer, Perk.
What stood out to me was how Perk's team identified an AI use case by connecting prior experimentation with a real operational problem. Why they chose Make.com for prototyping—and shipped to production without touching backend code—underscores how far no-code can take you when paired with crisp problem framing. The evolution from a single prompt to structured conversation stages (IVR handling, booking confirmation, payment request) is exactly how you harden agent behavior for production.
Breaking up the agent's task dramatically improved reliability. They also built two eval systems: classification for success rates and LLM-as-judge for conversational behavior. Even with automation, the team still listens to calls manually—a practice I strongly endorse for uncovering edge cases, trust issues, and UX nuances that dashboards can’t show.
The challenge of prompt engineering for voice—numbers, booking references, and text-to-speech markup—was non-trivial. Expanding to German revealed that prompts in native language improve results. And, as often happens with operations-heavy rollouts, this project uncovered other operational problems they didn't know existed—valuable signal for the roadmap.
Resources & Links: Perk. Make.com — No-code automation platform used for the prototype. Twilio — Voice/telephony provider. Eleven Labs — Text-to-speech provider (used in early experiments).
Chapters: 00:00 Introduction to the Team; 01:54 Understanding PERK's Mission; 02:59 Challenges in Travel Booking; 07:27 AI Solutions for Customer Care; 09:52 Prototyping with AI and Voice; 17:00 Implementing AI in Production; 25:51 Learning Through Trial and Error; 26:40 Prompting Challenges and Solutions; 27:58 Iterating on Prompts and Evaluations; 30:08 Scaling and Production Challenges; 32:43 Advanced Evaluation Techniques; 35:32 Real-World Applications and Success; 49:07 Future Directions and Expansion; 53:53 Conclusion and Team Reflections.
My product takeaways: Start with clear operational pain and measurable outcomes (e.g., payment verification). Use no-code to validate quickly, then progressively harden. Treat voice AI like any production system: break it into deterministic stages, add guardrails, and measure both outcome and behavior. Pair automated evals with hands-on reviews. And when going multilingual, write prompts in the native language—your accuracy will thank you.
If you’re exploring agentic AI for operations, this is the blueprint: tight scoping, Make.com for speed, Twilio for reliability, structured prompts for control, and an eval-driven loop to scale quality with confidence.
You have put AI inside a real workflow. The demo looks convincing, early users say it feels faster, and the model usually produces something plausible. Yet one question remains unanswered: did the workflow improve, or did AI merely move the effort into reviewing, correcting, and recovering from its output?
You can answer that question without turning every prototype into a platform project. Treat the workflow itself as the product, isolate the assumption you need to test, measure the entire job rather than the generated output, and increase autonomy only when the evidence supports it.
Start with the decision, not the AI feature
An AI workflow is not a prompt attached to a user interface. It is a sequence containing automated steps, AI-augmented steps, and steps that still require a person. The experiment therefore has to cover that full sequence. A model can produce a strong answer while the workflow still fails because the right context was unavailable, verification took too long, or the recommendation arrived after the decision had already been made.
Write the decision you intend to make before building the variant. A useful decision statement has this shape: If the workflow improves the primary outcome by an amount that matters, while staying inside the agreed quality, safety, latency, and cost limits, expand it. If it does not, revise the failed assumption or stop.
Turn that statement into a one-page experiment contract:
User and context: Name the person doing the job and the moment in which the workflow starts. Avoid labels such as all customers or the product team.
Workflow boundary: Define the observable trigger and the completed outcome. Measure the same boundary in the current and AI-assisted versions.
Baseline: Record how the job works now, including input preparation, waiting, review, handoffs, corrections, and recovery from mistakes.
Hypothesis: State the mechanism, not just the desired result. For example, pre-assembling relevant account context will reduce investigation work before a support response is drafted.
Primary outcome: Choose one measure tied to the user’s completed job, not to the amount of AI output produced.
Guardrails: Define what must not deteriorate. Depending on the workflow, that may include critical-error severity, privacy violations, latency, user overrides, or cost per completed job.
Consider AI-assisted support triage. The workflow does not end when the model assigns a category. It ends when the case reaches the right destination with enough usable context for the next person to act. A faster classification that creates more rerouting or forces an agent to reconstruct the context is not a successful experiment. It is a local improvement that made the system worse.
Be equally precise about augmentation and automation. An augmented workflow helps a person make or execute a decision while that person remains accountable. An automated workflow lets the system take an action without case-by-case approval. Those are different experiments because they change permissions, failure consequences, observability, and recovery. My rule is to prove that assistance improves the job before testing whether the same step deserves autonomy.
Build the smallest workflow that can disprove the idea
Scope the experiment around one clear user, one context, and one outcome. A useful forcing function is that the experience should be understandable in a five-minute demonstration and produce measurable behavior within five days. That is not a universal service-level target. It is a way to expose an oversized scope before architecture, integrations, and stakeholder expectations make the idea expensive to change.
Test assumptions in the order that can save the most investment
Most AI workflow proposals hide several independent assumptions. Separate them so one promising result does not conceal a fatal weakness elsewhere:
Context availability: Are the required inputs present, current, permitted, and accessible at the moment of use?
Model capability: Can the system produce an acceptable recommendation across normal cases and important edge cases?
Verifiability: Can the user tell when the answer is wrong without repeating all the work the AI was meant to remove?
Workflow fit: Does the output arrive in the tool, format, and stage where someone can act on it?
User value: Does the assistance improve the completed job rather than a proxy such as words generated or suggestions displayed?
Operational viability: Can latency, reliability, inference cost, support load, and failure recovery remain acceptable at the intended level of use?
Safety: Can the workflow operate within its data, permission, and consequence boundaries even when the input is misleading or the model is wrong?
Start with the assumption most likely to invalidate the investment. If users cannot verify a recommendation, improving model fluency will not solve the problem. If essential context is unavailable at decision time, building an autonomous agent will only automate guessing. If the job is infrequent and low-friction, even excellent output may not create enough value to justify integration and governance work.
Keep the architecture subordinate to the experiment
Use the simplest model and architecture capable of winning the current experiment. Retrieval can help when answers must be grounded in approved knowledge. Tool use becomes relevant when the system must retrieve live state or prepare an action. Agentic behavior should be added one bounded step at a time. Fine-tuning belongs after repeatable value and a stable failure pattern have been established, not before.
A thin test can be assembled in this order:
Provide the required context manually or through a narrow, read-only connection.
Have the model produce a draft, recommendation, classification, or proposed action.
Require a person to review the result and record whether it was accepted, edited, rejected, or escalated.
Capture the final outcome, not just the model response.
Automate an integration or handoff only after the manual version reveals repeatable value and recurring friction.
This approach keeps the product experience honest while leaving the temporary implementation cheap to change. Do not use production secrets, unrestricted tool permissions, or unapproved personal data simply because the prototype is temporary. A disposable architecture still needs an approved data boundary.
Measure the whole job, especially review and repair
Did the system receive enough permitted information to attempt the task?
Required-field availability, stale or missing context, retrieval failures, and manual context added by the user
Assuming a good demonstration prompt represents normal production inputs
AI output
Was the result usable for its intended purpose?
Rubric scores, critical-error categories, unsupported claims, tool-selection errors, and consistency across representative cases
Judging fluency, confidence, or a handful of appealing examples
Human handoff
What work remained after generation?
Acceptance, edit severity, review time, rejection reasons, overrides, escalations, and cases abandoned
Counting an accepted suggestion without checking whether it was later rewritten or reversed
Completed job
Did the user reach the desired outcome?
Completion, time to acceptable outcome, downstream correction, repeat use, activation, or retention where those measures fit the job
Using output volume or time to first draft as the outcome
Economics and reliability
Can the workflow operate at the intended scale?
Cost per completed job, end-to-end latency, retries, timeouts, failure recovery, and support effort
Looking only at token cost or average model latency
Trust and safety
Did the workflow stay inside its operating boundary?
Blocked actions, permission violations, sensitive-data exposure, severe factual errors, incident reports, and rollback events
Treating the absence of a reported incident as proof that the control works
Use evaluation and live experimentation for different questions
An evaluation set asks whether a particular system configuration can perform the task reliably enough to expose to users. A live experiment asks whether that configuration improves behavior and outcomes inside the workflow. Passing an evaluation does not prove value. Winning an A/B test does not explain which failure modes remain hidden in the average.
Build the evaluation set from real task shapes, including ordinary inputs, known edge cases, and failures discovered during use. Give each case an expected outcome or a task-specific scoring rubric. Separate critical failures from cosmetic defects so a polished response cannot offset a dangerous action. Turning feedback and edge cases into structured prompts, examples, and evaluation sets converts production learning into a repeatable release check.
Keep enough version information to reproduce the tested system: model identifier, prompt or instruction version, retrieval configuration, relevant knowledge snapshot, enabled tools, permission scope, and experiment cohort. AI behavior can change when any of these changes. Do not retain raw sensitive inputs merely for convenience; store the minimum evidence your governance and debugging process actually permits.
Choose an experiment unit that contains the spillover
Randomization should match how the workflow changes behavior:
Randomize by task or session when cases are independent, users do not learn a lasting behavior from the variant, and no memory carries between tasks.
Randomize by user when repeated exposure changes habits, expectations, trust, or the way a person prepares inputs.
Randomize by account or team when people collaborate, share generated artifacts, or influence one another’s process. Splitting collaborators across variants can contaminate both experiences.
Use a staged rollout instead of an open A/B test when the primary concern is a low-frequency but serious failure. Begin with shadow operation or explicit approval and expand only after reviewing the cases.
Define the minimum detectable effect and the exposure window before launch. If the available traffic cannot support the decision, change the scope, extend the window, or use stronger qualitative and task-level evidence. Do not lower the bar after seeing a weak result.
Calculate the work AI displaces, not just the work it performs
Measure three views of effort across the same start and finish:
Human effort: input preparation, review, editing, follow-up, escalation, and recovery from a bad result.
Elapsed time: the interval from the workflow trigger to an acceptable completed outcome, including waiting and queue time.
Rework: cases reopened, rerouted, regenerated, reversed, or corrected downstream.
A lower drafting time can coexist with higher total effort when users must inspect every claim or repair the result later. Capture the reason whenever someone rejects, heavily edits, or overrides AI output. A short set of task-specific reasons produces more actionable evidence than a generic thumbs-up button: missing context, incorrect fact, wrong policy, poor tone, unsafe action, duplicate work, or output arriving too late.
Promote autonomy only when the evidence supports the next risk
Autonomy is not a single launch decision. It is a sequence of permission changes. Each stage should answer a new question without exposing the workflow to consequences it has not yet earned the right to create.
Shadow: Run the system without showing or applying its recommendation. Compare its proposed result with the actual decision and outcome.
On-demand assistance: Let the user request a recommendation when useful. Measure invocation, acceptance, edits, and completed outcomes.
Default draft: Generate the proposed result automatically, but let the user decide whether to use it. Watch for automation bias as well as abandonment.
Approve to act: Allow the system to prepare a tool action while requiring explicit confirmation of the target and consequence.
Bounded automation: Permit low-consequence actions inside a narrow policy, with monitoring, exception routing, and a tested rollback path.
Before promotion, confirm that the new stage has a clear owner, representative evaluation coverage, a measurable user benefit, no unresolved guardrail breach, visible failure states, and a recovery mechanism. Stable average quality is not enough if the next autonomy level creates a new kind of irreversible action.
The risk checklist should be concrete:
Prompt injection: Treat retrieved and user-provided content as untrusted. Limit which tools the system can call and which instructions can change its behavior.
Personal or confidential data exposure: Minimize context, map where inputs and outputs travel, apply access controls, and avoid placing sensitive content in logs that do not need it.
Hallucination or unsupported output: Ground the response where appropriate, expose supporting context to the reviewer, require verification for consequential claims, and fail closed when required evidence is missing.
Runaway cost or action loops: Set budgets, timeouts, retry limits, tool-call limits, and an explicit stop condition.
Keep an experiment record that another product trio could inspect without reconstructing the work from chat history:
The decision, hypothesis, workflow boundary, and riskiest assumption
The baseline, primary outcome, guardrails, and minimum detectable effect
The model, prompt, retrieval, tool, permission, and interface versions
The exposure unit, eligible cohort, exclusions, and rollout state
The evaluation result, workflow result, qualitative evidence, and important exceptions
The final decision: expand, hold, revise, stop, or roll back
The edge cases added to the evaluation set and the instrumentation gaps to close
This is where continuous discovery and delivery meet. Feedback is not merely a backlog of feature requests. It becomes a better task definition, a new evaluation case, a refined guardrail, or evidence that the workflow should not be automated. The artifact that compounds is not the prompt. It is the organization’s ability to make increasingly reliable decisions about where AI belongs.
Key takeaways
Define the ship, iterate, stop, and rollback decision before building the AI variant.
Experiment on the complete workflow boundary, from trigger to acceptable outcome, rather than on model output alone.
Start with one user, one context, one outcome, and the assumption most capable of invalidating the investment.
Use offline evaluations to test capability and live experiments to test user and business value.
Measure input preparation, review, editing, waiting, downstream correction, and recovery so displaced work does not masquerade as saved work.
Increase autonomy through shadow, assistance, drafting, approval, and bounded automation stages.
Version the whole AI system and feed production edge cases back into the evaluation set.
Choose one workflow currently being improved with AI and write its trigger, completed outcome, baseline, primary measure, guardrails, and decision rule. If any field is still vague, that is the next product discovery task. Once each field is observable, ship the smallest reversible version that can prove the assumption wrong.
I’ve spent enough time in the trenches of product management to know the hardest part isn’t collecting feedback—it’s separating signal from noise. When every channel is buzzing, the real question becomes: what should we build next, and why? That’s where Amplitude AI Feedback has changed how I work. It gives me a disciplined, data-informed way to turn messy qualitative input into clear, defensible roadmap decisions.
Learn how Amplitude AI Feedback leverages AI to transform massive volumes of customer feedback into actionable product insights.
In practice, this means I can synthesize input from support tickets, NPS responses, user interviews, sales notes, and reviews—then connect those insights to product behavior data from Amplitude analytics. The result isn’t just a list of requests; it’s a ranked problem set grounded in evidence, which makes product discovery and continuous discovery faster, clearer, and less biased.
A recent example: we were hearing recurring complaints about onboarding friction, but it wasn’t obvious which steps truly mattered. By pairing feedback themes with activation and retention signals, I could zero in on the first-session setup tasks that correlated with drop-off. That clarity guided product roadmapping and sprint planning decisions we could stand behind, and it accelerated user activation without bloating the backlog.
My workflow is straightforward: aggregate feedback, cluster themes, validate with behavioral metrics, and translate insight into outcomes. I look for patterns tied to user activation, retention analysis, and moments that drive product-led growth. When the evidence shows a request is both frequent and high-impact, it earns a place on the roadmap; when it’s loud but low-impact, it becomes a targeted experiment rather than a default commitment.
What I appreciate most is the confidence this brings to stakeholder conversations. Instead of debating opinions, we review the evidence: quantified themes, clear user stories, and measurable KPIs. That turns “Finally, Signal That Tells You What to Build” from a slogan into an operating principle, and it helps empowered product teams move faster with fewer reversals.
If you’re building your AI Strategy or exploring LLMs for product managers, this is one of the highest-leverage moves you can make: use a unified analytics platform to connect qualitative feedback with quantitative behavior. It sharpens prioritization, improves time-to-learning, and keeps the team focused on outcomes—not outputs.
Inspired by this post on Amplitude – Best Practices.
If product managers still open analyst tickets for routine funnel, activation, and retention questions, your analytics transformation has not reached self-service. Buying licenses and publishing dashboards may increase access, but access is not the same as decision autonomy.
You are not trying to turn every product manager into an analyst. You are creating a governed path from question to evidence to decision, while preserving analyst time for problems that require deeper investigation. That takes a shared measurement layer, curated entry points, clear ownership, and operating rituals that make data part of product work.
Start with the bottleneck, not the analytics platform
A self-service analytics transformation should begin with the service your teams experience today. Pick a common product question, such as which users complete activation, where a critical journey loses customers, or which cohorts retain. Ask a product manager to answer it from a standing start, then observe every dependency between the question and a decision.
Look for five distinct sources of friction:
Discovery friction: the product manager cannot find the relevant event, metric, or approved dashboard.
Definition friction: two reports use the same metric name but calculate it differently.
Construction friction: the data exists, but answering the question requires an analyst to build or join the view.
Trust friction: the product manager can create a chart but still needs someone to confirm that it is correct.
Decision friction: the chart answers what happened but does not connect the behavior to a product choice.
This diagnostic separates a tooling problem from a measurement or operating-model problem. Consolidating scattered tools into a unified analytics platform can reduce search and construction friction. It will not resolve inconsistent definitions, unclear ownership, or a culture in which every decision still needs analyst approval.
Establish a baseline before changing the stack. Track the elapsed time from a clearly stated question to decision-ready evidence, the mix of routine and investigative analyst requests, the frequency of conflicting metric definitions, and the product decisions that cite behavioral evidence. Avoid choosing a universal benchmark that your context cannot support. Measure your current state, separate question types, and set improvement targets from that baseline.
The intended end state is narrow enough to test. A product manager should be able to examine activation, funnel drop-off, and cohort retention without joining a reporting queue. An engineer should be able to see the behavioral signal after a release. An analyst should spend less time reproducing standard views and more time on questions whose ambiguity or complexity merits specialist work. When evidence is visible to the people making the decision, discovery and delivery can share the same facts.
Build a governed measurement layer before expanding access
Giving more people permission to query inconsistent data produces faster inconsistency. Self-service becomes trustworthy only when teams share a stable vocabulary for customer behavior and business outcomes.
Treat that vocabulary as a product. Events describe observable behavior; metrics encode an interpretation of that behavior. The distinction matters. A signup event may have a precise trigger, but an activation metric still needs a qualifying action, an eligible population, a time window, and explicit exclusions. If those choices live only inside one dashboard, the dashboard is carrying business logic that other teams cannot reliably reuse.
Use a standard instrumentation workflow for every new event or property:
Start with the decision. Record the question the team needs to answer and the action that could change because of the result.
Define the behavior. Specify the event trigger, required properties, allowed values, exclusions, and the naming convention it follows.
Assign accountability. Name the owner, identify the affected product flow, and record privacy and access requirements.
Implement consistently. Use the same instrumentation pattern and carry the change through the normal CI/CD path instead of relying on an undocumented one-off.
Validate before release. Compare the emitted payload with the tracking contract and check that required properties arrive with expected values.
Publish for reuse. Add the definition to the catalog and expose it through the appropriate curated report, rather than leaving users to discover raw events by trial and error.
This is the practical value of treating data requests like product requests: a team can ask for an event or property with a defined purpose, owner, and privacy classification, while a repeatable path takes it from instrumentation through CI/CD, documentation, and curated analytics.
Your catalog entry should answer the questions a future user will otherwise send to an analyst:
What behavior does this event represent, and what does it not represent?
Exactly when does it fire?
Which properties are required, and what do their values mean?
Which users, accounts, environments, or internal activities are excluded?
Who owns the definition and approves a semantic change?
What privacy classification and role-based access rules apply?
Which approved metrics and dashboards depend on it?
Is it active, deprecated, or scheduled for replacement?
Choose a naming convention that reveals intent, such as an object plus a past-tense action, and apply it consistently. The exact grammar matters less than eliminating synonymous events and ambiguous labels. Do not silently rename or repurpose an event after teams have built reports on it. Deprecate it explicitly, identify the replacement, and update dependent views so a semantic change does not masquerade as a change in customer behavior.
Governance should make the safe path easier, not turn every question into an approval request. Standard definitions, privacy-by-design, role-based access, named owners, and clearly labeled dashboards are the guardrails. Product teams should remain free to explore within them. That balance preserves both speed and trust.
Give non-technical teams a curated front door
A blank analytics canvas is not a self-service experience. It transfers the construction work to users without giving them the context needed to interpret the result. Start with a small set of approved views that answer recurring product questions, then let experienced users branch into deeper exploration.
For one critical product flow, publish three discoverable dashboards:
An activation dashboard that shows the eligible population, qualifying behavior, and relevant segments.
A journey dashboard that exposes conversion between meaningful steps and makes drop-off visible.
A retention dashboard that uses a documented cohort definition and return behavior.
Three well-governed dashboards are more useful than a large library nobody can navigate. Each one should state the question it answers, intended audience, metric definitions, default filters, exclusions, owner, and review status. If a chart is exploratory rather than authoritative, label it accordingly. Users should not have to infer whether they are looking at a decision-grade view or a working draft.
Build enablement around real decisions. Generic feature training teaches people where buttons live; it does not teach them which metric to trust. Use a current product question to show how to select a cohort, inspect a funnel, compare segments, and move from an observed pattern to the next investigation. Targeted onboarding, in-app guidance, and product tours can reinforce that path when users return to the platform.
Then hold a weekly readout for the teams using the flow. Ask what they learned, which decision changed, where a definition was unclear, and which missing property blocked the analysis. Starting with one end-to-end flow, three core dashboards, and weekly decision readouts gives you a controlled environment in which to repair the system before scaling it.
Watch the first few self-service attempts closely. If users repeatedly choose the wrong event, improve the label and catalog entry. If they can build a chart but cannot explain the denominator, curate the metric rather than adding more training. If sensitive properties are broadly visible, fix access design before inviting more users. Friction observed during onboarding is product feedback about the analytics experience.
Change ownership, decision rituals, and success measures
Self-service changes the division of work; it does not eliminate analysts or central governance. Product trios should define measurement needs while they shape a solution, not after engineering has finished it. The data function should own reusable semantics and quality mechanisms. Leaders should make evidence part of routine decisions instead of treating analytics as a separate reporting activity.
A workable ownership split looks like this:
Role
Primary ownership
Boundary
Product trio
Decision question, hypothesis, measurement plan, interpretation, and product action
Does not redefine shared metrics inside a local dashboard
Data and analytics
Event taxonomy, reusable metric definitions, validation patterns, and deeper investigation
Does not become the required builder for every routine chart
Engineering
Accurate instrumentation, implementation consistency, and release validation
Does not decide business meaning without product and data input
Platform and governance owners
Access, privacy controls, catalog standards, dashboard hygiene, and lifecycle management
Does not approve every permitted exploration
Product leaders
Decision rituals, outcome accountability, and protection of specialist capacity
Does not reward unsupported numbers simply because they arrive quickly
Carry measurement through the entire product lifecycle. During discovery, write the expected behavior and the evidence that would change the team’s view. During delivery, make instrumentation part of acceptance criteria. After release, inspect the same agreed signals instead of inventing success measures retrospectively. Before an A/B test, state the hypothesis and justify the minimum detectable effect so the team understands what result the experiment is designed to detect.
The weekly decision ritual can remain simple:
What product question did you answer?
Which governed event, metric, cohort, or dashboard supported the answer?
What decision changed, or what new uncertainty must be resolved?
What defect in instrumentation, definition, access, or documentation slowed you down?
This keeps dashboards connected to action and creates a visible backlog for the analytics product itself. It also prevents login counts from becoming the transformation’s main success measure. A person can log in frequently without reaching a trustworthy conclusion.
Measure the operating change instead:
Time from question to decision-ready evidence, segmented by question type.
Routine questions resolved by the product team without an analyst handoff.
Analyst capacity spent on recurring report construction versus deeper investigation.
Critical events and metrics with complete definitions, owners, and privacy classifications.
Duplicate dashboards, conflicting definitions, validation failures, and data-quality incidents.
Discovery, experiment, and post-release decisions that reference governed behavioral evidence.
Read these signals together. If platform usage rises but routine tickets remain unchanged, access improved while autonomy did not. If self-service rises while definition disputes and quality incidents increase, governance is lagging adoption. If tickets fall but teams cannot name decisions informed by data, people may have stopped asking rather than become self-sufficient.
Do not remove analyst support merely to make the ticket count look better. The intended shift is from repetitive construction to higher-leverage work: investigating ambiguous patterns, improving measurement quality, supporting sound experiment design, and helping teams interpret questions that exceed the safe limits of a standard dashboard.
Key takeaways
Define self-service as the ability to reach trustworthy, decision-ready evidence without a routine analyst handoff, not as access to an analytics tool.
Standardize event definitions, properties, ownership, privacy requirements, validation, and documentation before expanding access.
Begin with one critical flow and three curated views: activation, journey conversion, and retention.
Teach analytics through live product questions and reinforce it with weekly decision readouts.
Measure time-to-insight, ticket mix, governed coverage, quality failures, and decisions changed; logins alone cannot show autonomy.
Scale only after teams can move faster without creating conflicting metrics, unsafe access, or hidden analyst dependencies.
Choose one critical flow in your next planning cycle. Baseline its current question-to-decision path, define the tracking contract, publish the three governed views, and schedule the first weekly readout. Let that flow prove the operating model before you broaden the rollout. Self-service scales when each new team inherits a trusted path, not another blank workspace.
I recently revisited a topic I once pushed back on: using AI to analyze (and maybe even synthesize) customer interviews. After six months of real-world experiments and countless conversations with seasoned product leaders, I’ve evolved my perspective. There is meaningful value here—but only when we’re clear about where AI helps and where it quietly erodes the hard-won customer understanding that powers great product decisions.
If you want to experience the conversation that sparked this reflection, you can listen to the episode on Spotify or Apple Podcast, and watch the discussion here: YouTube. It’s a candid, practical exploration of AI’s role in continuous discovery, and it mirrors what I’m seeing on the ground with product trios and empowered product teams.
Here’s the crux: AI raises the floor for beginners but accelerates experts even more. That matches my experience—early-career PMs get structure, momentum, and a confidence boost, while experienced interviewers can move faster without sacrificing nuance. But there’s a catch. If your interviewing skills aren’t solid yet, AI can create a veneer of insight that masks shallow understanding. In other words, it can help you go wrong more efficiently.
The conversation makes an important distinction between analysis and synthesis. Analysis is about extracting signals from the interview. Synthesis is about building meaning—connecting patterns, weighing contradictions, and deciding what to do next. AI can speed up the former with summaries and highlights. The latter—true synthesis—still demands expert judgment, context, and empathy.
One line from the episode stuck with me: your unpolished interview skills matter more than any shiny new AI workflow. I’ve felt that firsthand. When interview quality is uneven, dropping transcripts into an LLM won’t save you. You still need to synthesize every interview individually so the signals remain traceable and credible. That discipline keeps teams aligned, prevents overfitting to noise, and builds the organizational memory that fuels better bets.
We also explored the operational reality most teams face: interviews pile up. Backlogs grow. Leaders want speed. This is where “expert + AI” shines. With the right prompts, templates, and context, tools like ChatGPT and Claude can help transform raw transcripts into structured artifacts you can trust—provided a strong interviewer sets the frame and makes the calls. That balance preserves both velocity and quality.
What changed my mind most was the evidence from experiments—running sets of interviews through different LLMs and comparing outcomes. The patterns were consistent: beginner + AI is usually better than nothing, but the real performance gains come from expert + AI. When experts guide the process, AI becomes an accelerant rather than a crutch.
A favorite story in the episode takes a detour into building a gaming PC—an unexpected but perfect metaphor for AI’s limits. You can get great step-by-step guidance from a model, but when context shifts or edge cases appear, expertise is what keeps you from making expensive mistakes. Customer interviews are like that. Empathy comes from human interaction; AI can’t replace the experience of talking directly to your customers.
My practical guidance for teams integrating AI into continuous discovery: start with interviewing fundamentals, separate analysis from synthesis, and standardize how you capture single-interview learnings. If you need a tight template for this, refer to “The Interview Snapshot: How to Synthesize and Share What You Learned from a Single Customer Interview.” Use AI for summaries, clustering, and draft artifacts—but have an expert finalize the narratives, evaluate trade-offs, and document assumptions.
If you’re scaling this across an organization, invest in training first, then in workflows. Build a lightweight operating system for discovery: consistent interview guides, “story-based” techniques, and a shared library of prompts. Consider resources like “The Interview Coach,” as well as practical write-ups such as “Customer Interview Analysis: Where AI Helps and Hurts.” These help teams avoid common pitfalls and make better use of AI in high-judgment moments.
My bottom line: AI isn’t magic. It can help, but only if your interviews are strong and you provide the right context. Customer understanding is a competitive moat; outsourcing it entirely will cost you in the long run. Use AI to accelerate—not replace—the human judgment that makes product discovery work.
Resources and links worth exploring: ChatGPT, Claude, The Interview Snapshot: How to Synthesize and Share What You Learned from a Single Customer Interview, The Interview Coach, and Customer Interview Analysis: Where AI Helps and Hurts.
I’d love to hear how your team is using AI in discovery. What’s working, what’s risky, and where do you draw the line between automation and judgment? Share your experiences in the comments—our community learns faster when we compare notes.
When I push our organization to adopt the product operating model, I’m emphasizing a foundational shift—from “shipping roadmaps of features (output)” to solving real customer and business problems, measured by “business results (outcomes)”. That’s the difference between activity and impact, and it’s the only way to build durable value at scale.
This change inevitably reaches beyond the product organization. It reshapes how company stakeholders in Sales, Marketing, Customer Success, Finance, Legal, Security, and Operations engage with product teams, and it reframes what they expect from us. Instead of asking, “When will feature X ship?” they learn to ask, “How will we move the outcome that matters?”
In practice, the product operating model is a contract: product teams commit to outcomes, and stakeholders commit to partnership. That partnership means we co-own the problem, align on evidence, and share accountability for results. The reward is clarity—everyone sees how their work ladders to strategy and why the sequence of work makes sense.
Here’s how I align stakeholders around this model. First, I ground everything in outcomes vs output OKRs. We replace feature roadmaps with a clear strategy, prioritized problems, and measurable objectives. Our product roadmapping and sprint planning then serve the objectives—not the other way around—so capacity is allocated to the highest-leverage bets.
Second, I build empowered product teams around product trios (product, design, engineering). We practice continuous discovery with stakeholders: we share opportunity trees, test riskiest assumptions early, and bring partners into research when it informs go-to-market strategy, pricing, or enablement. This keeps us honest and avoids late-stage surprises.
Third, I establish operating rhythms that make outcomes visible. Monthly stakeholder reviews focus on progress toward objectives and what we’re learning—not status theater. Quarterly, we connect OKRs to business performance so leaders can see the throughline from discovery and delivery to pipeline, retention, or margin. If priorities shift, we renegotiate objectives explicitly.
Fourth, I define metrics that stakeholders trust. We use a balanced set of leading indicators (activation, engagement, cycle time) and lagging indicators (revenue, retention, unit economics). We socialize definitions early so no one debates the scoreboard mid-game. The result: faster decisions and less “data whiplash.”
Fifth, I invest in change management. Moving from outputs to outcomes can feel threatening if your success has historically been measured by launch volume or roadmap commitments. I address this head-on with training, transparent comms, and clear decision rights. The message is simple: outcomes create more autonomy for empowered product teams and more predictability for stakeholders.
At HighLevel, this approach has been especially powerful when cross-functional dependencies are high. For example, when we set an objective to improve user activation for a new CRM integration, we didn’t promise a bundle of features. We committed to a measurable lift in activation and a shorter time-to-value, co-owned with Customer Success and Marketing. That alignment unlocked smarter experiments, tighter enablement, and a more credible launch narrative.
The anti-patterns are predictable: treating OKRs as a renaming of the roadmap, equating discovery with indecision, or isolating product decisions from go-to-market strategy. The cure is equally consistent: bring stakeholders into discovery, attach every bet to an objective, and show progress with evidence—not just demos.
Ultimately, the product operating model is a leadership choice. It asks us to trade certainty theater for learning velocity, and feature checklists for business impact. When stakeholders see that shift pay off—in faster cycles, clearer priorities, and results that matter—support for the model moves from compliance to conviction.
In my role leading product teams, the AI product roadmap isn’t just a plan—it’s the operating system for how we discover value, prioritize with rigor, and ship with confidence. The pace has changed, the stakes are higher, and the best product managers are now orchestrating AI capabilities, data, and customer insight in near-real time.
Master the evolving art of the AI product roadmap. Prioritize smarter, turn data into direction and insight into action, only much faster.
When I say “AI product roadmap,” I’m talking about a living system that blends strategy, discovery, and delivery. It’s less about dates and more about outcomes, risk reduction, and sequencing learning. In practice, that means combining AI Strategy with product roadmapping and sprint planning, then validating each bet with real customer signals.
For prioritization, I anchor on outcomes vs output OKRs and connect them to measurable signals across the funnel. Continuous discovery keeps insights flowing, while a unified approach to analytics and retention analysis tells me where the lift is. This lets me rank initiatives not just by impact and effort, but by how quickly we can learn, iterate, and compound value.
On discovery, product trios are non-negotiable. We prototype early with gen ai and LLMs for product managers to accelerate concept validation and reduce ambiguity. When customers can co-create through in-app guides or lightweight product tours, we turn vague needs into crisp problem statements and testable hypotheses far faster.
On delivery, I pair tight feedback loops with experimentation. A deliberate cadence of A/B testing and strong instrumentation ensures we’re learning every sprint, not just launching. The goal is to de-risk decisions quickly, keep momentum high, and translate signals into roadmap movement without thrash.
Under the hood, the AI stack matters. I rely on a retrieval-first pipeline to ground models in trusted data, and I’m intentional about privacy-by-design and data governance from day one. As agentic AI patterns emerge, I put evaluation workflows in place so we can ship confidently—and safely—without slowing down innovation.
Finally, alignment is the multiplier. Clear narrative roadmaps tied to customer outcomes help stakeholders see trade-offs, while crisp interfaces with go-to-market and CRM integration close the loop from roadmap to revenue. When everyone can trace a line from AI strategy to shipped value, prioritization becomes easier and trust grows.
If you’re feeling the acceleration, you’re not alone. With the right AI product toolbox—rooted in discovery, grounded in data, and delivered through tight feedback loops—you can move faster, learn smarter, and build products your customers can’t live without.
