Let's say there's a team lead, and they've given a developer a task. A fairly complex one. They described the concept and suggested a well-known method A to solve it.
The developer studies the concept and silently chooses method B (also well-known) instead. Rolls out the result. The team lead reads it, is surprised by the change of concept, but sees that method B can work at least as well as A. So they let the result through to testing, especially since checking the already implemented method B is faster than demanding to go back to A right away.
During testing, method B fails due to a conflict with an external system S, which the developer had little experience with (the developer who usually handles integrations with S is unavailable). Method B itself is correct, but integration with system S is a requirement of the task. There's no way to predict the compatibility of B and S before implementation.
The developer switches to the originally suggested method A. Method A works as expected, the task gets solved, but with a ~80% overrun of the estimate due to the time spent on B.
System S is external, very niche, has almost no alternatives and is quite innovative. Finding developers with experience in it isn't easy. There is documentation for S, but it's incomplete. As usual, its incompleteness gets worse with every update. Basically, developers work with S once in a lifetime — if they have to. The team lead has a direct line to the CEO of system S, but it's not meant for daily chats about every little thing.
The project manager is unhappy about the overrun and having to explain it to the client. Apparently, a monstrous mistake has been made. But which one?