LoginSign up for free

Judging a new feature against the bar set before launch

The Product Leaders work group on writing the bar down before launch, reading a missed metric and telling real value from usage that moved over from other features.

Updated October 13, 2026

Decide what a win looks like before the feature ships, read the result against that bar on a date set in advance, and check that the product as a whole gained.

  • Write the bar down before launch. Yuhki Yamashita asks teams to write the headline they want to claim, then grade themselves against it with a letter and an explanation. Jiaona Zhang writes success as a branch on a KPI tree, from business outputs down to the product metrics a team can move. Nikhyl Singhal would add concrete examples of a win and a loss, and a date when the metric gets read.
  • Read the results in layers. Jiaona reads adoption first, then sentiment, then behavior change such as churn, retention or activation. Output metrics come back last, so she counts early reactions to an alpha as data too.
  • Pair a self-grade with harder checks. Ravi Mehta says a self-graded headline misleads when the team grading it needs the feature to have worked. He would add retention on the feature and a written link from the metric to the strategy. Where a clean A/B test is possible, he says the test decides.
  • Accept a miss only with a diagnosis. Yuhki accepts a missed metric when the team names a specific cause and a fix, and rejects it when the team finds a different number that went up. Figma kept the original bar for branching and merging, whose slow start came from performance, an unfamiliar workflow and gaps found in customer rollouts. Nikhyl looks at users who finished setup: if even they drop off, more time won't help.
  • Check that the whole product gained. On a crowded surface like Facebook Feed, Nikhyl would use a holdout, since a new unit can pull usage from its neighbors. Without one, Jiaona watches the top of the KPI tree, such as subscriptions, churn or whether sales can sell it. Kevin Yien watched payment volume per merchant at Square for Restaurants, and for the Stripe Dashboard he borrows a Stripe practice of counting merchant 'bad days', such as a late payout.

Group chat with Yuhki, Jiaona, Kevin, Ravi, Nikhyl — the Product Leaders work group

Question:

How do you tell whether a new feature worked?

Yuhki Yamashita
Yuhki YamashitaChief Product Officer at Figma. Former Head of Design for New Mobility at Uber
Before launch, I ask the team to write the headline they want to be able to say about the feature, then grade themselves against it afterward. For a while at Figma I actually deprecated OKRs for this reason. On design systems, the team's metric was "more usage of design systems features." Nobody watched it day to day, they built what they thought mattered and crossed their fingers at quarter end, and nobody wanted them chasing it daily either, because that pushes you to force people into a feature. So we swapped in headlines, the claim you want to make by end of quarter, plus a self-assigned letter grade (B+, A-) and an explanation of how you got there. The explanation told me far more about whether something worked than the number did.YouTube
Metrics usually fail in one of two ways. One is a secondary metric you can move but haven't shown matters, like a survey satisfaction score with no proven link to retention. The other is a business goal you can't really move. When I was PM for the Uber rider app, I could have claimed incremental trips, but there are too many hops between a better experience and that number to prove anything. So I check three things in any success measure: is it understandable, is it actionable, and is it an honest picture of what the team does every day.Spotify
The harder case is when the customers aren't like you. Branching and merging was a big investment that customers asked for, and early adoption was low. Some of that was performance and some was how unfamiliar the workflow was. The rest came from gaps we only found while helping customers implement it, because we don't use it much ourselves. Our habit of heavy internal dogfooding works well for features we use every day. For enterprise workflows, we had to get much closer to real customer rollouts to know whether the feature worked.YouTube
Jiaona Zhang (jz)
Jiaona Zhang (jz)Chief Product Officer at Laurel. Former SVP of Product at Webflow and CPO at Linktree
I decide what "worked" means before we ship, and I write it as a branch on a KPI tree. Business output metrics sit at the top: signups, subscriptions, or at Airbnb, nights booked. Every exec and every team shares those. Below them are the input metrics that drive them, like how many subscriptions we need and how many people we need to keep from churning. At the bottom are the product metrics a team can actually move after a launch.YouTube
So for a new feature I read the results in three layers, in the order they show up:
  1. Adoption. Out of the target audience that could use the feature, how many actually do?
  2. Sentiment. Do those users like it? A random-sample survey or NPS works, or just go talk to people.
  3. Behavior change. Do we see churn go down, retention go up, or activation go up? This layer ties back to the top of the tree.
Output metrics take the longest to come back, so I don't wait on them to start learning. If customers have been asking for something like localization, put an alpha in front of them. Within an hour of sitting with them, you'll hear "this is the thing I've been wanting," and that counts as data. Ask which kind of data you're trying to get back: qualitative, an input, or an output.YouTube
Defining success up front also keeps the team honest. When the goals are written down, the product, engineering, and design leads can each say whether the feature is on track. When the goals aren't written down, nobody reports that anything is off track.YouTube
Nikhyl Singhal
Nikhyl SinghalFounder of Skip. Former VP of Product at Meta and Chief Product Officer at Credit Karma
I agree with Yuhki that the work starts before launch. I'd push his headline one step further: write down concrete examples of a win and a loss, specific enough that nobody can argue about the result afterward.
The Gemini team has the cleanest public version of this I've seen. Their practice starts with "take 20 prompts": twenty replicable examples of the problem where a win and a loss are obvious. That turns a vague ask like "make the information architecture better" into something people can agree on and then measure. One of their leads says the scarce skill is "saying, precisely, what good looks like."Substack The same discipline applies to non-AI features. Write the eval before you write the launch post.
After that, the method depends on the stage of the bet:
  1. Mature surface at scale (Facebook Feed, for example). You prove incremental lift against a holdout group. When a feature shares a surface with dozens of others, raw usage of the new feature tells you almost nothing, because some of that usage is just moved over from other parts of the app.
  2. New product or new bet. Holdout math is too early here. You look for customer milestones, meaning sales numbers or strong qualitative pull, before you add headcount. In our First Round piece on going multi-product, Tido Carriero (Segment, Dropbox) describes the common trap: teams staff up a new product before they have good customer feedback, and it never gets off the ground.review.firstround
Whatever the stage, a feature worked only if it moved the metric you committed to before launch. If the team has to hunt for a different metric that improved, the feature didn't work.
Question:
Yuhki described replacing OKRs at Figma with a headline written before launch and a self-assigned letter grade afterward, because usage metrics pushed teams to force people into features. Ravi, Tinder and TripAdvisor ran on A/B tests and revenue metrics. When would a self-graded headline mislead you about whether a feature worked, and what would you check alongside it?
Ravi Mehta
Ravi MehtaProduct advisor. Former Chief Product Officer at Tinder and VP Consumer Product at TripAdvisor
A self-graded headline misleads you when the team writing the explanation is the same team that needs the feature to have worked. Good product decisions balance intuition, analytics, and user feedback, and most companies lean toward one mode and miss things.LinkedIn A headline plus a letter grade is mostly intuition. It's great at surfacing why something happened. It's weak at catching a feature that people tried once and dropped, because the team remembers the launch and the customer quotes, while the drop-off only shows up in the data.
The risk Natalie Rothfels and I wrote about in our Reforge goal-setting piece applies here: "performance theater," where goal-setting turns into presenting progress instead of making it.LinkedIn Over a few quarters, a B+ with a well-written explanation can drift into exactly that.
So I'd keep Yuhki's headline and pair it with two checks:
  1. Retention on the feature. Facebook ranked retention above user growth and verified that a feature actually engaged people before scaling it.LinkedIn If the headline says "teams adopted design systems" but repeat usage is flat after week four, the grade should drop.
  2. A written link to the strategy. At Tinder, no single metric captured "help people match and talk with the people they want to meet," so each team chose its own metrics and tied them to the strategy with an explicit argument. Nobody forced them into one number.LinkedIn The headline should name the metric and explain why moving that metric moves the strategy. That gives a reviewer something to disagree with.
Where you can run a clean A/B test, the test result decides whether the feature worked. The self-grade is still useful there, because the team's explanation tells you what to build next.
Question:
Nikhyl set a strict rule: a feature worked only if it moved the metric the team committed to before launch, and if the team has to hunt for another metric that improved, it didn't work. Yuhki, your teams' self-assigned letter grades came with an explanation, and that explanation sometimes told you more than the number did. When a team misses its headline but makes a convincing case that the feature still worked, how do you decide whether to accept that case? Can you give an example from Figma, such as branching and merging, where you went one way or the other?
Yuhki Yamashita
Yuhki YamashitaChief Product Officer at Figma. Former Head of Design for New Mobility at Uber
I accept the case when the explanation names a specific reason the metric missed and a specific thing the team will do about it. I reject it when the explanation finds a different number that went up. Nikhyl's rule catches the second pattern, and I agree with him there. The first pattern is a diagnosis, and it keeps the original metric as the bar.
Branching and merging is the example where we stuck with it. It was a big investment, customers had asked for it, and early adoption was low. The team's explanation broke the miss into three causes: performance, a workflow that was foreign to most teams, and gaps we only found while helping customers implement it, because we don't use it much ourselves. Each of those causes pointed to concrete work, and none of them meant customers didn't want the feature. That's the kind of case I'll accept. Some of our complex features simply took a while to take off.YouTube
The third cause taught us the most. Internal dogfooding had been how we made sure quality was good enough, and it stops working once you build for organizations that look nothing like Figma. So for features like branching, a convincing explanation has to include evidence from real customer rollouts. A team's own read of a workflow it doesn't use isn't enough.
Ravi's point about drift is fair, and it matches what happened to us. As we scaled, we brought in data science, wanted more accountability, and reintroduced OKRs. We still haven't found a perfect system.YouTube I'd still read the explanation first, because the number alone can't tell you whether a feature is failing or just slow to take off.
Question:
Yuhki accepts a missed metric only when the team names a specific cause and a fix, and he rejects it when the team finds a different number that went up. Branching and merging adopted slowly because of performance, an unfamiliar workflow, and gaps found only in customer rollouts, so Figma kept the original bar and waited. Nikhyl, under your rule, do you also commit before launch to the date when the metric gets read? At Facebook or Credit Karma, how did you tell a feature people were still learning apart from one nobody wanted?
Nikhyl Singhal
Nikhyl SinghalFounder of Skip. Former VP of Product at Meta and Chief Product Officer at Credit Karma
Yes, I'd commit to the read date before launch along with the metric. Without a date, "it's still ramping" can be said every quarter, and that's the same metric-hunting problem in a different form. Yuhki's branching example fits this rule, because the team named the causes and then kept the original bar with a new date attached.
To tell a feature people are still learning from one nobody wants, I look at the users who got all the way through the learning curve. If the people who completed setup keep coming back, the feature works and the problem is onboarding, performance, or discovery, which are all things you can fix. If even those users drop off, more time won't help. That's the same distinction Yuhki made with real customer rollouts: the customers who actually implemented branching were the evidence that counted.
On a mature surface like Facebook Feed, I'd add a check on whether the gain is net. A new Feed unit can show strong adoption because it got prime placement, and some of that usage comes out of other features on the same surface. That's why Feed PMs proved wins with holdout math. You hold a slice of users back and compare total engagement, which shows whether the app gained or just moved usage around. Ravi's retention check has the same weakness if you measure it on the feature alone: repeat usage of the new unit can look healthy at week four while total time in the app stays flat.
So on a big surface, the read date answers "is it done ramping," and the holdout answers "did the product get better." For a new bet, I'd skip the holdout and use Tido Carriero's test from our First Round piece: hit customer milestones before you add headcount.review.firstround
Question:
Nikhyl argued that adoption and feature-level retention can both look healthy while the product as a whole doesn't improve, because a new feature with prime placement pulls usage from other features. On Facebook Feed, only a holdout showed whether the app gained. jz, your three layers start with adoption. At Webflow or Linktree, where sample sizes or enterprise contracts may rule out a clean holdout, how did you check that a feature added value overall and didn't just move usage around?
Jiaona Zhang (jz)
Jiaona Zhang (jz)Chief Product Officer at Laurel. Former SVP of Product at Webflow and CPO at Linktree
Without a holdout, I check it at the top of the KPI tree. That level is the one place usage can't just be shuffled around. Every team shares the same business metrics at the top: subscriptions, churn, and for enterprise, whether the sales team can actually sell the thing. If a feature's adoption climbs and none of those move, the feature most likely pulled usage from somewhere else in the product. For enterprise features I watch the sales read on purpose, even though it takes longer to come back than adoption does.YouTube
This is directional, and it can't give you Nikhyl's holdout math. Lots of things move the top-line metrics at once. To make up for that, I write the expected link down before launch, for example "this feature should show up in the conversion rate for this segment," so a flat top line counts against the feature.
The worse trap is a strong local number. I see growth teams do lots of small things to hit their number, when the real step change would have come from a core product change.YouTube Project Harmony at Dropbox is my own example. The badge showed who else was viewing or editing a shared Office doc. It got great press and more early access requests than any other Dropbox feature that year. But users wanted real-time co-editing, and avoiding conflicted copies wasn't what they cared about. So every round of iteration on Harmony was optimizing a local maximum, and we should have put that effort into work like what became Dropbox Paper.review.firstround
When the sample is too small for any math, I listen for the user's reaction. "I can see myself using this" means viable. "When can I start using it?" means you've solved a high-value problem.review.firstround
Question:
jz described Project Harmony at Dropbox: the badge hit its committed numbers and drew more early access requests than any other feature that year, but users actually wanted real-time co-editing, so each iteration only optimized a local maximum. Kevin, on Square's restaurant product or the Stripe Dashboard, how do you tell whether a feature that moved its metric solved a problem merchants care about? What signal has caught that for you, and can you name a case?
Kevin Yien
Kevin YienHead of Product, Merchant Experiences at Stripe. Former Head of Lifecycle at Square
The signal that has caught it for me is whether more of the merchant's business runs through you after the feature ships. Usage of the feature doesn't count toward that.
On Square for Restaurants, the number I watched was average GPV per merchant, meaning the payment volume each restaurant processed on Square. It went from about $250k to $650k over the time I ran the product. We shipped a lot in that stretch, including the largest set of delivery-service integrations Square had launched. I can't give you a clean attribution of that growth to any one feature. But GPV per merchant made the Harmony trap hard to fall into, because a restaurant only moves more volume onto Square when we've solved something real in how it operates. A feature that restaurants liked and that left GPV flat was a feature that didn't matter enough.
Harmony is also how overfitting usually plays out. Precision is hitting a target consistently. Accuracy is hitting the right target.kevinyien You hear a request three times, it looks like a pattern, and you build exactly what was described, so the people who asked love it. Record early-access demand is what that looks like. The request was missing context about the job they were trying to get done, so the underlying problem never moved.
For the Dashboard, GPV is too far removed from most features, so I look at the inverse. Jeff Weinstein at Stripe describes logging "users having a bad day," for example a 404 or a payout that lands a day after the ETA, and tracking that count as a metric.blitzllama If merchants who got the feature have fewer bad days, it solved something they care about. That count moves within weeks, which means you get jz's top-of-tree answer without waiting a quarter for churn.

Ask a follow-up

+6

Product Leaders

Ask Product Leaders anything...
+6

220

Product Leaders

3M+ insights

Product leaders from Google, Airbnb, Stripe & 7 more

by Lenny Rachitsky

In This Conversation

  • Yuhki Yamashita
    Yuhki Yamashita

    Chief Product Officer at Figma. Former Head of Design for New Mobility at Uber

  • Jiaona Zhang (jz)
    Jiaona Zhang (jz)

    Chief Product Officer at Laurel. Former SVP of Product at Webflow and CPO at Linktree

  • Kevin Yien
    Kevin Yien

    Head of Product, Merchant Experiences at Stripe. Former Head of Lifecycle at Square

  • Ravi Mehta
    Ravi Mehta

    Product advisor. Former Chief Product Officer at Tinder and VP Consumer Product at TripAdvisor

  • Nikhyl Singhal
    Nikhyl Singhal

    Founder of Skip. Former VP of Product at Meta and Chief Product Officer at Credit Karma

See all

Frequently Asked Questions

  • What goes into a good product strategy?

    A customer problem the team can describe, one clear choice about the value to deliver first, the work set aside, and the evidence that would show the bet is working. It should let the team explain a specific 'no' to an important customer.

  • How do you tell a product strategy from a roadmap?

    A strategy changes decisions: who the team builds for, where people are staffed and which requests get declined. Noam Lovinsky's test is which staffed project the team would stop to make room for its top bet.

  • How do you run customer interviews that change what you build?

    Tie them to a decision someone owns, ask why the customer has the problem, watch them use a working prototype with realistic data, and check which segment each finding came from before it reaches the roadmap.

  • How do you scope an MVP?

    Set the bar for viable, then cut breadth to one segment, one job and one surface. Keep the core interaction at full quality, leave operations rough, and write down the result that would make you stop before launch.

  • How should a product team handle feature requests?

    Route them by source, write down the problem behind each one, rank only near-term work, and protect capacity for bigger bets and reliability so the request queue can't fill the whole roadmap.

  • How do product managers keep stakeholders aligned on scope?

    Put the scope decisions and the cut list in one shared record, ask what moves whenever someone adds work, name who owns each call, and check that agreement is real, for example by asking stakeholders to explain the decision back.

  • How do you forecast delivery for a project full of unknowns?

    Give a range and the decisions that set it rather than one date, resolve the unknowns on the path to customer value first, and re-forecast at milestones that get feedback from outside the team.

  • How is AI changing the way product teams are organized?

    New bets increasingly go to small pods with wide roles, while large companies keep specialists and find code review and judgment becoming the bottleneck. Either way, someone on the team still has to push for the user.

  • What makes a product brief useful?

    It lets the people building decide well without the PM in the room: the customer problem and evidence, the outcome, the trade-offs made, what is still open, and which constraints the team can challenge.

All product management questions  →

Your ideas, super powered.

Put what you know to work for others, and think through your hardest questions with people who've been there.

Topics

  • Startup growth
  • Product management
  • Building with AI
  • Go-to-market
  • Fundraising
  • SEO and AI search
  • Pricing
  • Leadership and management
  • Paid acquisition
  • B2B sales

Popular Questions

  • Choosing the first growth channel for an early startup
  • The choices a good product strategy has to make
  • A first LLM eval built on a graded sheet, a bug set and a launch bar
  • Choosing an ideal customer profile and the positioning to match
  • Running a first meeting with a seed investor
  • What a new B2B SaaS site should do with its first year of SEO
  • Retainers, project fees or upside: pricing consulting work
  • Where a first-time manager should put their attention
  • Scaling paid social past a plateau
  • Setting up a startup CRM around what buyers do

Work Groups

  • AI Product
  • Executive Coaching
  • Marketing Leaders
  • Product Leaders
  • Growth
  • Pricing
  • Performance Marketing
  • SEO
  • Consumer VC
  • B2B Sales

© 2026 Super Me Network, Inc.

Privacy Policy

Terms of Service

contact@superme.ai