Yes, it might be useful and straightforward to implement. But I will be sad if something like this would be implemented. I will try to explain.
The only use case for locking notes is to prevent accidents with unwanted changes. But Joplin is a one-person app with a history of notes. For example, I can be cautious with my notes. But even if I mess up something accidentally, I can restore notes from history.
On the other hand, I see how many problems this feature can bring. For example, I start to lock all important notes, so in a couple of years, I will end up with hundreds or thousands of locked notes. Sometimes I have to rearrange my notes (e.g. add tags to many notes at once, move several notes to another notebook, delete several notes). Should "locked" notes interrupt these commands (adding and removing tags, moving or deleting notes)? If so, I will end up with unlocking notes, changing something (e.g. notebook), locking them back. I am sure this feature would be more pain in work than an advantage.
Besides, another solution came into my mind. Let's think about situations when you want to "lock" your note:
- you wrote something important what does not work if would be changed accidentally (contact information, bank accounts, piece of code)
- you wrote a summary of some situation that was accepted by someone (an agreement, meeting minutes, plan of work, strategy)
In both these cases, if you change something in your note, it would not be reliable anymore. But if the "lock" function solves the first use case, it does not solve the second. Because sometimes you need to change your agreement, plan, etc. You should know that the "locked" note was changed and does not contain "accepted" information anymore.
So the solution for both cases would be a "snapshot" for note and not a "lock" function. By doing a snapshot of a note with a comment on why you decided to snapshot it, you will be able to realize why you chose to "lock" this note at first. By highlighting the differences between the current note and snapshot, you will be able to decide what you should do with changes. Either implement them by doing a new snapshot or discharge them by returning to the previous snapshot.
An exclamation mark before note name might highlight notes with a snapshot where the current version is not equal to the snapshot.
Snapshot feature solves problems with unnecessary changes but gives more flexibility for changing notes. For example, you had a note with a friend's phone number, but you can not reach him by this phone. You asked people if he changed the phone and they give you a new one. You add it to note as a new phone. Now your note has a name like "! Mike's contacts". You reached Mike with a new phone, assured that the new phone is correct and made a new snapshot, so now the name does not contain the exclamation mark "Mike's contacts". The same for your code, meeting minutes, agreements and so on. Snapshot is more flexible and solves problems with accidentally changes. But give you possibly to monitor and accept changes if you needed.
Long post, sorry. This is why I do not have good feelings about "simple lock" feature.