The 6-hour wake-up call
Last month I spent six hours automating a deployment task that takes thirty seconds to do manually. Six. Hours. I wrote a Bash script, refactored it into Python, added retries, wrote tests, set up CI to run the tests, and then — I kid you not — wrote documentation for the script. All to avoid doing a thing I do maybe twice a quarter.
When I finally pushed the PR, my coworker just looked at me and said, "You could have just done it." She was right. That experience kicked off a quiet audit of every overengineered tool in my stack. The biggest offender? My analytics setup.
Google Analytics had become a 200KB JavaScript bundle, a cookie banner, a consent management platform, and a quarterly meeting with our DPO. For a personal blog. For a personal blog. So I migrated to something simpler. I've been running with the new setup for about six months and I want to share what I learned comparing the three biggest privacy-focused alternatives.
Why migrate at all?
Before we get into tooling, a quick sanity check. Privacy-focused analytics make sense if:
- You don't actually use the 90% of GA features that require cookies
- You want page views, referrers, and top pages — not user IDs and audience cohorts
- You're tired of GDPR/CCPA consent banners eating your conversion rate
- Your bundle size matters
If you're running an ad business or doing serious funnel analysis, none of these will replace GA4. Be honest with yourself about what you actually need.
The contenders
I looked at three options seriously: Plausible, Fathom, and Umami. All three are cookieless, all three are GDPR/CCPA-friendly out of the box, and all three have a dramatically smaller script than GA.
Side-by-side
| | Plausible | Fathom | Umami |
|---|---|---|---|
| Hosting | Cloud + self-host | Cloud only | Self-host + cloud |
| Open source | Yes (AGPL) | No | Yes (MIT) |
| Script size | ~1KB | ~2KB | ~2KB |
| Cookies | None | None | None |
| Free tier | Trial only | Trial only | Self-host: free |
A few things I want to call out honestly:
- Plausible is open source under AGPL, which matters if you self-host and modify it. Their cloud product is paid.
- Fathom is the most polished but also the most closed. No self-hosting option exists. If that's a dealbreaker, skip it.
- Umami is the most permissively licensed (MIT) and the easiest to self-host. The UI is less refined than Plausible's, but it's caught up a lot.
Migration: the actual work
Here's the before. Standard GA4 snippet, which I'd been carrying around for years:
<!-- The old GA4 snippet -->
<script async src="https://www.googletagmanager.com/gtag/js?id=G-XXXXXXX"></script>
<script>
window.dataLayer = window.dataLayer || [];
function gtag(){dataLayer.push(arguments);}
gtag('js', new Date());
// anonymize_ip needed for GDPR compliance
gtag('config', 'G-XXXXXXX', { anonymize_ip: true });
</script>And here's what each of the alternatives looks like.
Plausible
<!-- Plausible: one line, one script tag -->
<script defer data-domain="yoursite.com"
src="https://plausible.io/js/script.js"></script>That's it. No config object, no consent banner needed (per their docs — verify with your own legal team if you're in a regulated industry). For SPA route tracking you swap to script.hash.js or call plausible('pageview') manually.
Fathom
<!-- Fathom: similar minimal setup, site ID is the magic value -->
<script src="https://cdn.usefathom.com/script.js"
data-site="ABCDEFGH"
defer></script>Nearly identical developer experience. The dashboard is faster than Plausible's in my testing, but I haven't run a rigorous benchmark.
Umami
Umami is the one with real setup work, because the typical path is to self-host it. Here's what a docker-compose deployment looks like:
# docker-compose.yml — Umami with Postgres
services:
umami:
image: ghcr.io/umami-software/umami:postgresql-latest
ports:
- "3000:3000"
environment:
# DATABASE_URL is required; format documented in Umami's README
DATABASE_URL: postgresql://umami:umami@db:5432/umami
DATABASE_TYPE: postgresql
# APP_SECRET is used to sign auth tokens — generate a long random string
APP_SECRET: replace-me-with-something-random
depends_on:
- db
db:
image: postgres:15-alpine
environment:
POSTGRES_DB: umami
POSTGRES_USER: umami
POSTGRES_PASSWORD: umami
volumes:
- umami-db:/var/lib/postgresql/data
volumes:
umami-db:Once it's running, the tracking snippet is the same shape as the others:
<!-- Umami: data-website-id comes from your Umami dashboard -->
<script defer src="https://your-umami-host.com/script.js"
data-website-id="your-website-id-here"></script>I deployed mine to a $5 VPS. Total setup time including DNS and TLS: about 20 minutes. Which, yes, is more than the 30-second deploy task I spent six hours automating. The difference is that this work is amortized across years of running the thing.
What broke during migration
A few things I didn't expect:
- UTM parameters. All three handle them, but the dashboards display them differently. If you have spreadsheets pulling from the GA API, those break.
- Goals/events. GA4's event model is more flexible than any of these. If you tracked custom events heavily, you'll lose some granularity or have to instrument differently.
- Historical data. None of these import GA data. I exported a CSV of my last 12 months from GA and stashed it in a folder labeled
analytics-archive. Haven't opened it once. - Cookie banner removal. Don't forget to actually remove your consent banner code. I left mine in for two weeks because I forgot it was there.
Which one should you pick
After running all three on different projects for six months, here's my honest take:
- Pick Plausible if you want a hosted product with the option to self-host later. The UI is the most polished of the open-source options, and the AGPL license means the open-source community can keep building on it. Their docs are excellent.
- Pick Fathom if you want the simplest possible managed experience and don't care about self-hosting. It's the "just works" option, but you're locked into their cloud.
- Pick Umami if you want to self-host on day one without paying for a cloud subscription, or if MIT licensing matters to your stack. It's what I run on my personal blog now. The setup is slightly more involved, but once it's up you forget it exists.
The real lesson
The 6-hour Bash script wasn't really about Bash. It was about my reflex to overengineer things that didn't need engineering. Migrating off GA followed the same instinct in reverse — I was running enterprise-grade analytics tooling on a hobby project. Sometimes the right move is a 1KB script tag and a $5 VPS, not a tag manager and a consent platform.
Manual work is technical debt, sure. But unnecessary automation is also technical debt. It just has better marketing.