From an end user perspective, all I need to do is press a button to connect my wallet, and I'm in. The site doesn't even need to reload or hit a callback uri. It's a much simpler flow than any of the oauth authentication flows. Also, as anyone can create a wallet and it is not tied to any other identifying information, it's a breath of fresh air to have some vague sense of anonymity than hooking everything into a centralized email account.
From a developer standpoint, all I need to do is use an API with a callback function that on success takes whatever data I need and update my application state appropriately. It really is smooth, and I don't need to do things like maintain session or handle access token expiration and request refresh tokens. I can sign messages on the frontend & verify signatures on the backend to ensure the user is who they claim to be. It's so simple compared to the stuff I had to implement in the corporate world for OAuth (granted, the projects I've been working on in the space are much less complex).
If you want to try it out yourself as an end user, just download a wallet extension and check out an nft marketplace such as solanart or opensea. You simply have to connect, and that's it. I find it fascinating personally and it's one of the pieces of web3 that I'm most excited for. I believe we're going to continue to see a lot of innovation in the space.
Having set up a lot of SSO and other auth mechanisms, I think there is a good opportunity for a combination of NFT-access-token + WebAuthn [1]. The nice thing about that would be a secure login without email/passwords combination that you can access with your biometrics. Imagine the same flow as login with 1Password without having to fill the form.
On the developer side, you don't have to setup the OIDC flow, database, or anything. You just rely on a generic service to provide you with a token. Less opportunity to mess it up, and it can work on localhost too.
Now, would be the question of a similar exercise for authorization.
I'm writing an app that utilizes NFT ownership to authorize access to a service, and it's been really easy to implement, though I'm certain I'll need to continue making improvements to it. But my theory is that I can sign a message with my wallet on the frontend using NaCl, send that message and the signature to my backend and verify it, then verify token ownership using RPC. My PoC implementations have been working pretty well, but I am not sure of any holes that may exist in this approach, so it's still a work in progress.
From the user’s perspective I see the (dubious) benefit of being able to use the same key for your money and online accounts, but that’s about it …
The only way I can recommend getting started is the way that I did a few months back - I strongly encourage checking out and entering random hackathons! https://gitcoin.co/hackathons
There's a lot going on in the space currently - many projects are trying to attract development talent so they will sponsor / participate in hackathons. imo they're fantastic opportunities to learn something new and potentially win some extra money.
I'd probably recommend ethereum as a first ecosystem to really dive into - the tooling is more mature than other dev-centric blockchains. However, keep in mind that ethereum as a base can be a tricky place to launch your app because of high transactional fees, and you would likely want to integrate a layer 2 like Arbitrum or support alternative coins in a final application. I'll link some pages to a few technologies I used when building some ethereum dapps
https://www.trufflesuite.com/truffle https://www.trufflesuite.com/ganache
for wallet integration, either of these work https://github.com/ChainSafe/web3.js https://github.com/ethers-io/ethers.js
I highly recommend checking out The Graph too - it allows for you to leverage graphQL on your smart contract data by creating a dedicated subgraph. With some careful integration, you can replace a dedicated backend that would normally be required for various APIs with this. It's a very exciting project imo. https://thegraph.com/en/
And of course, the solidity documentation is very helpful. Coming from a scripting heavy background, solidity was very easy for me to pick up and write a simple escrow service. https://docs.soliditylang.org/en/v0.8.9/
I'd also recommend checking out other chains once you become more comfortable with the system. I'm currently working on Solana and it's a bit more difficult to work with due to the tooling not being as mature, but it is a very interesting chain to work with and I hope that it can scale better than Ethereum has.
A simplified example: You own an NFT and want to prove that you own it.
You can produce some chunk of data (not a transaction) that includes a reference to the NFT (be it the UTxO, Tx, or some hash) and sign it with the same key that owns the NFT (or a derivative key depending on the design of the system).
Since it's not a transaction it doesn't cost anything to produce and you can share it with the interested parties however you wish.
In a sense you can think of it like GPG (and GPG based SSH keys) except instead of the web of trust being a federated set of servers and key cross signing, it's a decentralised ledger.
It's not simpler but it can be easier because it largely comes out of the box set up. The PKI is already well established and you don't need to really spin up or configure anything complicated to use it. You just launch a wallet with the supported features and it "just works".
Also, I really do think that NFT ownership serving as an access token into a service is a very neat feature that we'll start to see more of as people start getting more creative with NFTs instead of simply being an art asset. There's a lot there and we're barely scratching the surface imo.