When you ship a new feature, you need to know who's actually using it and how fast adoption is growing. Amplitude lets you track feature adoption events and visualize adoption curves in real time—but you need to instrument the right events and set up segmentation correctly to get meaningful data.

Step 1: Instrument Feature Adoption Events

Start by tracking when users interact with your feature. You need to send events that mark adoption milestones—first view, first interaction, regular use.

Add a feature adoption event to your client code

Use the Amplitude Web SDK to track when a user first accesses or uses your feature. Call amplitude.logEvent() with a descriptive event name and attach properties like feature version or adoption date.

javascript

import * as Amplitude from '@amplitude/analytics-browser';

// Initialize Amplitude
await Amplitude.init('YOUR_API_KEY').promise;

// Track feature adoption when user first accesses the feature
Amplitude.logEvent('Feature Adopted', {
  feature_name: 'new_dashboard',
  adoption_date: new Date().toISOString(),
  feature_version: '2.0'
});

// Also set a user property to mark them as an adopter
Amplitude.setUserProperties({
  has_adopted_dashboard: true,
  dashboard_adoption_date: new Date().toISOString()
});

Log feature adoption when users first access the feature, and set a user property to identify adopters.

Track repeated usage to measure engagement

Beyond first adoption, log an event each time a user interacts meaningfully with the feature. This lets you measure engagement depth, not just initial adoption. Track metrics like time spent or action count.

javascript

// Track each time user performs a core action in the feature
Amplitude.logEvent('Dashboard View', {
  feature_name: 'new_dashboard',
  view_type: 'daily_metrics',
  time_in_feature_seconds: 45
});

// Update recency tracking
Amplitude.setUserProperties({
  last_dashboard_view: new Date().toISOString(),
  dashboard_views_count: userInteractionCount
});

Log interaction events to track engagement depth and update recency properties.

Watch out: If you only track "Feature Adopted" once, you won't see engagement metrics. Log interaction events separately to measure how deeply users use the feature after adoption.

Step 2: Visualize Adoption with Events and Segmentation

Once events are flowing into Amplitude, use the Events chart to segment and visualize adoption over time.

Create an events chart filtered to your feature

In Amplitude, go to Analytics > Events. Select your feature adoption event (e.g., Feature Adopted). The default chart shows raw event counts by day—you'll see adoption spike when the feature launches.

javascript

// If building a custom dashboard, use the Amplitude REST API:
fetch('https://api.amplitude.com/2/events', {
  method: 'POST',
  headers: { 
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    event_type: 'Feature Adopted',
    start_date: '2025-01-01',
    end_date: '2025-03-26'
  })
}).then(r => r.json());

// Returns adoption counts by day, used to visualize adoption curve

The Events chart shows adoption velocity. Date segmentation reveals whether adoption accelerates or plateaus.

Add segmentation by user properties to see cohort adoption

To understand adoption across user segments, add a Segmentation filter. For example, segment by user_plan or company_size to see which user types adopt fastest. In the UI, click Segmentation > Add and choose your property.

javascript

// In your client code, set properties that enable segmentation:
Amplitude.setUserProperties({
  user_plan: 'pro',          // or 'free', 'startup', 'enterprise'
  company_size: 'mid-market', // or 'small', 'enterprise'
  has_adopted_dashboard: true
});

// In the Amplitude UI, segment the adoption chart by user_plan:
// Events > Feature Adopted > Segmentation > user_plan
// Result: separate adoption curves for free vs pro vs enterprise users

Set user properties early so you can segment adoption by user cohort in Amplitude.

Switch to cumulative view to see total adopter count

By default, the Events chart shows daily counts (how many adoption events fired each day). Switch to Cumulative view to see the total number of unique users who have adopted over time. In the chart settings, select Cumulative Count.

javascript

// If building a custom dashboard, compute cumulative adoption:
fetch('https://api.amplitude.com/2/events', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${API_KEY}` },
  body: JSON.stringify({
    event_type: 'Feature Adopted',
    start_date: '2025-01-01',
    end_date: '2025-03-26',
    group_by: ['day'],
    metric: 'unique_users'  // Count distinct users, not raw events
  })
}).then(r => r.json());

// Compute cumulative sum client-side
const cumulative = adoptionData.reduce((acc, day) => {
  const prev = acc[acc.length - 1]?.cumulative || 0;
  acc.push({
    date: day.date,
    cumulative_adopters: prev + day.unique_users
  });
  return acc;
}, []);

Cumulative count shows total adopters over time. This reveals whether adoption is accelerating or plateauing.

Tip: Use Cumulative Count to see adoption curves—this is the clearest signal of adoption velocity. Daily event counts are volatile and can mask underlying trends.

Step 3: Compare Adopters vs. Non-Adopters with Cohorts

Once you have adoption data, you can segment users and measure whether adoption correlates with better outcomes like retention or revenue.

Create a cohort for feature adopters

Go to Cohorts > Create New Cohort. Define adopters as users who have the property has_adopted_dashboard: true (set via setUserProperties() earlier). This cohort now includes all users who have adopted.

javascript

// In your client code, mark adopters with a property:
Amplitude.setUserProperties({
  has_adopted_dashboard: true,
  dashboard_adoption_date: new Date().toISOString()
});

// In the Amplitude UI, create a cohort:
// Cohorts > Create New > Add Criteria
// Property: has_adopted_dashboard = true
// Save as "Dashboard Adopters"
// This cohort is now queryable in retention, funnels, and segmentation

Define cohorts using user properties set at adoption time.

Compare retention between adopters and non-adopters

Use Retention to measure whether adopters stay more engaged. Go to Analytics > Retention, select your "Dashboard Adopters" cohort, and measure a return event (e.g., daily active use or specific feature interactions). Adoption should correlate with higher retention.

javascript

// Use the REST API to compare cohort retention:
fetch('https://api.amplitude.com/2/retention', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${API_KEY}` },
  body: JSON.stringify({
    user_property_filter: {
      property: 'has_adopted_dashboard',
      value: 'true'
    },
    event: 'Dashboard View',
    start_date: '2025-01-01',
    group_by: 'week',
    retention_type: 'event'
  })
});

// Compare against non-adopters by flipping the filter:
// user_property_filter { property: 'has_adopted_dashboard', value: 'false' }

Retention data shows whether adopters remain active longer than non-adopters.

Watch out: If your cohort is too small (< 100 users), retention data will be noisy. Wait until adoption reaches meaningful scale before analyzing retention curves.

Common Pitfalls

Logging adoption only once per user: You won't see engagement depth. Log interaction events separately to distinguish between one-time users and power users.
Using raw event counts instead of cumulative: Daily adoption events are volatile. Always use cumulative count to see the real adoption curve and spot growth deceleration.
Not setting user properties at adoption time: Without properties like has_adopted_dashboard, you can't segment or build cohorts. Always call setUserProperties() when adoption occurs.
Confusing total events with unique adopters: If a user logs 50 interactions, that's 50 events but only 1 adopter. Use unique user metrics or cohort-based counting for accurate adoption numbers.

Wrapping Up

You now have a complete picture of feature adoption: you're tracking adoption events, visualizing adoption curves in Amplitude, and comparing adopter behavior against non-adopters. Watch for adoption velocity dips—they often signal UX friction you can fix. If you want to track feature adoption automatically across your entire product stack, Product Analyst can help.

How to Visualize Feature Adoption in Amplitude

Step 1: Instrument Feature Adoption Events

Add a feature adoption event to your client code

Track repeated usage to measure engagement

Step 2: Visualize Adoption with Events and Segmentation

Create an events chart filtered to your feature

Add segmentation by user properties to see cohort adoption

Switch to cumulative view to see total adopter count

Step 3: Compare Adopters vs. Non-Adopters with Cohorts

Create a cohort for feature adopters

Compare retention between adopters and non-adopters

Common Pitfalls

Wrapping Up