DEV Community: David🚀

Why I Ditched Google Analytics for My Startup and Built My Own Traction Tool

David🚀 — Tue, 09 Sep 2025 06:30:40 +0000

When I first launched my startup, I did what almost every founder does: I installed Google Analytics.
It’s the default. Everyone says you need it.

But after weeks of trying to use it, I realized something: I was drowning in dashboards and graphs, yet still couldn’t answer the only question that mattered to me:

👉 “Which post or link is actually bringing me new signups?”

The Problem With Google Analytics

Don’t get me wrong, Google Analytics is powerful. If you’re running a big e-commerce store or managing multiple ad campaigns, it’s probably the right tool.

But for a solo founder like me, it felt like trying to fly a Boeing 747 when all I needed was a bicycle.

Too many menus, metrics, and jargon.
Hard to set up funnels or events without hours of tweaking.
I just wanted clarity, but GA buried me in noise.

The truth? Most early-stage founders don’t need more data.
We need the right data.

What I Actually Needed

At the early stage, growth comes from experiments:

Posting on Reddit
Sharing a thought on X
Answering a question on Quora
Dropping your link in a directory

The question is: which of these experiments is working?

I didn’t need heatmaps, bounce rates, or conversion paths.
I just needed to know: “Did this specific post bring me signups?”

That’s it.

The Breaking Point

One morning, after wrestling with GA for the hundredth time, I realized I was spending more time learning an analytics tool than growing my startup.

That’s when it clicked:
If the tools don’t fit the stage I’m in, maybe I should build one that does.

Building My Own Traction Tool

So I built something lightweight:

Instead of setting up complex events, I create a custom link for every post or share.

I group these links into channels (e.g., Reddit posts, Twitter DMs, directories).

When someone clicks, I instantly know which post brought them in.

No dashboards. No endless graphs. Just clear answers to simple questions.

What I Learned

Ditching Google Analytics taught me something important about traction:
It’s not about tracking everything. It’s about tracking the few things that matter right now.

For me, one experiment showed that a single Reddit comment outperformed 10 polished blog posts. That insight shifted how I approached growth.

When you know exactly what’s working, you can stop guessing and start doubling down.

Closing Thoughts

If you’re an early-stage founder, don’t let complex tools slow you down.
Focus on clarity, not noise.

That’s why I ditched Google Analytics and why I built my own traction tool to grow with less guesswork.

👉 If you’ve ever felt overwhelmed by analytics and just wanted to know which post is actually working, you’ll understand exactly why I built Reddimon

Plug-and-Play Attribution Dashboard You Can Build in a Day

David🚀 — Tue, 26 Aug 2025 12:49:24 +0000

Most solo founders post across Reddit, X, Product Hunt, Indie Hackers… then stare at their analytics and think:

“Cool, traffic went up… but which channel actually brought signups?”

That’s the blind spot. Traditional analytics tools are bloated and DIY setups are a weekend you don’t have.

That’s why I built Reddimon, a plug-and-play attribution dashboard that shows you, in under a day, exactly which channels are moving the needle.

Why lightweight attribution matters

Here’s the ugly truth: more traffic ≠ more customers.

The only metric that matters in early-stage growth is which channels turn into signups. If you don’t know that, you end up wasting weeks doubling down on the wrong place.

With Reddimon, you can skip the guesswork. It’s designed for solo founders who want clarity without touching GA4 or complicated event tracking.

How to set it up (Step-by-Step)

Step 1 — Create your Reddimon account
Sign up → takes 60 seconds. No setup wizard, no domain config, no tracking hell.

Step 2 — Generate a tracking link
Instead of sharing a raw link, Reddimon gives you a custom link. Example:

go.yourapp.com/reddit-launch

Under the hood, Reddimon automatically tags it with the right source and campaign.

Step 3 — Share it across channels
Post your Reddit comment, drop your X thread, or DM a potential user. Each channel gets its own clean link.

Step 4 — See your dashboard update
When people click, Reddimon instantly shows:

Which post/comment/thread drove the click
Which ones led to actual signups
Side-by-side comparison of your channels
No manual tagging, no spreadsheets.

What it looks like (Example)

Let’s say you launch in 3 places:

Reddit comment on r/startups
A thread on X
A post on Indie Hackers After a day, your dashboard might look like this:

Channel	Clicks	Signups	Conversion %
Reddit (comment)	57	12	21%
X (thread)	101	4	4%
Indie Hackers	33	8	24%

With one glance, you know Reddit + Indie Hackers are worth doubling down, while X is just vanity clicks.

Limitations (Keeping it real)

It won’t give you “enterprise-grade, multi-touch attribution.”
It’s not a BI tool.
It’s built for solo founders who want clarity fast. The idea: spend less time tracking, more time on the channels that actually convert.

You can do this in under 5 minutes. With Reddimon, you’ll know which channel brought the signups that matter not just traffic.

👉 Try it free, set up your first links and by this weekend you’ll have clarity most founders never get.

Dos and Don’ts of Building a Tracking Script in Vanilla JS

David🚀 — Wed, 20 Aug 2025 16:51:29 +0000

Most solo founders eventually hit the same wall:
“How do I actually know where my users are coming from?”

Sure, you can install Google Analytics or some other heavy library, but in my case, I didn’t want the weight, the complexity or the setup. I just wanted something lightweight drop a script tag on my landing page and instantly know:

who visited
where they came from
and whether they converted.

So I did the thing every indie hacker tells themselves they’ll never do, I rolled my own tracking script in vanilla JS. Spoiler: it worked, but I made a lot of mistakes along the way.

Here are some dos and don’ts that would have saved me hours if I knew them earlier.

✅ Do: Keep It Lightweight

The beauty of writing a vanilla JS tracking script is that you can keep it under a few kilobytes. No need for 100KB+ analytics libraries.

A basic visitor tracking snippet only needs to:

grab the current URL
capture referrer (if available)
send that data to your server

<script>
  (function() {
    const payload = {
      url: window.location.href,
      referrer: document.referrer,
      timestamp: Date.now()
    };

    navigator.trackDetails(
      "https://your-tracker-endpoint.com/collect",
      JSON.stringify(payload)
    );
  })();
</script>

That’s it. Async, lightweight, no extra dependencies.

❌ Don’t: Block the Main Thread

One of my early mistakes was firing a synchronous fetch() call before the page finished loading. On a slow connection, this delayed the entire page render basically the opposite of what you want.

For tracking, reliability > speed, but you never want to hurt UX. That’s why navigator.trackDetails is your best friend, it ships data in the background even if the user closes the tab immediately after clicking.

✅ Do: Respect Privacy (Collect Only What You Need)

It’s tempting to grab everything you can like IP addresses, user agents, even mouse movements. Don’t. Not only is it overkill, but you’ll run into GDPR/CCPA compliance headaches.

For most startups, you only need:

URL visited
Referrer/source
Event type (e.g. signup, conversion) Less is more. Your future self (and your lawyers) will thank you.

❌ Don’t: Rely Only on Cookies

Cookies are fragile. Users block them, browsers restrict them and incognito tabs erase them. If your script only uses cookies for user/session tracking, your data will get swiss-cheesed.

Instead, consider a lightweight fingerprint:

session ID stored in memory/localStorage
or server-issued UUID attached to the first request

Just don’t go creepy with full device fingerprinting, it’s bad karma.

✅ Do: Handle Single Page Apps (SPAs)

Modern apps don’t always reload pages. If you only fire tracking on window.onload, you’ll miss half your events.

For SPAs, listen to history changes:


(function(history){
  const pushState = history.pushState;
  history.pushState = function(state) {
    trackPageView();
    return pushState.apply(history, arguments);
  };
})(window.history);

window.addEventListener('popstate', trackPageView);

Now your tracker fires on route changes without needing a reload.

❌ Don’t: Forget Opt-Outs

If someone doesn’t want to be tracked, respect it. A simple global flag works:

if (!window.doNotTrack) {
  // run tracking code
}

Better yet, expose a public function:

window.disableTracking = true;

Users and devs alike will appreciate the transparency.

Wrapping Up: How This Shaped Reddimon

When I built Reddimon, I wanted founders to have a tracking script as simple as the code above: copy-paste one script tag and you’re done.

The lessons:

Keep it tiny
Don’t block UX
Collect only what matters
Support SPAs
Respect opt-outs

If you’re thinking of rolling your own, I hope these dos and don’ts save you some pain. And if you’d rather not reinvent the wheel well, that’s why I wrapped mine into Reddimon.

Why Most Founder Analytics Are Useless And What to Track Instead

David🚀 — Tue, 12 Aug 2025 14:32:52 +0000

When I first started promoting my product, I did what most founders do.

I posted on Reddit, Twitter, startup directories… basically anywhere someone might listen.

Every day I was “doing marketing,” but I had no idea which of my posts were actually working.
I’d look at Google Analytics, see numbers going up or down and still couldn’t answer the one question that mattered:

“Where are my users actually coming from?”

The Problem With Traditional Analytics

Most analytics tools are built for large teams who already have traffic.
They give you 100+ charts, funnels and metrics but in the early days, all that noise can be overwhelming and honestly, useless.

When you’re at 50 visitors a day, you don’t need advanced cohort analysis.
You just need to know:

Which tweet brought in a signup
Which Reddit comment sparked interest
Which guest post actually got clicks

If you don’t have that clarity, you’ll keep wasting time on channels that don’t convert.

The Lean Tracking Mindset

Here’s the mindset shift that changed everything for me:
Instead of tracking everything, track only what directly connects to growth.

That means your “analytics” could be as simple as:

Identify a channel you’re posting to (Reddit, Twitter, etc.)
Create a unique tracking link for each post or comment
Measure which one leads to a signup or desired action

It’s not fancy, but it’s brutally effective.

The 3-Step Lean Tracking Framework

Step 1 – Define the action that matters most
For me, it’s a new user signup. For you, it could be a download, a form submission or a payment.

Step 2 – Create unique links for every channel/tactic
Instead of sending everyone to myproduct.com, I make a slightly different link for each place I post.
That way, I can see exactly which one drives results.

Step 3 – Double down on what works
If one Reddit thread brings in 10 signups and a Twitter post brings in 0, I know where to put my time next week.

How I Applied This

I built a lightweight tool that let me create these custom links in seconds and track signups without touching Google Analytics.
Last month, I posted in a “Show Your Startup” thread on Twitter using one of these links.
That single post brought 48 visitors in a day and I could trace every one of them back to that tweet.

Without this setup, I’d have had no idea where they came from.

The Takeaway for Early-Stage Founders

You don’t need fancy dashboards to grow.
You need clarity.
If you can see exactly which posts, comments, or ads drive conversions, you can focus on what’s working and stop wasting time on what’s not.

I built Reddimon to make this process ridiculously simple no code, no setup, just a custom link for every channel you try.
But even if you do it with spreadsheets, the principle is the same:

Track less, learn more, grow faster.

How I Built a Click Tracking System Without Cookies or Complex Setup

David🚀 — Sat, 09 Aug 2025 17:02:16 +0000

For months, I thought I knew where my users were coming from.

I’d post in a subreddit, reply to a thread on X, drop a link in a community… then check my analytics.

Google Analytics would tell me:

Direct
Social

Which basically means 🤷🏽 not helpful at all.

The result? I kept doubling down on channels that weren’t actually working, while ignoring the ones that were quietly bringing signups.

In early-stage SaaS, a few weeks of guessing can be the difference between growing and giving up.

Why I Didn’t Use Google Analytics

For me, it came down to three big problems:

Setup overhead – too much bloat for a small side project.
Privacy concerns – cookies, consent banners, tracking scripts I didn’t feel great about adding.
Vague reporting – "Direct" or Social isn't actionable when you need to know exactly which post or link brought someone in.

I wanted something that was:

Dead simple to set up.
Cookie-less and privacy-friendly.
Laser-focused on the one question: “Where did this click come from?”

The Core Idea

What if I created a unique link for every place I posted?
That way, I could:

Redirect users to my site.
Log exactly where they came from.
Group those links into campaigns for quick comparison.

The Build

I kept the architecture simple:

Stack

Supabase PostgreSQL for storing links and click logs
Next.js

Database schema (simplified)

-- Links table
id | original_url | campaign_name | tag | click_count

-- Visits table
id | link_id | timestamp | referrer

The redirect endpoint

// pages/api/track/[id].js
import { supabase } from '../../lib/supabase'

export default async function handler(req, res) {
  const { id } = req.query
  await supabase.from('clicks').insert({ link_id: id, referrer: req.headers.referer })
  const { data } = await supabase.from('links').select('url').eq('id', id).single()
  res.redirect(data.url)
}

No cookies. No personal data. Just a timestamp and referrer.

Privacy-First by Design

Here’s what I decided NOT to do:

❌ No cookies or localStorage.
❌ No IP address logging.
❌ No fingerprinting or hidden tracking.

Instead, I store only:

The link ID.
The time it was clicked.
The referrer (if available). That’s it.

The Result

Within the first week of using this system, I found out:

70% of my signups came from showcase on X.
A channel I thought was working? 0 users. Now, I double down on what’s actually driving results, no guesswork.

From Side Project to Tool

I ended up turning this into a simple SaaS called Reddimon so other founders can:

Track exactly which post, comment, or link brings them users.
Do it without cookies or heavy setup.
Focus only on marketing that works.

If you’re tired of “Direct / Unknown” in your analytics, you might like it.