You shipped a feature but have no idea who's actually using it. Amplitude makes it easy to see which users are adopting your new feature, when they started using it, and how it compares across segments. The key is sending the right event data and analyzing it with the right tools.
Send Feature Events to Amplitude
Every time a user interacts with your new feature, send an event to Amplitude with properties that describe their action.
Initialize the SDK and track feature interactions
Install the Amplitude JavaScript SDK and initialize it with your API key. When users interact with your feature, call amplitude.track() with an event name and properties that identify what they did.
import * as amplitude from '@amplitude/analytics-browser';
// Initialize
amplitude.init('YOUR_API_KEY', {
defaultTracking: true
});
// Track when user opens the feature
amplitude.track('Feature Opened', {
feature_name: 'advanced_filters',
feature_version: '1.0'
});
// Track when user completes an action in the feature
amplitude.track('Filter Applied', {
feature_name: 'advanced_filters',
filter_type: 'date_range',
result_count: 42
});Set user properties to track adoption status
Use amplitude.identify() to set properties like whether a user has adopted your feature, when they first used it, and how many times they've come back. This makes it easy to build cohorts and segment your analysis.
// When a user first uses the feature
amplitude.identify(new amplitude.Identify()
.set('adopted_advanced_filters', true)
.set('feature_adoption_date', new Date().toISOString())
.increment('feature_usage_count', 1)
);
// Later, update the count when they use it again
amplitude.identify(new amplitude.Identify()
.increment('feature_usage_count', 1)
);feature_version property to your events so you can track adoption separately for each rollout phase. Watch out: Don't track the same event twice from different sources (client and server) — pick one source of truth to avoid inflated numbers.Build Cohorts of Feature Adopters
Once your events are flowing into Amplitude, segment users into adopters vs. non-adopters using cohorts.
Create a cohort in the Amplitude UI
Go to Data > Cohorts and create a new cohort. Define your adopters as users who triggered your feature event at least once. You can filter by date range, event properties, or user properties to refine the definition.
// Use the Amplitude Cohort API to fetch cohort membership programmatically
const response = await fetch('https://api.amplitude.com/api/2/cohorts/compute', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_TOKEN',
'Content-Type': 'application/json'
},
body: JSON.stringify({
cohort_definition: {
match: 'any',
clauses: [
{
event_filter: {
event_type: 'Feature Opened',
event_properties: [
{
key: 'feature_name',
value: 'advanced_filters'
}
]
}
}
]
}
})
});
const adopters = await response.json();
console.log('Total adopters:', adopters.data.size);Compare adopter engagement vs. non-adopters
In Analytics > Segmentation, build a chart that measures engagement (like daily active users or key event frequency) broken down by your adopter cohort. This shows whether your feature is sticky and drives retention.
// In Segmentation view, create two segments:
// Segment 1: "adopted_advanced_filters = true"
// Segment 2: "adopted_advanced_filters = false"
// Measure any key metric: "Daily Active Users" or "Session Started"
//
// This visualization will show:
// - Are adopters more active than non-adopters?
// - Is the gap widening or shrinking over time?Measure Adoption Rate Over Time
Visualize how adoption is trending and which user segments are adopting fastest using Amplitude's retention and funnel analysis.
Track adoption velocity with Retention
In Analytics > Retention, set your feature's first-use event as the starting event. This shows what percentage of users come back to use your feature again — a key indicator of stickiness. If retention drops after 3 days, the feature may need iteration.
// Send events that reflect the user's journey through your feature
amplitude.track('Feature Opened', {
feature: 'advanced_filters',
plan_tier: user.plan_tier
});
// Wait for user to interact
if (userClickedFilter) {
amplitude.track('Filter Created', {
feature: 'advanced_filters',
filter_complexity: 'simple'
});
}
if (userAppliedFilter) {
amplitude.track('Filter Applied', {
feature: 'advanced_filters',
result_count: 42
});
}Segment adoption by user properties
In any analytics view, click Segment and break down your adoption numbers by properties like plan tier, signup date, or user role. This reveals which audiences adopt fastest and which ones need more education.
// Always send segmentation properties with your events
amplitude.track('Feature Opened', {
feature: 'advanced_filters',
plan_tier: user.plan_tier, // 'free' | 'pro' | 'enterprise'
signup_cohort: user.signup_month, // '2025-01' | '2025-02' etc
region: user.country, // 'US' | 'EU' | 'APAC'
is_power_user: user.event_count > 50 // boolean for custom segments
});Common Pitfalls
- Tracking events only during the beta phase — adoption stops being measured once the feature goes public, so you can't compare early adopters vs. late adopters
- Using vague event names like 'Button Clicked' instead of 'Advanced Filter Opened' — you'll lose context when analyzing adoption months later
- Forgetting to send user properties — you can't segment adoption by plan tier or signup date without setting these properties first
- Conflating 'feature opened' with 'feature adopted' — someone might have clicked into your feature by accident. Set a minimum threshold like 3 uses in 7 days to identify real adopters
Wrapping Up
You now have a clear picture of who's using your feature, how often they return, and which user segments adopt fastest. Track these metrics weekly, compare them to your rollout plan, and iterate based on what the data shows. If you want to automatically track feature adoption and set up benchmarks across all your tools, Product Analyst can help.