Google Analytics is great for seeing everything that happens on your site—though it’s hard to tie it into your user events and build a full picture of people’s interactions in your site and app.
Amplitude and Looker are great for digging through vast amounts of data about your users, but they require having your app send events to them.
What’s a better alternative in the middle, something that can watch your site for both page events and app events, and let you easily build reports that, say, track when people visit a page, then signup, then perform an action, without having to tie everything in manually?
tl;dr: I don't think there's a single easy option to cover both pageview / marketing analytics and product analytics, while being simple to set up and scalable (in terms of both cost and tech debt). I'd recommend:
1. For an early stage team with limited dev resources, a quick-and-dirty auto-logging setup using something like Iteratively (integrator) + Heap (product) + GA (marketing). Brace yourself for price cliffs if you grow - keep your options open by using an integrator.
2. For a team with a few more devs / product managers, a scalable setup where your logging is behind an integrator tool, which requires a bit more work to set up, but buys you future flexibility. Two such examples:
- choose managed tools, and use Iteratively (integrator + event schema governance) + Snowplow (logger, self-host or managed) + Indicative (product analytics, free to 50m events/mo); or
- go full open-source and use Rudderstack (logger / integrator) + Posthog (product analytics). In either case, you could use something like GA (or Matomo if you're really hardcore on privacy/data ownership) for more marketing-focused work.
Satchel have an excellent summary of the best product analytics options for an early-stage startup, and the trade-offs between them. The gist of their detailed analysis is that Heap is great early on for its auto-tracking functionality, which makes post-hoc analysis a lot easier (valuable when things are changing rapidly), although they caveat that by noting that the Amplitude free plan will get you a lot further. In both cases, I'd add the caveat that completely ignoring your event schemas and tracking plan will create an increasingly complex mess to clean up later. Be kind to your current or future data team.
Speaking from the perspective of a team that has recently broken through the (crippling) price cliffs of Amplitude, amongst other tools, I'd strongly encourage using a logging integrator from the start - probably something like Iteratively or Rudderstack - which then allows you to easily hot-swap your tooling as you scale. Segment also fits in the category, but that's just one more painful price cliff for you to face when your product gets some traction.
To address your other point: unfortunately, my impression is that there isn't one tool that does a good job of both marketing / pageview analytics and product / event-driven analytics, while also being easy to set up and scalable. The best solution is probably doubling up (GA + product analytics tool) and putting a layer in between to abstract out your logging integrations, possibly using auto-track depending on your scale. Ideally, self-host and keep first-party cookies if you have the in-house experience - we're living in an increasingly privacy-conscious world, and browsers are becoming increasingly defensive on this front.
Another strong option in conjunction with other tools is Snowplow, but this is likely to introduce some devops workload (or a relatively expensive hosted version). However, once you've got it set up, you now have full ownership of your event and pageview analytics pipeline, with flexibility to add things like streaming pipelines (Kafka/Kinesis), and no longer need to worry about zero to $50k jumps in product pricing as you scale. It combines nicely with product analytics tools like Indicative (free to 50m monthly events vs Amplitude's 10m), and if a tool like Iteratively is used as an intermediate layer, you could always swap that out (for example for the open-source Posthog).
Hey @maguay, one can actually do this with Mixpanel if they implement their JS tracker. It certainly doesn't give you any demographic data like GA but it does help understand the user journey better.
While the idea of something that automatically tracks everything without sending events sounds great -- it actually creates a mess in the medium-term. Heap's auto-tracking is a good example; it is great in the short-run and can help identify some quick wins but the data gets messy and redundant very quickly.
I'm a huge proponent of deciding what to track and laying out a tracking plan before implementing any event-based analytics or engagement solutions -- so much so that I wrote an entire guide on what to track and how to create a tracking plan.
I wish people would stop using app as short hand for web application because it usually implies a mobile app and sometimes is a world of different tech.
You're asking a mixture of two very different questions here. The automatic inspection that's relatively straightforward with some web tech can be a lot harder to implement in a native mobile app.
There's also a degree of opacity with native mobile libraries - you have less idea what might be happening than with web tech so they are potentially a bigger privacy loophole.
Sorry to be stroppy but it's become a bit of a hot button for me.
@AndyDentPerth Guilty as charged! App has become the far more popular term versus software, and we've definitely seen a shift industry-wise in referring especially to consumer software as apps. But it can get confusing.
Very good point about the difference in ease of tracking on the web vs. mobile. One should never think their web app interactions are that private.
Agreed. I'm from UXCam and wanted to chime in with https://uxcam.com for mobile apps. Only takes like 15 minutes to get it up and running and capturing every interaction in the app - something which is significantly harder to do for mobile than it is for web.
Hey @maguay , can you expand a bit? What do you mean with tie everything manually? For example in Mixpanel and Amplitude you can easily visualize how many users signed up, performed an action, etc. You just need to send your app events there. Or do you mean that you would like to see what each individual person performs specific actions?
Want to make sure I understand what you are looking for. An example of a use case would be great.
@Charles Essentially wondering if there’s a user analytics tool that can monitor events without you needing to send your app events to it. Basically is there something similar to the way Google Analytics can watch your site for traffic with a single script, or FullStory can watch for any UI event (page load or scroll, text selected, button click) with a similar single script? Which FullStory gets a fair bit of the way there—since you can track a wide range of events simply by watching clicks—but it wouldn’t be as reliable as event tracking where you’re pushing each event to a service.
Got it thanks. Datagran.io pixel does that. It automatically registers al clicks, forms and views. The downside when you don’t send the specific events is that you don’t have specific naming so that you can identify specifically what you want.
In mobile is a bit more complex as well. In there Datagran just tracks the basic stuff.
You just need to send your app events there
I suspect that's what @maguay means by manually as that's how I would describe that. I have worked on apps that had a lot of logging of events and added Flurry to an app that lacked logging. It's a lot of work, although it can be very informative.
In Touchgram, because of an extreme concern with privacy, there's utterly no app event logging. That's made it hard to answer people asking what features get used most. I have some ideas for a safe, utterly anonymous, counter-based approach to at least give me some event usage indication but that's a lot of work.
I would look into Heap Analytics: https://heap.io/. I personally haven't used them (I just go straight data warehouse + SQL + BI tool), but they help fill the gap that you're looking for. You don't need to individually send events, they can pick them up. To my knowledge, they do a good job across application and marketing website so you can see which source of users are most engaged, upgrade, etc.
@S We've actually ended up going with Heap and it's been great so far. The best part so far has been that it's gathering all of your site events, and you can create a new event and it already has been tracking the data so you've got historic data on something you just decided would be helpful to track. Now, adding an event manually was a bit more tricky than I expected in Heap, but Heap's Event Visualizer (which works in Chrome, not Safari) is an incredibly simple way to pick things you want to track.
So far so good. Looking forward to seeing how it works out over time.
We have 15k newsletter subscribers, and have around ~2k of them in a Slack group. We're starting to encounter issues in terms of community management - specifically, it's hard to pin content like c...
Google lets you subscribe to a calendar using a URL - although when using an Outlook 365 Calendar link, events are copied over once, and then the syncing stops. This seems to be a relatively new is...
Three major considerations I have been using to evaluate the plethora of options available: 1. Effortless/non-intrusive: It shouldn't feel like a video call 2. Price: As this app would be complime...
This is an incredible breakdown of product + marketing analytics options, thanks for sharing @dan-hunt!
The first time around we went with Segment for integration (which made it incredibly simple to track events and send them both to marketing tools like Customer.io and to analytics/data tools like Amplitude), and this time we’ve gone closer to your “early stage” stack here with Heap for product analytics and Google Analytics for marketing analytics (doing the integrations manually).
The full open-source stack you mentioned would be tempting; Segment’s costs add up fast, though the cost of maintaining an open-source stack are definitely there too.
So in your experience, Iteratively’s pricing scales better than Segment’s? Have you found any other advantages to using Iteratively versus Segment?