Agreed, though with the caveat that this is for transactional systems closer to the settlement/long term storage layers where the added assurance is useful. The performance hit for a traditional (linear) log is too large otherwise... though you can do a causally consistent version instead to reclaim some of the performance. But for more analytical workloads, I doubt it.
I'd actually go one step further and predict that in 3-7 years we'll start seeing early-stage startups, in fields completely unrelated to blockchains, using a smart contract enabled enterprise (private) blockchains for the majority of their backends... dropping most of the backend application layer (currently filled by django/rails/etc) in favor of a Vue/React <=JSON=> private blockchain arch.
The _reason_ such a shift might make sense is what you get in return:
- distributed w/ BFT (no _there's a problem with one of the nodes in the etc.d/consul cluster and its down/screwy_ problems)
- complete commoditization of high availability + disaster recovery
- good enough un-sharded write performance (a few 1000 tx's a sec) with unlimited read performance (writes are the expensive part)
- high-security env comes for free
That being said, the current state of smart contracts (specifically solidity but also plutus and tezos') makes this prediction laughable as, at the moment, writing/writing safe blockchain apps is quite difficult. However, if something _like_ Kadena's Pact (disclosure: am founder) finds traction it doesn't look too crazy.
Something like a procedural SQL for key-value DBs + capability-based auth + native REST support... which Pact effectively is when you strip away the blockchain context.
Given that the language is designed for safety and for technical executives/lawyers to be able to read if not write (similar to Excel's/SQL's usability by non-devs) it's stupid simple for a dev to learn. For example, a toy TodoMVC (Vue+Pact): https://github.com/kadena-io/pact-todomvc. Moreover, when you write a contract in Pact you get, for free, a REST API (pact types have native JSON reps) + an RDBMS representation. As if that weren't enough, it has a H-M type system (opt-in) + formal verification.
The only way this prediction can happen is if the smart contract language is far more effective at traditionally app-layer roles (e.g. django, rails). I'm not sure if it'll ever come to pass, but the combo of trivial to learn (and thus hire for) + abundant safety + formal verification could be enough to achieve it.