I only use Twitter via their PWA installed on my phone.
Also Discourse (where I work) is PWA compatible out of the box, so you can read previously visited topics offline, and install to browse in full screen.
In my view PWA has a limited scope in terms of kind of application which can be made with it. The number of things one need to deal with to build a PWA is just complex, troublesome hard to maintain and hard to debug. Like PWA relying on complex tooling (typical with JS front-end development), implementing local db and associated complexity and security implications (like what to use indexdb or localstorage or something else), making sure relevant data is always in sync with the servers.
So it's much easier to build a native cross-platform app instead of a PWA which is neither optimized for desktop web nor for mobile web (its a hybrid with it's own set of limitations on both the sides). I think framework like flutter is one viable way to build a cross platform desktop and mobile application including web (although it has it's own set of complication for building webapp).
Still I feel the best approach is to build a webapp for desktop browsers and do a mobile cross-platform development using technology like flutter (react native and others are still not very good when it comes to mobile apps). If the mobile app is sufficiently complex than just use SwiftUI or Kotlin directly with common services layer.
- 30% app store payment cut
- users don't like dealing with updating apps all the time
- employees don't like installing apps on their phones for work
unless it is a work phone (not as common anymore)
- cross-platform frameworks have their own bugs and
performance issues
- dealing with app rejections / takedowns / searchability on the app store
There is a lot of accidental complexity in web technologies, but it isn't insurmountable, and there are of course plenty of successful native apps and apps written on cross-platform technologies. At the end of the day, the technology matters less than whether you are solving the problems your customers want you to solve. Many of the technical issues you list are also true for other technologies, cross-platform or not, and picking something that you and your team are comfortable with is almost always the right decision (assuming you aren't trying to do something at the hardware level that PWAs don't have API access to do, of course).
therefore, i have to spend time to read the update changelog, and make a decision to update.
If it was possible to rollback, then i would be inclined to enable auto-update. Case in point - i used to really like the youtube app on android, but newer versions have usability issues, poor video playback on 2x speed (this didn't happen on an even older phone on the old version of the app). And i cannot get the old youtube app version, even if i try to factory reset (it's literally removed from the OS image when i updated android).
It's these reasons, plus more, that i distrust auto-updating.
Like old uTorrent? Riddled with security issues? You're better off with the latest version, or with security backports (these are generally FOSS apps, or vendor supported proprietary software). If an application removes features you wish to keep, and there's an interest in such in the community, a fork generally happens (with FOSS). For proprietary software, there's something like OldVersion.com or APK Mirror. Either way, when developers don't listen to their users, it is time to quit being a user.
Not really, a large majority of mobile applications are nothing more than web widgets doing CRUD workflows.
Everything that I have coded in either Cordova/Ionic (not my decision), is perfectly doable in mobile Web, without having to deal with the platform idiosyncratic, specially on Android.
The PWAs of today are the tip of the iceberg. They've already made huge leaps in the last couple years. Google has talked multiple times recently about their internal goals to bridge the gap between web apps and native apps: https://www.youtube.com/watch?v=JKVZMqpiY7w - In my view, it's just a matter of time before the limits you speak of are non-existent.
For one side I find it over hyped, it is just a bytecode format like many that came before it since UNCOL (1958), oversells security because while it is sandboxed, it won't prevent Heartbleed as bounds checking is only done at the edges of linear memory not to its internal contents, when multiple data structures are mapped into the same linear memory segment.
On the positive note, I find WebAssembly + WebGL/WebGPU has opened the door to the return of Flash like tooling and I am myself playing around with this, being a big fan of ongoing Unity, Blazor, Uno Platform efforts.
Also Discourse (where I work) is PWA compatible out of the box, so you can read previously visited topics offline, and install to browse in full screen.