Web 3/Dweb minus the crypto built on IPFS (or something similar).

I believe many developers will soon come to realize that you don't need a blockchain to build most decentralized applications. Products like like Google Docs, social networks, messaging app, etc don't depend on a proof of stake, and we shouldn't be running miners to power such simple operations. All these applications need isa decentralized form of message distribution and log storage paired with public-key cryptography in order to build a CRDT log. I understand why IPFS in itself at first glance often seems over-hyped, since it is essentially just a hyper-distributed caching layer. However, I highly recommend looking at technologies built on top of it like [OrbitDB](https://github.com/orbitdb/orbit-db) and [Textile](https://textile.io/). When they work reliably, their API is as easy if not easier than other "server-less" products like Firebase or Parse to use. Once libraries like these become mature, I believe the way we build software will be flipped on its head within 10-15 years to be completely client focused with minimal backend infrastructure.

The main advantages I see are:

* Increased reliability. This allows developers to remove almost all of their centralized servers and rely instead on a common infrastructure and protocol.

* Much simpler codebases and infrastructure. You only need to write a frontend for most applications. Building on u/searchableguy's comment: I can see no/low code tooling really taking off with decentralized-first applications, since there is no need to manage a complicated backend infrastructure with vendor lock-in.

* Real-time by default. Since IPFS databases run off of CRDT logs which rely on realtime syncing of new operations, they are benefit from immediate updates at all times – even when not connected to the main swarm out in the boonies.
* Offline-first by default.

* Cost/resource efficiency. No technology is magical, but [this](https://withblue.ink/2019/03/20/hugo-and-ipfs-how-this-blog-...) article from March is an early real world demonstration of how well this technology works already.

* Transport agnostic. It's completely feasible to have your watch, your phone, and your laptop have their IPFS nodes connected over Bluetooth, but never have to worry about if and how they're connected together since IPFS takes care of handling that P2P connectivity automatically. Instead of writing code that says "my watch created a reminder, upload this to the cloud for my laptop and also tell my phone this happened if we're connected," I can just write "my watch created a reminder, broadcast this operation to the IPFS network" and your phone and laptop will automatically receive this update.

* Security. The less that is stored on centralized servers, the better. While OrbitDB is not built to work off an encrypted database yet (it's in the roadmap for v1), Textile already is. Having everything be encrypted by default and optionally never leaving my device has many advantages.

The main challenges I see blocking this from going mainstream:

* Reliability still feels like the early days of the internet. The database-level libraries are still young, IPFS is slow/unreliable at times, and browser support is fairly strong but still has a way to go, and native mobile/native support is nonexistent.

* Filecoin is not ready yet. You still need to run your own IPFS node/swarm in order to do anything serious. Existing pinning services can only go so far if you're working with something like OrbitDB.

* Education. Security is of upmost important when designing technologies like this, so developers need to understand how a CRDT log works, how to build with merge conflicts in mind, and how to write/manage custom ACL for complex interactions. It also takes a different way of thinking to design networks like this.

* Reliability and security audits.

* Transport protocols. At the moment, many of the advantages of P2P over things like Bluetooth have not been realized yet since the IPFS core is still where most of the development is focused at the moment.

* Cross-platform support. IPFS only has an official Go and JavaScript node implementation with a Rust implementation in the works. While Go has become fairly portable in recent years, it still has a very bloated runtime that doesn't embed well on mobile and web. Once we have a reliable Rust port and some OrbitDB-like Rust-based libraries ports, I suspect we'll start seeing ergonomic mobile and web APIs that bind to these popping up.

To be clear, I'm not saying centralized servers will vanish in to thin air. There are many tasks like indexing large amounts of data that are incredibly difficult and not beneficial to build on a distributed network. The decentralized web – if done right – will make developers' lives much easier for many common applications, but there should not be a need to port things that aren't practical to run on the Dweb.

[Edit: Formatting]