Computers aren't the source of the failure. Programming isn't the source of the failure.
Algorithms thought of by humans are the source of the failures.
If we get a human to do steps to "login" or "provide receipts", they will make as many, or more, errors than the program that replaces them.
In fact, when you take a set of clear steps and automate them, you get a massive reduction in process errors. This can be so large that you make a different kind of error -- you try to apply the process in cases when it isn't very reliable!
When someone signs into a hotel, for example, the front desk does a bunch of steps involving verifying their identity, checking the payment method, ensuring the room is clean, etc. Prior to computers this was all done without them, using paper records and steps the people involved where supposed to follow.
It was slow, extremely error prone, and cost a bunch of money.
Replacing the steps that humans are bad at with computers doing them made it faster, less error prone, and much cheaper. But when they did this, they also tended to implicitly fold in tasks the computers where not good at into the same workflow, like dealing with exceptions and the like.
So you can get powerless front desk staff who are unable to make the computer make an exception when it is in the business interests of the owner of the hotel and computer to let them do it. And when the computer does make a mistake, there isn't the skills or ability to route around it and fix it.
Computers have replaced entire office buildings full of paper-shufflers. Forms getting mailed in, processed following certain algorithms, totals added up and written on other forms, summaries generated and put on other forms. Typists typing up documents, sometimes in triplicate or more. Secretaries taking memos and categorizing them by importance and presenting them to their executive. All steps we now do with computers for far less cost and far faster.
The computer doesn't always do it better, but it does it with far, far less errors.
The result of this lower error rate is that we pile more systems on top of systems. If you had something that failed 99% of the time, you can't build much on top of it; but you drop that failure rate to 0.001%, you can now treat it as reliable. So you build a system on top of it and 1000 other systems; and now your failure rate is upwards of 1%. You keep doing this, generating value, until the failure rate is high.
The only super complex systems we have are either the result of extensive engineering, like cars or rockets or integrated circuits or manufacturing line or bridges, or are the result of computer programming. Of these, computer programming is by far the cheapest one to prototype and modify and extend.
With this cheap extension and prototyping, you get these insanely complex systems built on a budget that solve problems. But the cost to make them reliable is very high, much higher than the cost to build them and see if they work. So computer programs are almost always written the be cheap and fast.
There is a whole pile of computer programs that are not written this way. Software to control air planes and rockets, for example. And software for medical systems. But even there, the temptation remains; you could either make something cost 100,000x as much and be utterly reliable, or be 100,000x cheaper and fail "very rarely". There is a lot of economic pressure to save a 100,000x cost increase and justify the cheaper way of writing software.
Modern software engineering is the economic management of insanely complex systems. When and where should you spend efforts on making something reliable, and when should you accept the insane cost savings of not ensuring reliability? Every spot you can accept bugs in is a spot that is much cheaper, but also a possible reason your entire project won't work.