Forem: Alex Koval

I built an analytics tool that tells you what's broken instead of showing more charts

Alex Koval — Thu, 19 Feb 2026 21:04:13 +0000

Six months ago I had a Mixpanel setup with 140+ custom events. Nobody on the team knew what half of them tracked. The engineer who set them up had left. The PM spent two weeks building dashboards before making any decision.

And after all that work, the dashboards told us what happened. Never why. Never what to do next.

So I started building something different.

The problem I kept running into

Every analytics tool I've used follows the same pattern: you track events, you build funnels, you stare at charts, you try to figure out what they mean.

The interpretation part — the "so what?" — is always left to you. And if you're a small team shipping fast, you don't have time to be a data analyst on top of everything else.

I wanted a tool that skips the dashboard phase entirely and just says: "Feature X has a drop-off problem at step 3. Here's what's likely causing it."

How it works under the hood

The core idea is simple. Instead of tracking hundreds of discrete events and hoping someone connects the dots, we track behavioral sequences and look for pattern changes over time.

Here's the basic mental model:

// Traditional analytics: track everything, interpret later
track('button_clicked', { button: 'signup' });
track('page_viewed', { page: '/onboarding' });
track('feature_used', { feature: 'import' });
// ...140 more of these

// What we do: drop in one script, auto-tracking handles the rest
// <script src="https://xora.es/sdk.js"></script>
xora.init({
  projectId: 'YOUR_PROJECT_ID',
  apiKey: 'YOUR_API_KEY'
});
// Auto-tracking enabled: pageviews, clicks, forms
// The system builds behavioral sequences from there

The SDK auto-captures session-level behavioral data — pageviews, clicks, form interactions — out of the box. On the backend, we build per-user behavioral profiles and track three things:

1. Time-to-value trends

Not just "how long until first action" but how that time changes over weeks. If a user's path to value is getting longer, that's friction building up — and it usually predicts churn 3-6 weeks before it happens.

2. Feature breadth per session

Healthy users explore. They touch multiple features, check settings, try integrations. Users who are about to leave narrow down to single-feature, in-and-out sessions. We track this as a rolling average and flag anomalies.

3. Post-support behavioral change

When a user contacts support and then doesn't change their behavior afterward, that's a strong signal they've mentally checked out. We track behavior deltas within 48 hours of support interactions.

The architecture (simplified)

┌─────────────┐ ┌──────────────┐ ┌─────────────────┐
│ JS SDK │────▶│ Event │────▶│ Sequence │
│ (auto-track)│ │ Pipeline │ │ Builder │
└─────────────┘ └──────────────┘ └────────┬────────┘
│
▼
┌─────────────────┐
│ Pattern │
│ Analyzer │
└────────┬────────┘
│
▼
┌─────────────────┐
│ Recommendations │
│ Engine │
└─────────────────┘

The Sequence Builder turns raw events into behavioral flows per user. The Pattern Analyzer compares current patterns against that user's historical baseline. When something shifts beyond a threshold, the Recommendations Engine generates a plain-English explanation of what changed and what likely caused it.

No dashboards. No funnels to build. Just alerts that say "here's what's broken and here's what to fix first."

What I learned building this

Devs don't want more dashboards. Every founder and dev I talked to during early user research said the same thing: "I don't have time to interpret charts." They wanted answers, not data.

Auto-tracking beats manual event setup. We started with a manual event tracking approach like everyone else. Adoption was terrible. Nobody wants to instrument 50 events. The moment we switched to auto-capture with a lightweight script tag, onboarding time dropped from days to minutes.

Behavioral sequences > individual events. A single event tells you almost nothing. The order and timing of events tells you everything. This was the biggest insight that shaped the product.

Current state

We're in early beta with a handful of teams. Still rough around the edges. The SDK is lightweight, drops into any site with a single script tag. Integration is copy-paste:

<!-- Add before </head> -->
<script src="https://xora.es/sdk.js"></script>
<script>
  xora.init({
    projectId: 'YOUR_PROJECT_ID',
    apiKey: 'YOUR_API_KEY'
  });
</script>

<!-- Identify logged-in users -->
<script>
  xora.identify('user_123', {
    $email: 'user@example.com',
    plan: 'pro'
  });

  // Track custom events on top of auto-tracking
  xora.track('feature_used', { name: 'export' });
</script>

Auto-tracking covers pageviews, clicks, and forms out of the box. You only need identify and track if you want to layer on user identity and custom events.

If you're building a SaaS product and tired of staring at Mixpanel dashboards without knowing what to actually do — I'd love to hear what you think. Still figuring out a lot of this in public.

What's your current analytics setup look like? And honestly — do you actually look at your dashboards?

How to detect where users drop off with 5 lines of code (no Mixpanel, no Amplitude)

Alex Koval — Fri, 13 Feb 2026 11:00:45 +0000

Most analytics tools are overkill for early-stage products. You don't need 50 dashboards. You need to know one thing: where are users dropping off?

I've been building an analytics tool and along the way figured out patterns that work for detecting user drop-offs early. Here's the practical breakdown.

The problem with traditional analytics setup

You install Mixpanel or Amplitude. You track 200 events. You build funnels. You stare at charts. Two weeks later you still don't know why users leave after the onboarding screen.

The issue isn't tracking. It's interpretation.

What actually matters: the critical path

Before you track anything, map your critical path. That's the 3-5 actions a user MUST complete to get value from your product.

For example:
Sign up -> Connect data source -> See first insight -> Invite teammate

That's it. Everything else is noise at this stage.

Lightweight tracking that tells you what's broken

Here's a minimal approach. Track only your critical path steps with timestamps:

// Track critical path steps with timing
const trackStep = (step, metadata = {}) => {
  const payload = {
    step,
    timestamp: Date.now(),
    sessionId: getSessionId(),
    timeSinceLastStep: getTimeSinceLastStep(),
    ...metadata
  };

  navigator.sendBeacon('/api/track', JSON.stringify(payload));
};

// Usage
trackStep('signup_complete');
trackStep('data_source_connected', { source: 'postgres' });
trackStep('first_insight_seen', { insightType: 'drop_off' });
trackStep('teammate_invited');

The metric nobody tracks: time between steps

Drop-off rate between steps is obvious. Everyone tracks that. But time between steps is where the real signal is.

If 80% of users complete Step 1 → Step 2, but it takes them 15 minutes on average when it should take 2, you have a UX problem that won't show up in a conversion funnel.

// Simple analysis: find where users get stuck
const analyzeDropoffs = (events) => {
  const steps = ['signup', 'connect_source', 'first_insight', 'invite'];

  const analysis = steps.map((step, i) => {
    if (i === 0) return null;

    const prevStepUsers = events.filter(e => e.step === steps[i-1]);
    const thisStepUsers = events.filter(e => e.step === step);

    const conversionRate = thisStepUsers.length / prevStepUsers.length;

    // Calculate median time between steps
    const times = thisStepUsers.map(curr => {
      const prev = prevStepUsers.find(p => p.sessionId === curr.sessionId);
      return prev ? curr.timestamp - prev.timestamp : null;
    }).filter(Boolean);

    const medianTime = times.sort((a,b) => a-b)[Math.floor(times.length/2)];

    return {
      transition: `${steps[i-1]} -> ${step}`,
      conversionRate: (conversionRate * 100).toFixed(1) + '%',
      medianTimeSeconds: (medianTime / 1000).toFixed(0),
    };
  }).filter(Boolean);

  return analysis;
};

Output looks like this:
signup -> connect_source: 62.3% | median: 340s ⚠️
connect_source -> first_insight: 89.1% | median: 12s ✓
first_insight -> invite: 23.7% | median: 890s ⚠️

Now you know exactly where to focus. No dashboards needed.

Three patterns that predict churn

From working with beta users, these are the signals that consistently predict whether someone will stick around:

1. Time-to-first-value over 5 minutes = danger zone.
If a user can't get value from your product in the first 5 minutes, the chance they come back drops off a cliff. Measure this obsessively.

2. "Browse but never create" pattern.
Users who view 10+ pages but never perform a creation action (write, build, upload, connect) are tourists. They won't convert.

3. Solo usage after day 3.
For any collaborative product, if a user hasn't involved someone else by day 3, retention drops dramatically. The product becomes a solo experiment that gets forgotten.

When this DIY approach breaks down

This works great for your first 100-1000 users. After that you start needing:

Automatic segmentation — paid vs churned behavior comparison
AI pattern detection — finding signals you didn't think to look for
Real-time recommendations — "this user is about to churn, here's why"

This is exactly what I'm building with Xora Analytics. Instead of more dashboards, the AI analyzes user behavior and tells you what's broken and what to fix. 5 lines of SDK integration.

But honestly, start with the simple approach above. You'd be surprised how much you learn from just tracking 4-5 critical steps.

What's your critical path? And where do users get stuck? Would love to hear what patterns others have found.

I replaced 140 custom analytics events with 5 lines of code. Here's what I learned

Alex Koval — Wed, 11 Feb 2026 09:50:42 +0000

Last year I was consulting for a B2B SaaS product. They had 140 custom Mixpanel events. One hundred and forty.
Nobody knew what half of them tracked. The engineer who set most of them up had left. The product manager was building dashboards for two weeks before making any decisions. And after all that work? The dashboards told them what happened. Not why. Not what to do next.
That experience broke something in my brain. I couldn't stop thinking about it.
So I quit my job and built the thing I wished existed.
The problem nobody talks about
Every analytics tool on the market works the same way:

You define events manually
You send them to a dashboard
You stare at charts
You try to figure out what they mean
You build another dashboard
Repeat

This is insane. We're in 2026. AI can generate photorealistic videos and write code. But product analytics still works like it's 2015.
The dirty secret of Mixpanel, Amplitude, and every other analytics tool: they show you data, not decisions.
You still need a data analyst. You still need weeks to get answers. You still need engineering time to instrument events. And by the time you act on the insight, your users already churned.
What 4,000 events per week taught me
I'm building Xora Analytics. Instead of asking teams to define 140 events, we ask them to care about 5 core metrics. The AI does the rest.
Here's the architecture in plain English:

You install a lightweight JS snippet (~2 min)
It captures user behavior automatically
AI analyzes patterns and finds where users drop off
You get recommendations, not charts

Not "your retention dropped 12% at week 2." Instead: "Users who skip the workspace setup step churn 3x more. Here's a suggested onboarding change with predicted impact."
That's the difference. One gives you homework. The other gives you answers.
The 5 patterns that actually matter
After analyzing user behavior across our beta products, I keep seeing the same 5 churn patterns. I wrote about them in detail on Medium, but here's the quick version:

The 24-Hour Ghost If a user doesn't complete a meaningful action in 24 hours, they're 3x more likely to churn in the first month. Your time-to-first-value needs to be under 10 minutes.
The Feature Desert Single-feature users have 34% retention at 90 days. Users with 3+ features: 89%. If someone only uses one thing, they will leave.
The Week 2 Cliff Day 8-14 is where retention dies. Week 1 is exploration. Week 2 needs a habit trigger. If you don't create one, they're gone.
The Champion Exit When the one person who loves your product changes roles or leaves, the whole account goes silent. Multi-user adoption is your insurance.
The Quiet Downgrade Usage drops 60-70% over 3 months but they stay subscribed. They're not loyal. They just forgot to cancel. A 50%+ drop in weekly usage over 4 weeks predicts cancellation within 60 days. These aren't theoretical. These are real patterns from real products. And none of them require 140 custom events to detect. The technical bit For the devs who want to know how the integration looks: javascript// That's it. That's the setup. import { Xora } from '@xora/sdk';

Xora.init({
apiKey: 'your-key',
autocapture: true
});

Xora.identify(userId, { plan: 'pro', role: 'admin' });
Five lines. No event taxonomy to design. No engineering sprint to instrument. No 40-page tracking plan.
The AI figures out what matters based on actual user behavior, not your assumptions about what they should be doing.
What I'd do differently if starting analytics from scratch
If you're an early-stage SaaS and you're about to set up analytics, here's my honest advice regardless of what tool you use:
Don't start with events. Start with questions.
Write down the 3 questions you need answered this month:

Where do users drop off in onboarding?
Which feature correlates with retention?
What's the activation threshold?

Then instrument ONLY what answers those questions. Everything else is noise.
Don't build dashboards nobody checks.
If your team doesn't look at a dashboard weekly, delete it. Dashboard proliferation is a disease. I've seen companies with 200+ dashboards and zero data-driven decisions.
Don't separate analytics from action.
Knowing that "Step 3 has a 42% drop-off" is useless if it takes 2 weeks to get engineering to fix it. The insight and the action need to be close together.
Where I am now
Xora is in early beta. We have a handful of products sending us around 4,000 events per week. It's not a lot. We're early.
But the feedback is real. One team replaced their entire Mixpanel setup with our 5-minute integration and got their first actionable recommendation within 24 hours. No dashboards built. No data analyst hired. No engineering time wasted.
The free tier handles up to 500K events/month: analytics.xora.es
If you're building a SaaS product and drowning in analytics tools that give you charts but not answers — I'd love to hear about your setup. What's working? What's broken? Drop a comment or hit me up.

I'm Alex, founder of Xora Analytics. I write about product analytics, churn patterns, and building SaaS products. Follow me here on DEV or connect on LinkedIn if you want to nerd out about this stuff.