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.

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.

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.