Custom dashboards in Amplitude let you pull together the specific metrics that matter to your product—without waiting for an analyst to build them. Instead of digging through rows of raw events, you can track user cohorts, monitor feature adoption rates, and analyze funnel drop-off all in one place, updated in real time.
Creating and Configuring Your Dashboard
Start by setting up a new dashboard and configuring its baseline settings. This is where you'll add all your charts.
Step 1: Create a new dashboard
Go to the Dashboards tab in your Amplitude project and click Create Dashboard. Give it a specific name that describes what you're tracking—avoid generic names like 'Metrics' or 'Analytics'. Something like 'Onboarding Funnel—Q1 2024' or 'Feature Adoption by Cohort' helps your team understand what they're looking at. Dashboards are saved at the project level, so all team members with access to your Amplitude project can view and edit them.
// Before dashboards display useful data, your app needs to track events
import * as amplitude from '@amplitude/analytics-browser';
amplitude.init('YOUR_API_KEY');
// Track feature adoption events that will populate your dashboard
amplitude.track('Feature Used', {
feature_name: 'custom_dashboard',
user_type: 'analyst',
timestamp: new Date()
});Step 2: Configure dashboard time range and filters
Once created, set a Time Range (last 7 days, last 30 days, or a custom range) and optional Dashboard Filters to narrow your data. For example, filter by user segment ('power users'), geographic region, or subscription tier. These dashboard-level filters apply to every single chart on the dashboard at once, so you don't have to repeat the same filter on each individual chart. This is much faster than creating separate dashboards for each segment you want to analyze.
// Use Amplitude's HTTP API to fetch analytics data with time range
const startTime = Math.floor(Date.now() / 1000) - (7 * 24 * 60 * 60); // 7 days ago
const endTime = Math.floor(Date.now() / 1000);
const response = await fetch('https://api.amplitude.com/2/export', {
method: 'POST',
headers: {
'Authorization': `Bearer ${AMPLITUDE_API_TOKEN}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
start: new Date(startTime * 1000).toISOString(),
end: new Date(endTime * 1000).toISOString()
})
});
const data = await response.json();
console.log('Events in time range:', data);Adding Charts and Configuring Metrics
Charts transform raw events into visual insights. Amplitude offers several chart types—here's how to add and configure the most useful ones.
Step 3: Add a Segmentation chart
Click Add Chart and select Segmentation. Choose the event you want to analyze (e.g., 'Feature Used'), then pick your metric: count of events, unique users, or conversion rate. Finally, choose a breakdown dimension—for example, user_type, country, or subscription_tier. Amplitude will immediately visualize the distribution across that dimension in a bar chart. The more detailed your event properties, the more dimensions you can segment by.
// Include rich event properties to enable powerful segmentation in dashboards
amplitude.track('Feature Used', {
feature_name: 'custom_dashboard',
user_type: 'analyst', // Segmentation dimension
company_size: 'enterprise', // Another dimension
is_premium: true, // Boolean dimension
usage_minutes: 45, // Numeric dimension
region: 'EMEA' // Geographic dimension
});Step 4: Add Retention or Funnel charts
Retention charts show user return behavior over time. Select a start event ('Signed Up') and a return event ('Made Purchase'), and Amplitude shows you what percentage of users from day 1 came back on day 7, day 30, etc. Funnel charts are for sequential user flows—define 2 to 10 steps (e.g., 'Signed Up' → 'Added Card' → 'Made Purchase') and Amplitude reveals drop-off rates at each stage. Both chart types support segmentation, so you can see how retention or conversion varies across user cohorts.
// Track the sequential funnel steps that will be visualized in your dashboard
amplitude.track('Signed Up', {
signup_source: 'email',
signup_date: new Date()
});
amplitude.track('Added Card', {
card_type: 'visa',
payment_method: 'card'
});
amplitude.track('Made Purchase', {
purchase_amount: 99.99,
product_category: 'analytics',
is_first_purchase: true
});Step 5: Configure chart-level drill-down and filters
Most Amplitude charts support Drill Down—click a bar in a segmentation chart to see a filtered view of that segment's data. You can also add Chart Filters to show only rows that meet specific criteria (e.g., show only rows where user_type = 'analyst'). Use drill-down to investigate outliers or unexpected trends without cluttering your main dashboard view. Chart filters are useful for hiding noise—for example, filtering out internal team usage so it doesn't skew your metrics.
// Example: fetch events with filters applied before visualization
const response = await fetch('https://api.amplitude.com/2/export', {
method: 'POST',
headers: {
'Authorization': `Bearer ${AMPLITUDE_API_TOKEN}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
start: startDate,
end: endDate,
event: 'Feature Used',
filters: [
{ property: 'user_type', operator: 'is', values: ['analyst'] },
{ property: 'is_internal_user', operator: 'is not', values: [true] }
]
})
});
const filtered = await response.json();
console.log('Filtered data excluding internal users:', filtered);Sharing Dashboards and Keeping Data Fresh
A dashboard is only useful if your team can access it and the data stays current.
Step 6: Share dashboards and configure auto-refresh
Click Share on your dashboard to invite specific team members or generate a public link. Set Auto Refresh (e.g., every 1 hour) so everyone sees the latest data without manually refreshing. You can also export the entire dashboard as a PDF for reports or stakeholder meetings. Be aware that public links expose your event data to anyone with the link, so avoid sharing customer data or sensitive metrics externally.
// Programmatically poll the API to keep an external dashboard in sync
setInterval(async () => {
const response = await fetch('https://api.amplitude.com/2/export', {
method: 'POST',
headers: {
'Authorization': `Bearer ${AMPLITUDE_API_TOKEN}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
start: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
end: new Date().toISOString(),
event: 'Feature Used'
})
});
const freshData = await response.json();
console.log('Dashboard data refreshed at', new Date(), freshData);
}, 60 * 60 * 1000); // Refresh every hourCommon Pitfalls
- Tracking events without properties—if you don't send
user_typeorcountryin yourtrack()calls, you won't be able to segment by them in dashboards. Always include relevant properties when you track. - Using generic event names ('click', 'pageview', 'action') instead of descriptive names ('Feature Used', 'Onboarding Completed'). Generic names make dashboards harder to interpret and harder for other team members to reuse.
- Adding too many charts to one dashboard (15+). Dashboards slow down with too many visualizations, and they become harder to scan. Create separate dashboards for different workflows or user personas instead.
- Ignoring Amplitude's free-tier limits—the free plan restricts the number of dashboards and chart types you can create. If you're building comprehensive analytics, plan to upgrade early.
Wrapping Up
Custom dashboards in Amplitude turn raw event data into actionable insights your whole team can understand. Start by tracking events with rich properties, then layer on segmentation, retention, and funnel analysis to uncover patterns. Share dashboards with your team so everyone stays aligned on progress. If you want to track this automatically across tools, Product Analyst can help.