Beyond Pageviews: Why We implemented Analytics into OmniKit PRO

Most boilerplates, they give you the UI, the database connection, and maybe a basic Google Analytics script. You ship your MVP, see you have 100 visitors, and then… silence.

You have no idea what those 100 people tried to do. Did they start the sign-up process and fail? Did they hesitate at the pricing toggle? Did they click "Sign in with GitHub" but never actually authorize the app?

This lack of insight was an issue I had with my own first startup Woberry. We had traffic, but we had no idea what users were trying to do and more importantly, where they were getting stuck.

When we were building the OmniKit PRO kit, we decided that "flying blind" wasn't an option. We didn't just want to give you code; we wanted to give you a feedback loop.

That is why we integrated PostHog deeply into the core components tracking not just views, but actions and intent.

FYI there will be other alternative analytics platforms but we chose PostHog for now due to its generous free tier and developer-friendly features. More on that later.

Good News: The Demo is Live

You can see these components in action right now. The landing page for our demo is built entirely upon our Free UI Blocks.

Check out the live site at demo.omnikit.dev to see exactly how these blocks look and feel in a real production environment.

The Difference Between Traffic and Intent

• Standard analytics tell you what happened (e.g., "User visited /login").
• Granular tracking tells you why it happened (e.g., "User clicked Google Sign-In, but the callback never fired").

This distinction is critical for early-stage SaaS. You don't have enough traffic to run massive A/B tests yet, so you need to squeeze every ounce of insight out of the users you do have.

If you know that 50% of your users click "Sign in with Google" but only 10% successfully log in, you don't have a marketing problem, you have an integration problem. Standard analytics won't tell you that. The setup in OmniKit PRO will.

How It Works

We didn't want this to be something you have to "figure out" later. We baked it directly into the interactive components.

In the SignInSimple component included in the kit, for example, we don't just use a generic button. We wrap the interaction to capture the specific provider choice before the redirect happens.

By adding a simple capture line before the authentication call, we transform a black box into a clear funnel. When you launch your app using this kit, your analytics dashboard is already populated with high-value events like:

• oauth_sign_in_clicked (vs. email submissions)
• plan_selected (Monthly vs. Yearly preference)
• feature_card_clicked (What are users actually interested in?)

"use client";

import { useActionState } from "react";
import Link from "next/link";
import posthog from "posthog-js"; // Pre-configured in the kit

import { cn } from "@/lib/utils";
// ... imports

export function SignInSimple({ className, ...props }: SignInSimpleProps) {
  const [state, formAction] = useActionState<AuthState, FormData>(signInAction, {});
  const oauthProviders = getEnabledOAuthProviders();

  return (
    <div className={cn("flex flex-col gap-6", className)} {...props}>
      <Card>
        {/* ... Header ... */}
        <CardContent>
          <form action={formAction}>
            {/* ... Email Fields ... */}

            {/* The OAuth Strategy */}
            {oauthProviders.map((provider) => (
              <Button
                key={provider}
                variant="outline"
                type="button"
                className="w-full"
                onClick={() => {
                  // Capture the INTENT before the action
                  posthog.capture("oauth_sign_in_clicked", {
                    provider: provider,
                    provider_name: providerMeta[provider].name,
                  });
                  signIn.social({ provider });
                }}
              >
                Sign in with {providerMeta[provider].name}
              </Button>
            ))}
          </form>
        </CardContent>
      </Card>
    </div>
  );
}

Why We Chose PostHog for the Kit

We evaluated several analytics platforms for this integration. PostHog was the clear winner for two reasons: All-in-One Tooling and Developer-Friendly Pricing.

1. The "Indie" Tier is Incredible For most startups and solo developers, PostHog is effectively free. They offer 1 million events per month and 5,000 session recordings at no cost. This is generous enough that you likely won't pay a dime until you have significant traction.

2. More Than Just Charts Because we're capturing these events, you can turn on Session Replays to watch exactly what a user did before they encountered an error. It’s like having a debugger for user behavior.

Built for Growth

We treat analytics as a first-class feature, not an afterthought. By using the OmniKit PRO kit, you're not just deploying a website; you're deploying a system designed to help you learn and iterate.

You don't need to spend days setting up event listeners or debugging tracking scripts. It's already there, waiting for your first user.

Ship the product. Watch the data. Improve the experience.