Product Analytics Tools: How to Choose and Implement the Right Stack

By Viprasol Tech Team

---

Product analytics tells you what users are doing in your application — which features they use, where they drop off, which actions predict retention, and which paths lead to conversion. Without it, product decisions are made on intuition and HiPPO (highest-paid person's opinion). With it, you can run experiments, measure outcomes, and iterate on what actually works.

The most common analytics failure: installing a tool, adding a few page view events, and never looking at the data again. The value is in the implementation — specifically, in instrumenting the right events that map to your product's key workflows.

---

Tool Comparison: The Main Options

For most B2B SaaS products in 2026: PostHog covers product analytics + feature flags + session recording + A/B testing in one tool at a lower cost than buying separate tools. It's the default recommendation unless you have specific reasons to use Mixpanel or Amplitude.

Segment as a routing layer: If you're sending events to multiple tools (analytics + data warehouse + marketing automation), Segment sits in front of all of them. You instrument once; Segment routes to each destination. Worth the added cost at $10K+/month MRR when you're running multiple tools simultaneously.

---

Event Tracking Schema Design

This is the highest-leverage decision in analytics implementation. A well-designed event schema makes every future analysis easy. A poor one means re-instrumenting.

Naming conventions:

Object + Action (past tense):
  project_created
  task_completed
  subscription_upgraded
  report_exported
  team_member_invited

NOT:
  click_create_button  ← describes UI, not user intent
  page_view            ← too vague
  create               ← missing object context

Event property standards:

// Every event should include these base properties
interface BaseEventProperties {
  userId:      string;
  tenantId:    string;
  sessionId:   string;
  appVersion:  string;
  platform:    'web' | 'mobile' | 'api';
  // Note: analytics libraries add timestamp, IP, user agent automatically
}

// Object-specific properties on top of base
interface ProjectCreatedProperties extends BaseEventProperties {
  projectId:        string;
  projectName:      string;
  visibility:       'private' | 'team' | 'public';
  templateUsed:     boolean;
  templateId?:      string;
  memberCount:      number;
  creationFlow:     'onboarding' | 'sidebar' | 'empty_state' | 'dashboard';
}

The creationFlow property is critical — it answers "which path to project creation converts best?" without requiring a separate event per entry point.

---

Implementation: PostHog with TypeScript

Server-side tracking (preferred for B2B):

Server-side events can't be blocked by ad blockers, have access to server-side data (subscription tier, account age), and are more reliable than client-side.

import { PostHog } from 'posthog-node';

const posthog = new PostHog(process.env.POSTHOG_API_KEY!, {
  host:      'https://app.posthog.com',
  flushAt:   20,    // batch size
  flushInterval: 10000,  // flush every 10 seconds
});

// Shutdown gracefully — flush remaining events
process.on('SIGTERM', () => posthog.shutdown());

export function trackEvent(
  userId: string,
  event:  string,
  properties: Record<string, unknown> & { tenantId: string }
) {
  posthog.capture({
    distinctId: userId,
    event,
    properties: {
      ...properties,
      appVersion: process.env.APP_VERSION,
      platform:   'web',
    },
    groups: {
      company: properties.tenantId,  // group analytics by tenant
    },
  });
}

// Usage in a route handler
app.post('/v1/projects', requireAuth, async (req, res) => {
  const project = await createProject(req.body, req.user.id);

  trackEvent(req.user.id, 'project_created', {
    tenantId:     req.user.tenantId,
    projectId:    project.id,
    visibility:   project.visibility,
    templateUsed: !!req.body.templateId,
    creationFlow: req.body.source ?? 'unknown',
    memberCount:  0,
  });

  return res.status(201).json(project);
});

User identification and traits:

// Called on signup and after any profile update
export function identifyUser(userId: string, traits: {
  tenantId:      string;
  email:         string;
  name:          string;
  plan:          string;
  createdAt:     Date;
  trialEndsAt?:  Date;
}) {
  posthog.identify({
    distinctId: userId,
    properties: {
      email:       traits.email,
      name:        traits.name,
      plan:        traits.plan,
      created_at:  traits.createdAt.toISOString(),
      trial_ends:  traits.trialEndsAt?.toISOString(),
    },
  });

  // Group identify for tenant-level analytics
  posthog.groupIdentify({
    groupType:    'company',
    groupKey:     traits.tenantId,
    properties: {
      plan:        traits.plan,
      created_at:  traits.createdAt.toISOString(),
    },
  });
}

Client-side tracking (for UI interactions):

// posthog-js for browser
import posthog from 'posthog-js';

posthog.init(process.env.NEXT_PUBLIC_POSTHOG_KEY!, {
  api_host:             'https://app.posthog.com',
  capture_pageview:     false,   // handle manually for SPAs
  capture_pageleave:    true,
  autocapture:          false,   // explicit events only — autocapture creates noisy data
  disable_session_recording: process.env.NODE_ENV !== 'production',
  loaded: (ph) => {
    if (process.env.NODE_ENV === 'development') ph.opt_out_capturing();
  }
});

// React hook for consistent tracking
function useAnalytics() {
  const { user } = useCurrentUser();

  const track = useCallback((event: string, properties?: Record<string, unknown>) => {
    if (!user) return;
    posthog.capture(event, {
      ...properties,
      userId:   user.id,
      tenantId: user.tenantId,
      plan:     user.plan,
    });
  }, [user]);

  return { track };
}

// Usage in a component
function CreateProjectButton({ source }: { source: string }) {
  const { track } = useAnalytics();

  return (
    <button onClick={() => {
      track('create_project_clicked', { source, location: 'header' });
      openCreateProjectModal();
    }}>
      New Project
    </button>
  );
}

---

The Events That Actually Matter

Instrument these first — everything else is secondary:

Activation events (user realizes value for the first time):

• project_created, first_report_generated, first_integration_connected
• The activation event is product-specific — it's the "aha moment" before users start paying

Engagement events (ongoing value delivery):

• Core workflow completions: task_completed, report_exported, team_member_invited
• Feature adoption: feature_X_first_used (once per user)

Retention predictors (actions that correlate with long-term retention — find these through cohort analysis):

• Often the same as engagement events, but frequency matters
• "Users who complete 3+ tasks in week 1 retain at 80% vs 30% for those who don't"

Revenue events:

• trial_started, upgrade_clicked, plan_upgraded, payment_failed, subscription_cancelled
• With plan, amount_cents, trigger properties on each

---

Key Metrics to Track

Activation rate — % of signups who reach the activation event within N days. If <40%, activation is your biggest lever.

D1/D7/D30 retention — % of users active 1, 7, 30 days after signup. Healthy B2B SaaS: D30 > 40%.

Feature adoption — % of active users who have used Feature X at least once. Low adoption = poor discoverability or poor value.

Funnel conversion — signup → activated → paying. Drop-off at each stage tells you where to focus.

Time to value — how long from signup to first activation event. Shorter is better.

---

What Good Analytics Implementation Costs

---

Working With Viprasol

Analytics instrumentation is part of our standard product development process — we define the event schema during discovery, implement tracking alongside feature development, and configure dashboards before launch. We use PostHog for most clients and integrate with data warehouses when needed.

Our SaaS development services include analytics implementation as a standard deliverable.

Need analytics implementation for your product? Viprasol Tech instruments and analyzes SaaS products for startups and enterprises. Contact us.

---

See also: SaaS Development Services · Data Analytics Consulting · SaaS MVP Development

Sources: PostHog Documentation · Mixpanel Event Tracking Guide · Amplitude Analytics Academy