Product Analytics Engineering in 2026: Event Tracking Design, Mixpanel vs Amplitude, and Self-Hosted

Most product analytics implementations are broken. Events are named inconsistently, properties are missing or misspelled, and PMs can't trust the funnel data because the underlying event schema was designed by whoever was available when the feature shipped. The result: nobody uses the analytics, decisions are made on gut feel, and the engineering investment in tracking was wasted.

Good analytics engineering starts with a taxonomy — a governed naming convention and property schema — before a single event is tracked. This post covers the schema design, platform comparison, and implementation patterns that produce analytics data product teams actually trust.

Why Analytics Data Is Usually Wrong

## Common analytics engineering failures:

❌ No taxonomy: button_click, buttonClick, btn_clicked — same event, three names
❌ Missing context: "signup" event without plan, channel, or referral source
❌ Client-only tracking: ad blockers and SSR pages drop 20–40% of events
❌ No validation: properties sent as wrong types, null values, empty strings
❌ Missing PII scrubbing: email addresses logged in event properties
❌ Inconsistent user identity: anonymous → identified user linkage broken

Result: PM asks "What's our activation rate?"

Engineering: "It depends which event you use..." PM: "Never mind, I'll look at Stripe."

---

## Event Taxonomy Design

```markdown

Naming Convention: Object-Action Pattern

Format:

Server-Side Tracking (Critical for Data Quality)

Client-side tracking misses 20–40% of events due to ad blockers, SSR, and browser bugs. Server-side tracking is authoritative:

// src/analytics/server-tracker.ts
// Track critical business events server-side — no risk of missing them

import PostHog from 'posthog-node';

const posthog = new PostHog(process.env.POSTHOG_API_KEY!, {
  host: process.env.POSTHOG_HOST ?? 'https://app.posthog.com',
  flushAt: 20,       // Batch 20 events before flushing
  flushInterval: 5000, // Or flush every 5 seconds
});

export async function trackServerEvent<T extends AnalyticsEvent>(
  event: T,
): Promise<void> {
  const { event: eventName, properties } = event;

  // Scrub PII from properties before tracking
  const safeProperties = scrubPII(properties);

  posthog.capture({
    distinctId: properties.userId ?? properties.anonymousId,
    event: eventName,
    properties: {
      ...safeProperties,
      $lib: 'server',
      serverTimestamp: new Date().toISOString(),
    },
  });
}

function scrubPII(props: Record<string, unknown>): Record<string, unknown> {
  const PII_KEYS = new Set(['email', 'phone', 'name', 'ipAddress', 'address']);
  return Object.fromEntries(
    Object.entries(props).filter(([key]) => !PII_KEYS.has(key)),
  );
}

// Critical events to always track server-side:
// - signup_completed (after user created in DB)
// - subscription_created / upgraded / cancelled (after Stripe webhook)
// - payment_succeeded / payment_failed (after payment processing)
// - invitation_accepted (after user completes invite flow)

React Client-Side Tracking Hook

// src/analytics/useTrack.ts
'use client';

import posthog from 'posthog-js';
import { useCallback } from 'react';
import type { AnalyticsEvent } from './schema';

export function useTrack() {
  const track = useCallback(<T extends AnalyticsEvent>(event: T) => {
    // Don't track in development
    if (process.env.NODE_ENV === 'development') {
      console.log('[Analytics]', event.event, event.properties);
      return;
    }

    posthog.capture(event.event, event.properties);
  }, []);

  return { track };
}

// Usage in components:
function UpgradeButton({ currentPlan }: { currentPlan: string }) {
  const { track } = useTrack();

  return (
    <button
      onClick={() => {
        track({
          event: 'upgrade_cta_clicked',
          properties: {
            currentPlan,
            ctaLocation: 'settings_billing',
            // BaseEventProperties filled automatically by PostHog SDK
          },
        });
        router.push('/upgrade');
      }}
    >
      Upgrade Plan
    </button>
  );
}

Data Quality Validation

// src/analytics/validator.ts — Validate events against schema before sending

import { z } from 'zod';

const BaseSchema = z.object({
  userId: z.string().uuid().optional(),
  anonymousId: z.string().min(1),
  sessionId: z.string().min(1),
  platform: z.enum(['web', 'ios', 'android', 'api']),
  environment: z.enum(['production', 'staging']),
  appVersion: z.string().regex(/^\d+\.\d+\.\d+$/),
});

const EventSchemas: Record<string, z.ZodType> = {
  signup_completed: BaseSchema.extend({
    plan: z.enum(['free', 'pro', 'enterprise']),
    signupMethod: z.enum(['email', 'google', 'github']),
    hasTeammate: z.boolean(),
  }),

  subscription_upgraded: BaseSchema.extend({
    fromPlan: z.string().min(1),
    toPlan: z.string().min(1),
    billingInterval: z.enum(['monthly', 'annual']),
    mrr: z.number().int().min(0),
    mrrDelta: z.number().int(),
  }),
};

export function validateEvent(
  eventName: string,
  properties: Record<string, unknown>,
): { valid: boolean; errors?: string[] } {
  const schema = EventSchemas[eventName];
  if (!schema) {
    // Unknown event — warn but don't block
    console.warn(`[Analytics] Unknown event: ${eventName}`);
    return { valid: true };
  }

  const result = schema.safeParse(properties);
  if (!result.success) {
    const errors = result.error.errors.map((e) => `${e.path.join('.')}: ${e.message}`);
    // In production: send to error monitoring, don't throw
    console.error(`[Analytics] Invalid event ${eventName}:`, errors);
    return { valid: false, errors };
  }

  return { valid: true };
}

Analytics Data Quality CI Check

// scripts/check-analytics-schema.ts
// Run in CI to detect events not matching the defined schema

import { glob } from 'glob';
import { readFileSync } from 'fs';

const EVENT_PATTERN = /track\(\s*['"`]([a-z_]+)['"`]/g;
const DEFINED_EVENTS = new Set([
  'signup_started', 'signup_completed',
  'subscription_created', 'subscription_upgraded', 'subscription_cancelled',
  'feature_viewed', 'report_exported',
  // ... add all events from your taxonomy
]);

async function checkAnalyticsSchema() {
  const files = await glob('src/**/*.{ts,tsx}');
  const violations: string[] = [];

  for (const file of files) {
    const content = readFileSync(file, 'utf-8');
    let match;

    while ((match = EVENT_PATTERN.exec(content)) !== null) {
      const eventName = match[1];
      if (!DEFINED_EVENTS.has(eventName)) {
        violations.push(`${file}: Unknown event "${eventName}"`);
      }
    }
  }

  if (violations.length > 0) {
    console.error('Analytics schema violations:');
    violations.forEach((v) => console.error(' -', v));
    process.exit(1);
  }

  console.log(`✅ All events match defined taxonomy (${DEFINED_EVENTS.size} events)`);
}

checkAnalyticsSchema();

Working With Viprasol

We design and implement product analytics systems — from event taxonomy through server-side tracking, platform setup, and data quality validation pipelines.

What we deliver:

• Event taxonomy design (naming conventions, required properties, governance process)
• PostHog, Mixpanel, or Amplitude implementation with server-side tracking
• Analytics SDK abstraction layer (swap platforms without code changes)
• Zod schema validation for analytics events in CI
• Funnel analysis setup for activation and conversion tracking

→ Discuss your analytics architecture → AI and analytics services

See Also

• SaaS Metrics and Benchmarks
• A/B Testing Engineering
• SaaS Churn Prediction with ML
• Real-Time Analytics with ClickHouse
• Feature Flag-Driven Development