Loading tutorials…
Loading tutorials…
Most Amplitude projects break in month three because of decisions made in the first hour. This walks through workspace setup, identity resolution, and the early taxonomy choices that determine whether your data is trustworthy six months from now.
Who this is forProduct, growth, or founder-led teams standing up Amplitude for the first time. Especially relevant if you're moving from GA4 or starting fresh on a SaaS product where you need real user-level analytics, not aggregate web metrics.
What you'll need
Step 1
In Amplitude, a Workspace is the org-level container; a Project is where data lives. Most SaaS teams need one workspace and 2-3 projects (dev/staging/prod).
Sign up at amplitude.com. Choose "Plus" or "Growth" plan based on event volume — free tier (Starter) is fine to validate but caps at 10M events/month and lacks Pathfinder.
Inside Amplitude → Organization Settings → Projects → "Create Project." Name it clearly: `web-prod`, `web-staging`, `web-dev`. Avoid one shared project for all environments — staging data poisons production charts.
Each project gets its own API Key + Secret Key. Find them at Settings → Projects → [Project Name] → General. Treat the Secret Key like a database password.
If you have a mobile app, create a separate project for it (e.g., `ios-prod`) — server-side configs and SDKs differ enough that mixing them creates support headaches.
Set the project timezone to match your business timezone, not UTC. This affects how "Day" buckets are computed in Charts and is hard to change later without rebuilding dashboards.
Step 2
Pick the SDK that matches your stack — Browser SDK 2 for web, React Native / iOS / Android for mobile, Node for server-side. Init it on app load with the project API key.
For web, install `@amplitude/analytics-browser` (Browser SDK 2). Initialize at app load: `amplitude.init(API_KEY, { defaultTracking: true })`. The `defaultTracking` flag enables page-views, sessions, form interactions, and file downloads automatically — saves 4-6 hours of manual instrumentation.
For React/Next.js, init in a top-level Client Component or `_app.tsx` (Pages Router) / `app/layout.tsx` (App Router). Do not init in Server Components — there is no browser to instrument.
For mobile, the iOS/Android SDKs require initialization in `AppDelegate`/`Application.onCreate`. Use the `start()` method, not `init()` — the SDK names differ between web and mobile.
For server-side events (Stripe webhooks, server-triggered emails), install `@amplitude/analytics-node` and use the Secret Key, not the public API Key. Mixing these is a common security mistake.
Test the install: open Amplitude → Data → Sources. The source you just created should show "Events Received" within 60 seconds of your first deploy.
Step 3
Amplitude has two identifiers: `user_id` (your stable user ID) and `device_id` (anonymous). Picking the wrong `user_id` permanently fragments your data.
When a user is anonymous, Amplitude assigns a `device_id` automatically. When they log in, you call `amplitude.setUserId(yourStableId)`. Amplitude then merges anonymous + logged-in sessions for that user — this is called "identity resolution."
The `user_id` you pass MUST be stable for the lifetime of the user. Use your database's primary key (e.g., `user.id` from Postgres), not email (changes), not username (changes), not phone (changes).
Never set `user_id` to a session ID or anything ephemeral — Amplitude will treat every session as a new user and your retention charts will look catastrophic.
For B2B SaaS, also set a `group` (org/company) with `amplitude.setGroup("organization", orgId)`. This unlocks org-level analytics in Charts (rare on the free tier — check your plan).
For multi-product companies, decide whether to track `account_id` as a user property or via groups. Groups are more flexible but require Plus plan or higher.
Step 4
Set up PII masking, IP blocking for internal traffic, and EU data residency (if applicable) BEFORE you start tracking real users.
Settings → Projects → [Project] → "PII Defaults." Amplitude masks IP addresses automatically by default in EU regions, but does not mask user properties named `email` or `name`. Add custom mappings if you must record these.
In Settings → Projects → "Internal IP Filters," add your office IP and any developer home IPs. Internal traffic skews funnel data — especially for early-stage products where the founding team is 30% of the events.
For EU/UK customers under GDPR, switch your project to Amplitude's EU data center via Settings → Organization → Data Residency. This is one-way — you can't move data later. Pick this before you have any real production data.
Settings → "User Sessions" defines the session timeout (default: 30 minutes). For SaaS tools where users stay logged in all day, increase to 60-90 minutes — otherwise every coffee break becomes a new session and your "Sessions per User" metric becomes meaningless.
If you handle health data, financial data, or anything HIPAA/PCI-relevant, enable Amplitude's HIPAA mode (Growth plan and above) before any events flow.
Step 5
Open Amplitude → Data → Tracking Plan. Define every event name + properties before you write a single instrumentation line. The plan is the contract between product, eng, and analytics.
Use Amplitude's Tracking Plan UI (Data → Tracking Plan → "Create new plan") to define each event. Format: `Object Verb` ("Signup Submitted," "Subscription Started," "Article Viewed"). Past tense, sentence case.
For each event, define required properties (must exist on every event) vs optional. Required properties typically include `plan_tier`, `org_id`, `feature_area`.
Mark events as either "Live," "In Development," or "Deprecated." This becomes the source of truth — devs ship code referencing the plan, analytics rejects non-conforming events.
Use Amplitude's Data Guard or the standalone Iteratively for stricter schema enforcement if you have multiple eng teams shipping events. For small teams, the in-app Tracking Plan is sufficient.
Export the plan as JSON or CSV and version-control it. The taxonomy is the most expensive thing to change later — every consumer of your data depends on it.
Step 6
Enable default tracking on the Browser SDK, then add `setUserProperties()` for the dimensions you'll slice by (plan, role, signup date, company size).
In `amplitude.init()`, set `defaultTracking: { pageViews: true, sessions: true, formInteractions: true, fileDownloads: true }`. This gives you `[Amplitude] Page Viewed` events automatically.
For SPAs (React Router, Next.js App Router), the default `pageViews: true` may miss client-side route changes. Add a `usePathname()` listener and call `amplitude.track("Page Viewed", { path: pathname })` on every route change.
On every login/signup, call `amplitude.setUserId(user.id)` then `amplitude.setUserProperties({ plan: "pro", role: "admin", signup_date: user.createdAt, company_size: org.size })`.
User properties are mutable — Amplitude stores the latest value, NOT historical values. To track "what plan was the user on at the time of the event," set the property as an EVENT property too: `amplitude.track("Feature Used", { plan: user.plan })`.
Avoid setting more than 50 user properties per user. After that, Amplitude charts get slow and noisy.
Step 7
In Amplitude → Data → User Lookup, find your own test user and confirm events flow with the right properties. Then run a sample chart to confirm aggregation works.
Open Amplitude → Data → User Lookup. Search for your own `user_id` or email. The event stream should show events in chronological order with all properties.
Trigger a known event (e.g., "Signup Submitted") from your staging environment. Verify it appears within 30-60 seconds with the correct properties.
Build a quick Charts → Segmentation chart of that event over the last 7 days. If the chart is empty or zero, the SDK is either misconfigured or events aren't firing.
Build a simple funnel: Signup Submitted → First Feature Used → Subscription Started. If the funnel returns sensible numbers across 7-14 days of data, your taxonomy is internally consistent.
Announce the project ready only after at least 3 stakeholders (product, eng, analytics) have validated their key events appear correctly.
Common mistakes
One shared project across dev, staging, and production
What goes wrong: Test events from staging contaminate production charts. Your "New Users This Week" includes 30% QA accounts. Bid-related decisions in marketing get made on dirty data — easily wasting $500-2,000/mo in misallocated spend.
How to avoid: Create separate projects per environment from day one. Migration after the fact requires writing an event-filter and waiting 30-90 days for clean baselines.
Using email as the user_id
What goes wrong: When users change emails, they become two separate users. Retention charts artificially collapse. You can't tell a 90-day retained user from a brand-new one. SaaS dashboards lie by ~10-15%.
How to avoid: Always use your database primary key (`user.id`) as the Amplitude `user_id`. Email goes in as a user property only.
Setting timezone to UTC instead of business timezone
What goes wrong: Daily Active Users (DAU) buckets cross midnight UTC, splitting a single working day across two "days." US-based teams report incorrect DAU/WAU numbers and miss real weekly patterns.
How to avoid: Settings → Project → Time Zone → set to your business HQ timezone (e.g., America/New_York). This is set per project at creation; changing later forces all historical charts to recompute.
Tracking events without a Tracking Plan
What goes wrong: You end up with `Signup`, `Sign Up`, `signup_completed`, and `user_signed_up` — four versions of the same event. Every funnel is wrong by 50%+ and you spend $4,000-8,000 in eng time consolidating taxonomy six months in.
How to avoid: Use Amplitude's Data → Tracking Plan UI before any event is shipped. Lock event names + required properties. Reject non-conforming events at the SDK layer.
No internal IP filtering
What goes wrong: Your dev team running QA accounts looks like 20% of your active user base in early-stage products. Pricing/packaging decisions get made on synthetic data. Cohort metrics overstate stickiness by 15-30%.
How to avoid: Settings → Projects → Internal IP Filters → add office IPs + main dev IPs. Update quarterly as the team grows.
Recap
Done — what's next
How to set up Amplitude event tracking the right way
Read the next tutorial
Hand it off
Most founders we talk to want analytics they can trust *and* don't want to be the one fixing taxonomy six months later. A vetted product-analytics specialist sets up Amplitude correctly — identity, taxonomy, and validation — then maintains it as you grow. From $14-16/hr; most ongoing engagements land at $300-900/mo.
See specialist rates
No — the free Starter plan supports identity resolution, tracking plan, and Charts. You hit limits on Pathfinder (Plus and up), advanced cohorts (Plus and up), Experiments (Growth), and event volume (10M events/month on Starter). Most early-stage SaaS can run on free for the first 12-18 months.
Both, with different jobs. Browser SDK for in-app behaviour (page views, clicks, feature usage). Server SDK (`@amplitude/analytics-node`) for events you cannot lose: payments, subscription changes, webhook events. Mixing them properly requires shared `user_id` on every event.
Yes, with caveats. Amplitude's "CSV import" supports backfilling historical events, but the event taxonomy must match your new tracking plan. Mixpanel events port over cleanly because the schema is similar; GA4 events need flattening (no `event_params` array). Plan 2-3 weeks of analyst time per platform.
Pricing is event-volume based: Starter (free, 10M events/mo), Plus (paid, starts ~$49K/yr at scale), Growth (custom enterprise). The trick is that one user action can fire 5-15 events, so 10M events ≠ 10M actions. Most SaaS teams hit Plus pricing around 500-2,000 monthly active users.
For most SaaS, yes — keep GA4 for marketing attribution (Google Ads, Meta Ads, organic search) and Amplitude for in-product behavior. They answer different questions. See our `connect-google-ads-with-ga4` tutorial for the GA4 side.
Amplitude
Bad event tracking is the most common reason Amplitude projects fail. Here is the naming convention, the SDK code, and the Data Guard rules that keep your taxonomy clean for years — not weeks.
Amplitude
Cohorts and Personas are where Amplitude beats GA4 by a mile. But most teams build sloppy cohorts and end up with overlapping segments that conflict. Here's the discipline that keeps them clean.
Amplitude
Amplitude and Mixpanel are the two dominant product analytics platforms in 2026. They look similar from the outside but the right pick depends on what you actually need. Here's the honest comparison.
Amplitude
DIY Amplitude is a great idea — until your taxonomy gets out of control or your charts disagree with reality. This is the honest framework for when the math flips toward hiring.