Umami vs Plausible for a Micro-SaaS: When Privacy Analytics Hide the Funnel You Need

I replaced Google Analytics on a small paid app because the cookie banner was uglier than the landing page. Plausible went on first. The dashboard was a relief: visitors, referrers, pages, a bounce number I did not fully trust and did not miss. A month later I still could not answer the only question that paid rent. How many people who saw pricing started checkout, and how many of those reached “thanks”? The privacy tool had done its job. It had also hidden the funnel.

Umami was the next stop because I could self-host it next to the app and send custom events without feeling like I had invited an ad network back in. I got more knobs. I still did not get a GA-style funnel unless I designed the events like a grown-up and accepted that “privacy analytics” means you will not be forgiven for reconstructing a person from a path.

Both products are good at not being Google. Neither is a substitute for instrumentation you were too embarrassed to add when the product was three pages. The failure is expecting a clean dashboard to invent a conversion model. A pretty empty funnel is still empty. I learned that the expensive way, after a pricing experiment I could not measure.

What Plausible will tell you

Plausible is a product. You pay, you paste a script, you get a shared aesthetic of honest-enough traffic. It is fast. It is easy to show a cofounder. Cookieless mode and a public dashboard are part of the brand. Goals exist. You can mark a thank-you URL. You can count outbound clicks. You can do some event work if you read the docs instead of only the homepage.

What it will not do is reconstruct a multi-step SaaS funnel the way a marketer who grew up in GA4 expects. Sessions are not people. Adblockers still eat the script, just fewer of them than gtag. If your checkout lives on Stripe’s domain, the “goal” on your thank-you page is a different story than the click on Subscribe. Plausible can count both as events. It will not hold your hand through the identity join you do not have.

For a brochure site, that is enough. For a micro-SaaS with a trial, a pricing table, an app login, and a Stripe session, “enough” is how you ship a pricing change based on vibes. The dashboard looks complete. The funnel is a ghost.

What Umami will tell you

Umami is closer to a small toolkit. Self-host it and you own the Postgres. Cloud Umami exists if you do not want the box. Custom events are first-class in a way that feels more like “this is a product analytics lite” than Plausible’s calmer marketing site. You can attach properties. You can filter. You can convince yourself you have Mixpanel at home.

You do not. You have events in a database and a UI that will not do cohort magic. If you never fire checkout_started and checkout_completed with a shared anonymous id you accept as imperfect, Umami will show you pageviews of /pricing and /thanks as two hills. The valley is your imagination.

Self-hosting also means you will be the person who upgrades Umami when a release notes says “breaking.” That is the micro-SaaS tax. Plausible’s tax is a subscription and less control. Pick the tax you will actually pay. An unmaintained Umami is not more private. It is a stale script and a CVE tab you closed.

The funnel privacy mode deletes

A useful funnel for a tiny SaaS is usually four or five steps: landed, saw pricing, started checkout, paid, activated. Privacy analytics will give you landed and maybe paid if the thank-you URL is first-party. The middle dies when:

• Checkout is a third-party host and you only count pageviews on your origin.
• You refuse a client id because it “feels like tracking.”
• The app is a SPA and the script never sees a virtual pageview you forgot to send.
• You use a reverse proxy for the script (good) and then forget to send events from the server when the client is blocked (also common).

Server-side events are the grown-up fix. Stripe webhook says paid. Your API says trial_started. You write those into Umami or into your own table. Plausible can ingest events too if you use the API. The dashboard script is not the product. The event list is the product. People install the script and stop.

I keep a boring table in the app database: user_id (or a hashed email), step, at. That is not Google. That is my funnel. Analytics tools become a traffic overlay, not the source of truth for money. When I skip that table, I go back to staring at referrers like they are a strategy.

Referrers lie in 2026 anyway. A lot of mobile traffic arrives with the referrer stripped. Newsletter clicks look like direct. App-in-app browsers eat your UTM. Privacy analytics did not invent that. They just refuse to paper over it with a modeled “Google / organic” fairy tale. If your acquisition story depends on that fairy tale, you will hate both Umami and Plausible. You should hate the story first.

I still tag campaigns. I put UTMs on ads I pay for. I look at them in Plausible or Umami as a weather report. I do not use them to decide whether the pricing page works. The pricing page works if checkout_started and paid move when I change the page. That join lives in my table, or it does not live.

Adblock, consent, and the missing 20%

Privacy tools still lose to blockers and to people who never load JavaScript. If your paid conversion is 3% of visitors, and you lose 20% of pageviews to blockers, you cannot A/B a headline with a straight face. You can still watch orders. Orders do not need a script. They need Stripe.

I treat Plausible and Umami as weather. I treat revenue events as climate. If the weather says traffic doubled and climate says MRR did not move, I believe climate. The privacy dashboard hid nothing in that case. It reported a different country.

When I pick Plausible

I pick Plausible when I want a script up today, a public stats page for a marketing site, and a bill I can explain. I add a thank-you goal. I do not ask it to explain activation. I do not self-host unless I have a reason beyond aesthetics.

I also pick it when the founder is me and I will not patch Umami. Honesty about ops is part of privacy. A dead self-host is a tracking pixel with extra steps.

When I pick Umami

I pick Umami when I already run the app’s database and I want events next door. I send named events from the client and from webhooks. I accept that I will write a couple of SQL queries the UI will not love. I keep Plausible-level pageviews as a vanity check, not as the board deck.

I do not pick Umami to feel more righteous than Plausible. The righteousness is cookieless collection and a smaller vendor. The work is still naming events. If I will not name events, Umami is a prettier hit counter.

The decision

If you need a traffic picture and a single goal URL, Plausible is the shorter path. If you need a funnel you can defend, neither script is enough until you emit steps from the server. Umami makes that slightly more natural if you like owning the box. Plausible makes the traffic picture slightly more pleasant if you like owning less.

Team access is a small, real difference. Plausible’s shared dashboard is a link you can give a contractor without handing them the production database. Umami can do users and roles if you configure them. I have given a contractor Plausible and regretted nothing. I have given a contractor the Umami admin URL and regretted the week they “helped” by changing the tracking script domain.

Cost at tiny scale is not the decision. Plausible’s bill is coffee. Umami’s bill is a container and a backup. Cost at “this is actually a business” is still not Google’s bill. The decision is whether you will emit events. If you will not, buy Plausible and enjoy the calm. If you will, Umami or Plausible’s API both work. The hide happens in the gap between pageview and payment, not in the logo on the dashboard.

Privacy analytics hide the funnel when you expected a dashboard to infer intent from page paths. They do not hide it when you write the steps down like a ledger. Put money events in your database. Put weather in Umami or Plausible. Do not let a clean chart talk you out of the four events you were afraid looked like tracking. Those four events are how a micro-SaaS learns. The rest is a nice graph for a Friday.